summaryrefslogtreecommitdiff
path: root/release/src/router/busybox/shell
diff options
context:
space:
mode:
authorAndreas Baumann <mail@andreasbaumann.cc>2015-01-03 12:04:58 +0100
committerAndreas Baumann <mail@andreasbaumann.cc>2015-01-03 12:04:58 +0100
commit008d0be72b2f160382c6e880765e96b64a050c65 (patch)
tree36f48a98a3815a408e2ce1693dd182af90f80305 /release/src/router/busybox/shell
parent611becfb8726c60cb060368541ad98191d4532f5 (diff)
downloadtomato-008d0be72b2f160382c6e880765e96b64a050c65.tar.gz
tomato-008d0be72b2f160382c6e880765e96b64a050c65.tar.bz2
imported original firmware WRT54GL_v4.30.11_11_US
Diffstat (limited to 'release/src/router/busybox/shell')
-rwxr-xr-xrelease/src/router/busybox/shell/Config.in217
-rw-r--r--release/src/router/busybox/shell/Makefile30
-rwxr-xr-xrelease/src/router/busybox/shell/Makefile.in36
-rw-r--r--release/src/router/busybox/shell/ash.c12742
-rw-r--r--release/src/router/busybox/shell/cmdedit.c1577
-rw-r--r--release/src/router/busybox/shell/cmdedit.h11
-rw-r--r--release/src/router/busybox/shell/hush.c2975
-rw-r--r--release/src/router/busybox/shell/lash.c1649
-rw-r--r--release/src/router/busybox/shell/msh.c4953
9 files changed, 24190 insertions, 0 deletions
diff --git a/release/src/router/busybox/shell/Config.in b/release/src/router/busybox/shell/Config.in
new file mode 100755
index 00000000..c1e90994
--- /dev/null
+++ b/release/src/router/busybox/shell/Config.in
@@ -0,0 +1,217 @@
+#
+# For a description of the syntax of this configuration file,
+# see scripts/kbuild/config-language.txt.
+#
+
+menu "Another Bourne-like Shell"
+
+choice
+ prompt "Choose your default shell"
+ default "none"
+ help
+ Choose a shell. The ash shell is the most bash compatible
+ and full featured.
+
+config CONFIG_FEATURE_SH_IS_ASH
+ bool "ash"
+
+config CONFIG_FEATURE_SH_IS_HUSH
+ bool "hush"
+
+config CONFIG_FEATURE_SH_IS_LASH
+ bool "lash"
+
+config CONFIG_FEATURE_SH_IS_MSH
+ bool "msh"
+
+config CONFIG_FEATURE_SH_IS_NONE
+ bool "none"
+
+endchoice
+
+if CONFIG_FEATURE_SH_IS_ASH
+ config CONFIG_ASH
+ default y
+
+ comment "ash (forced enabled as default shell)"
+endif
+
+if !CONFIG_FEATURE_SH_IS_ASH
+config CONFIG_ASH
+ bool "ash"
+ default y
+ help
+ Make sh a link to ash.
+endif
+
+comment "Ash Shell Options"
+ depends on CONFIG_ASH
+
+config CONFIG_ASH_JOB_CONTROL
+ bool " Enable Job control"
+ default y
+ depends on CONFIG_ASH
+ help
+ Enable job control in the ash shell.
+
+config CONFIG_ASH_ALIAS
+ bool " Enable alias support"
+ default y
+ depends on CONFIG_ASH
+ help
+ Enable alias support in the ash shell.
+
+config CONFIG_ASH_MATH_SUPPORT
+ bool " Enable Posix math support"
+ default y
+ depends on CONFIG_ASH
+ help
+ Enable math support in the ash shell.
+
+config CONFIG_ASH_GETOPTS
+ bool " Enable getopt builtin to parse positional parameters"
+ default n
+ depends on CONFIG_ASH
+ help
+ Enable builtin getopt in the ash shell.
+
+config CONFIG_ASH_CMDCMD
+ bool " Enable cmdcmd to override shell builtins"
+ default n
+ depends on CONFIG_ASH
+ help
+ Enable support for the ash 'command' builtin, which allows
+ you to run the specified command with the specified arguments,
+ even when there is an ash builtin command with the same name.
+
+config CONFIG_ASH_MAIL
+ bool " Check for new mail on interactive shells"
+ default y
+ depends on CONFIG_ASH
+ help
+ Enable "check for new mail" in the ash shell.
+
+config CONFIG_ASH_OPTIMIZE_FOR_SIZE
+ bool " Optimize for size instead of speed"
+ default y
+ depends on CONFIG_ASH
+ help
+ Compile ash for reduced size at price of speed.
+
+if CONFIG_FEATURE_SH_IS_HUSH
+ config CONFIG_HUSH
+ default y
+
+ comment "hush (forced enabled as default shell)"
+endif
+
+if !CONFIG_FEATURE_SH_IS_HUSH
+config CONFIG_HUSH
+ bool "hush"
+ default n
+ help
+ Make sh a link to hush.
+endif
+
+if CONFIG_FEATURE_SH_IS_LASH
+ config CONFIG_LASH
+ default y
+
+ comment "lash (forced enabled as default shell)"
+endif
+
+if !CONFIG_FEATURE_SH_IS_LASH
+config CONFIG_LASH
+ bool "lash"
+ default n
+ help
+ Make sh a link to lash.
+endif
+
+if CONFIG_FEATURE_SH_IS_MSH
+ config CONFIG_MSH
+ default y
+
+ comment "msh (forced enabled as default shell)"
+endif
+
+if !CONFIG_FEATURE_SH_IS_MSH
+config CONFIG_MSH
+ bool "msh"
+ default n
+ help
+ Make sh a link to msh.
+endif
+
+
+comment "Bourne Shell Options"
+ depends on CONFIG_MSH || CONFIG_LASH || CONFIG_HUSH || CONFIG_ASH
+
+config CONFIG_FEATURE_COMMAND_EDITING
+ bool "command line editing"
+ default n
+ depends on CONFIG_MSH || CONFIG_LASH || CONFIG_HUSH || CONFIG_ASH
+ help
+ Enable command editing in shell.
+
+config CONFIG_FEATURE_COMMAND_SAVEHISTORY
+ bool " history saving"
+ default n
+ depends on CONFIG_ASH
+ help
+ Enable history saving in ash shell.
+
+config CONFIG_FEATURE_COMMAND_TAB_COMPLETION
+ bool "tab completion"
+ default n
+ depends on CONFIG_MSH || CONFIG_LASH || CONFIG_HUSH || CONFIG_ASH
+ help
+ Enable tab completion in shell.
+
+config CONFIG_FEATURE_COMMAND_USERNAME_COMPLETION
+ bool "username completion"
+ default n
+ depends on CONFIG_MSH || CONFIG_LASH || CONFIG_HUSH || CONFIG_ASH
+ help
+ Enable username completion in shell.
+
+config CONFIG_FEATURE_COMMAND_HISTORY
+ int "history size"
+ default 15
+ depends on CONFIG_MSH || CONFIG_LASH || CONFIG_HUSH || CONFIG_ASH
+ help
+ Specify command history size in shell.
+
+config CONFIG_FEATURE_SH_STANDALONE_SHELL
+ bool "Standalone shell"
+ default n
+ depends on CONFIG_MSH || CONFIG_LASH || CONFIG_HUSH || CONFIG_ASH
+ help
+ Have all the busybox commands built into the shell, creating
+ a standalone shell.
+
+config CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN
+ bool "Standalone shell -- applets always win"
+ default n
+ depends on CONFIG_MSH || CONFIG_LASH || CONFIG_HUSH || CONFIG_ASH
+ help
+ Use a command builtin to the shell over one with the same name,
+ that may be on the system.
+
+config CONFIG_FEATURE_SH_FANCY_PROMPT
+ bool "Fancy shell prompts"
+ default n
+ depends on CONFIG_MSH || CONFIG_LASH || CONFIG_HUSH || CONFIG_ASH
+ help
+ Setting this option allows for prompts to use things like \w and
+ \$ and also using escape codes.
+
+config CONFIG_FEATURE_SH_EXTRA_QUIET
+ bool "Hide message on interactive shell startup"
+ default n
+ depends on CONFIG_MSH || CONFIG_LASH || CONFIG_HUSH || CONFIG_ASH
+ help
+ Remove the busybox introduction when starting a shell.
+
+endmenu
+
diff --git a/release/src/router/busybox/shell/Makefile b/release/src/router/busybox/shell/Makefile
new file mode 100644
index 00000000..d9940204
--- /dev/null
+++ b/release/src/router/busybox/shell/Makefile
@@ -0,0 +1,30 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
+#
+# 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
+#
+
+TOPDIR:= ../
+SHELL_DIR:=./
+include $(TOPDIR).config
+include $(TOPDIR)Rules.mak
+include Makefile.in
+all: $(libraries-y)
+-include $(TOPDIR).depend
+
+clean:
+ rm -f *.o *.a .depend $(AR_TARGET)
+
diff --git a/release/src/router/busybox/shell/Makefile.in b/release/src/router/busybox/shell/Makefile.in
new file mode 100755
index 00000000..c5be7ba7
--- /dev/null
+++ b/release/src/router/busybox/shell/Makefile.in
@@ -0,0 +1,36 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
+#
+# 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
+
+
+SHELL_AR:=shell.a
+ifndef $(SHELL_DIR)
+SHELL_DIR:=$(TOPDIR)shell/
+endif
+
+SHELLT-y:=
+SHELLT-$(CONFIG_ASH) += ash.o
+SHELLT-$(CONFIG_HUSH) += hush.o
+SHELLT-$(CONFIG_LASH) += lash.o
+SHELLT-$(CONFIG_MSH) += msh.o
+SHELLT-$(CONFIG_FEATURE_COMMAND_EDITING) += cmdedit.o
+
+libraries-y+=$(SHELL_DIR)$(SHELL_AR)
+
+$(SHELL_DIR)$(SHELL_AR): $(patsubst %,$(SHELL_DIR)%, $(SHELLT-y))
+ $(AR) -ro $@ $(patsubst %,$(SHELL_DIR)%, $(SHELLT-y))
+
diff --git a/release/src/router/busybox/shell/ash.c b/release/src/router/busybox/shell/ash.c
new file mode 100644
index 00000000..2b99a325
--- /dev/null
+++ b/release/src/router/busybox/shell/ash.c
@@ -0,0 +1,12742 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * ash shell port for busybox
+ *
+ * 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>
+ * 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
+ *
+ *
+ * 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:
+ * JOBS -> 1 if you have Berkeley job control, 0 otherwise.
+ * define SYSV if you are running under System V.
+ * define DEBUG=1 to compile in debugging ('set -o debug' to turn on)
+ * define DEBUG=2 to compile in and turn on debugging.
+ *
+ * When debugging is on, debugging info will be written to ./trace and
+ * a quit signal will generate a core dump.
+ */
+
+
+
+#define IFS_BROKEN
+
+#define PROFILE 0
+
+#ifdef DEBUG
+#define _GNU_SOURCE
+#endif
+
+#include <sys/types.h>
+#include <sys/cdefs.h>
+#include <sys/ioctl.h>
+#include <sys/param.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <assert.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#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
+
+#if JOBS
+#include <termios.h>
+#endif
+
+#include "cmdedit.h"
+
+#ifdef __GLIBC__
+/* glibc sucks */
+static int *dash_errno;
+#undef errno
+#define errno (*dash_errno)
+#endif
+
+#if defined(__uClinux__)
+#error "Do not even bother, ash will not run on uClinux"
+#endif
+
+#ifdef DEBUG
+#define _DIAGASSERT(assert_expr) assert(assert_expr)
+#else
+#define _DIAGASSERT(assert_expr)
+#endif
+
+
+#ifdef CONFIG_ASH_ALIAS
+/* $NetBSD: alias.h,v 1.5 2002/11/24 22:35:38 christos Exp $ */
+
+#define ALIASINUSE 1
+#define ALIASDEAD 2
+
+struct alias {
+ struct alias *next;
+ char *name;
+ char *val;
+ int flag;
+};
+
+static struct alias *lookupalias(const char *, int);
+static int aliascmd(int, char **);
+static int unaliascmd(int, char **);
+static void rmaliases(void);
+static int unalias(const char *);
+static void printalias(const struct alias *);
+#endif
+
+/* $NetBSD: cd.h,v 1.3 2002/11/24 22:35:39 christos Exp $ */
+
+
+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).
+ */
+
+
+static const char not_found_msg[] = "%s: not found";
+
+
+#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 */
+
+/*
+ * We enclose jmp_buf in a structure so that we can declare pointers to
+ * jump locations. The global variable handler contains the location to
+ * jump to when an exception occurs, and the global variable exception
+ * contains a code identifying the exeception. To implement nested
+ * exception handlers, the user should save the value of handler on entry
+ * to an inner scope, set handler to point to a jmploc structure for the
+ * inner scope, and restore handler on exit from the scope.
+ */
+
+struct jmploc {
+ jmp_buf loc;
+};
+
+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 */
+#define EXINT 0 /* SIGINT received */
+#define EXERROR 1 /* a generic error */
+#define EXSHELLPROC 2 /* execute a shell procedure */
+#define EXEXEC 3 /* command execution failed */
+#define EXEXIT 4 /* exit the shell */
+#define EXSIG 5 /* trapped signal in wait(1) */
+
+
+/* do we generate EXSIG events */
+static int exsig;
+/* last pending signal */
+static volatile sig_atomic_t pendingsigs;
+
+/*
+ * These macros allow the user to suspend the handling of interrupt signals
+ * over a period of time. This is similar to SIGHOLD to or sigblock, but
+ * much more efficient and portable. (But hacking the kernel is so much
+ * more fun than worrying about efficiency and portability. :-))
+ */
+
+#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) {
+ if (--suppressint == 0 && intpending) {
+ onint();
+ }
+}
+#define INTON inton()
+static void forceinton(void)
+{
+ suppressint = 0;
+ if (intpending)
+ onint();
+}
+#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 */
+
+/*
+ * BSD setjmp saves the signal mask, which violates ANSI C and takes time,
+ * so we use _setjmp instead.
+ */
+
+#if defined(BSD) && !defined(__SVR4) && !defined(__GLIBC__)
+#define setjmp(jmploc) _setjmp(jmploc)
+#define longjmp(jmploc, val) _longjmp(jmploc, val)
+#endif
+
+/* $NetBSD: expand.h,v 1.13 2002/11/24 22:35:40 christos Exp $ */
+
+struct strlist {
+ struct strlist *next;
+ char *text;
+};
+
+
+struct arglist {
+ struct strlist *list;
+ struct strlist **lastp;
+};
+
+/*
+ * 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 */
+
+
+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 *);
+
+#ifdef CONFIG_ASH_MATH_SUPPORT
+static void expari(int);
+#endif
+
+/* $NetBSD: eval.h,v 1.13 2002/11/24 22:35:39 christos Exp $ */
+
+static char *commandname; /* currently executing command */
+static struct strlist *cmdenviron; /* environment for builtin command */
+static int exitstatus; /* exit status of last command */
+static int back_exitstatus; /* exit status of backquoted command */
+
+
+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.
+ */
+
+#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
+
+
+
+struct ncmd {
+ int type;
+ union node *assign;
+ union node *args;
+ union node *redirect;
+};
+
+
+struct npipe {
+ int type;
+ int backgnd;
+ struct nodelist *cmdlist;
+};
+
+
+struct nredir {
+ int type;
+ union node *n;
+ union node *redirect;
+};
+
+
+struct nbinary {
+ int type;
+ union node *ch1;
+ union node *ch2;
+};
+
+
+struct nif {
+ int type;
+ union node *test;
+ union node *ifpart;
+ union node *elsepart;
+};
+
+
+struct nfor {
+ int type;
+ union node *args;
+ union node *body;
+ char *var;
+};
+
+
+struct ncase {
+ int type;
+ union node *expr;
+ union node *cases;
+};
+
+
+struct nclist {
+ int type;
+ union node *next;
+ union node *pattern;
+ union node *body;
+};
+
+
+struct narg {
+ int type;
+ union node *next;
+ char *text;
+ struct nodelist *backquote;
+};
+
+
+struct nfile {
+ int type;
+ union node *next;
+ int fd;
+ union node *fname;
+ char *expfname;
+};
+
+
+struct ndup {
+ int type;
+ union node *next;
+ int fd;
+ int dupfd;
+ union node *vname;
+};
+
+
+struct nhere {
+ int type;
+ union node *next;
+ int fd;
+ union node *doc;
+};
+
+
+struct nnot {
+ int 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;
+};
+
+
+struct nodelist {
+ struct nodelist *next;
+ union node *n;
+};
+
+
+struct funcnode {
+ int count;
+ union node n;
+};
+
+
+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 */
+
+/* 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} */
+
+/* values of checkkwd variable */
+#define CHKALIAS 0x1
+#define CHKKWD 0x2
+#define CHKNL 0x4
+
+#define IBUFSIZ (BUFSIZ + 1)
+
+/*
+ * NEOF is returned by parsecmd when it encounters an end of file. It
+ * must be distinct from NULL, so we use the address of a variable that
+ * happens to be handy.
+ */
+static int plinno = 1; /* input line number */
+
+/* number of characters left in input buffer */
+static int parsenleft; /* copy of parsefile->nleft */
+static int parselleft; /* copy of parsefile->lleft */
+
+/* next character in input buffer */
+static char *parsenextc; /* copy of parsefile->nextc */
+static struct parsefile basepf; /* top level input file */
+static char basebuf[IBUFSIZ]; /* buffer for top level input file */
+static struct parsefile *parsefile = &basepf; /* current input file */
+
+
+static int tokpushback; /* last token pushed back */
+#define NEOF ((union node *)&tokpushback)
+static int parsebackquote; /* nonzero if we are inside backquotes */
+static int doprompt; /* if set, prompt the user */
+static int needprompt; /* true if interactive and at start of line */
+static int lasttoken; /* last token read */
+static char *wordtext; /* text of last word returned by readtoken */
+static int checkkwd;
+static struct nodelist *backquotelist;
+static union node *redirnode;
+static struct heredoc *heredoc;
+static int quoteflag; /* set if (part of) last token was quoted */
+static int startlinno; /* line # where last token started */
+
+static 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 $ */
+
+typedef void *pointer;
+
+static char nullstr[1]; /* zero length string */
+static const char spcstr[] = " ";
+static const char snlfmt[] = "%s\n";
+static const char dolatstr[] = { CTLVAR, VSNORMAL|VSQUOTE, '@', '=', '\0' };
+static const char illnum[] = "Illegal number: %s";
+static const char homestr[] = "HOME";
+
+#ifdef DEBUG
+#define TRACE(param) trace param
+#define TRACEV(param) tracev param
+#else
+#define TRACE(param)
+#define TRACEV(param)
+#endif
+
+#if defined(__GNUC__) && __GNUC__ < 3
+#define va_copy __va_copy
+#endif
+
+#if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ < 96)
+#define __builtin_expect(x, expected_value) (x)
+#endif
+
+#define likely(x) __builtin_expect((x),1)
+#define unlikely(x) __builtin_expect((x),0)
+
+#define TEOF 0
+#define TNL 1
+#define TREDIR 2
+#define TWORD 3
+#define TSEMI 4
+#define TBACKGND 5
+#define TAND 6
+#define TOR 7
+#define TPIPE 8
+#define TLP 9
+#define TRP 10
+#define TENDCASE 11
+#define TENDBQUOTE 12
+#define TNOT 13
+#define TCASE 14
+#define TDO 15
+#define TDONE 16
+#define TELIF 17
+#define TELSE 18
+#define TESAC 19
+#define TFI 20
+#define TFOR 21
+#define TIF 22
+#define TIN 23
+#define TTHEN 24
+#define TUNTIL 25
+#define TWHILE 26
+#define TBEGIN 27
+#define TEND 28
+
+/* first char is indicating which tokens mark the end of a list */
+static const char *const tokname_array[] = {
+ "\1end of file",
+ "\0newline",
+ "\0redirection",
+ "\0word",
+ "\0;",
+ "\0&",
+ "\0&&",
+ "\0||",
+ "\0|",
+ "\0(",
+ "\1)",
+ "\1;;",
+ "\1`",
+#define KWDOFFSET 13
+ /* the following are keywords */
+ "\0!",
+ "\0case",
+ "\1do",
+ "\1done",
+ "\1elif",
+ "\1else",
+ "\1esac",
+ "\1fi",
+ "\0for",
+ "\0if",
+ "\0in",
+ "\1then",
+ "\0until",
+ "\0while",
+ "\0{",
+ "\1}",
+};
+
+static const char *tokname(int tok)
+{
+ static char buf[16];
+
+ if (tok >= TSEMI)
+ buf[0] = '"';
+ sprintf(buf + (tok >= TSEMI), "%s%c",
+ tokname_array[tok] + 1, (tok >= TSEMI ? '"' : 0));
+ return buf;
+}
+
+/* $NetBSD: machdep.h,v 1.10 2002/10/07 14:26:08 christos Exp $ */
+
+/*
+ * Most machines require the value returned from malloc to be aligned
+ * in some way. The following macro will get this right on many machines.
+ */
+
+#define SHELL_SIZE (sizeof(union {int i; char *cp; double d; }) - 1)
+/*
+ * It appears that grabstackstr() will barf with such alignments
+ * because stalloc() will return a string allocated in a new stackblock.
+ */
+#define SHELL_ALIGN(nbytes) (((nbytes) + SHELL_SIZE) & ~SHELL_SIZE)
+
+/*
+ * This file was generated by the mksyntax program.
+ */
+
+
+/* Syntax classes */
+#define CWORD 0 /* character is nothing special */
+#define CNL 1 /* newline character */
+#define CBACK 2 /* a backslash character */
+#define CSQUOTE 3 /* single quote */
+#define CDQUOTE 4 /* double quote */
+#define CENDQUOTE 5 /* a terminating quote */
+#define CBQUOTE 6 /* backwards single quote */
+#define CVAR 7 /* a dollar sign */
+#define CENDVAR 8 /* a '}' character */
+#define CLP 9 /* a left paren in arithmetic */
+#define CRP 10 /* a right paren in arithmetic */
+#define CENDFILE 11 /* end of file */
+#define CCTL 12 /* like CWORD, except it must be escaped */
+#define CSPCL 13 /* these terminate a word */
+#define CIGN 14 /* character should be ignored */
+
+#ifdef CONFIG_ASH_ALIAS
+#define SYNBASE 130
+#define PEOF -130
+#define PEOA -129
+#define PEOA_OR_PEOF PEOA
+#else
+#define SYNBASE 129
+#define PEOF -129
+#define PEOA_OR_PEOF PEOF
+#endif
+
+#define is_digit(c) ((unsigned)((c) - '0') <= 9)
+#define is_name(c) ((c) == '_' || isalpha((unsigned char)(c)))
+#define is_in_name(c) ((c) == '_' || isalnum((unsigned char)(c)))
+
+/*
+ * is_special(c) evaluates to 1 for c in "!#$*-0123456789?@"; 0 otherwise
+ * (assuming ascii char codes, as the original implementation did)
+ */
+#define is_special(c) \
+ ( (((unsigned int)c) - 33 < 32) \
+ && ((0xc1ff920dUL >> (((unsigned int)c) - 33)) & 1))
+
+#define digit_val(c) ((c) - '0')
+
+/*
+ * This file was generated by the mksyntax program.
+ */
+
+#ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE
+#define USE_SIT_FUNCTION
+#endif
+
+/* number syntax index */
+#define BASESYNTAX 0 /* not in quotes */
+#define DQSYNTAX 1 /* in double quotes */
+#define SQSYNTAX 2 /* in single quotes */
+#define ARISYNTAX 3 /* in arithmetic */
+
+#ifdef CONFIG_ASH_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, } */
+#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 ... */
+#endif
+};
+#else
+static const char S_I_T[][3] = {
+#ifdef CONFIG_ASH_ALIAS
+ {CSPCL, CIGN, CIGN}, /* 0, PEOA */
+#endif
+ {CSPCL, CWORD, CWORD}, /* 1, ' ' */
+ {CNL, CNL, CNL}, /* 2, \n */
+ {CWORD, CCTL, CCTL}, /* 3, !*-/:=?[]~ */
+ {CDQUOTE, CENDQUOTE, CWORD}, /* 4, '"' */
+ {CVAR, CVAR, CWORD}, /* 5, $ */
+ {CSQUOTE, CWORD, CENDQUOTE}, /* 6, "'" */
+ {CSPCL, CWORD, CWORD}, /* 7, ( */
+ {CSPCL, CWORD, CWORD}, /* 8, ) */
+ {CBACK, CBACK, CCTL}, /* 9, \ */
+ {CBQUOTE, CBQUOTE, CWORD}, /* 10, ` */
+ {CENDVAR, CENDVAR, CWORD}, /* 11, } */
+#ifndef USE_SIT_FUNCTION
+ {CENDFILE, CENDFILE, CENDFILE}, /* 12, PEOF */
+ {CWORD, CWORD, CWORD}, /* 13, 0-9A-Za-z */
+ {CCTL, CCTL, CCTL} /* 14, CTLESC ... */
+#endif
+};
+#endif /* CONFIG_ASH_MATH_SUPPORT */
+
+#ifdef USE_SIT_FUNCTION
+
+#define U_C(c) ((unsigned char)(c))
+
+static int SIT(int c, int syntax)
+{
+ static const char spec_symbls[] = "\t\n !\"$&'()*-/:;<=>?[\\]`|}~";
+#ifdef CONFIG_ASH_ALIAS
+ static const char syntax_index_table[] = {
+ 1, 2, 1, 3, 4, 5, 1, 6, /* "\t\n !\"$&'" */
+ 7, 8, 3, 3, 3, 3, 1, 1, /* "()*-/:;<" */
+ 3, 1, 3, 3, 9, 3, 10, 1, /* "=>?[\\]`|" */
+ 11, 3 /* "}~" */
+ };
+#else
+ static const char syntax_index_table[] = {
+ 0, 1, 0, 2, 3, 4, 0, 5, /* "\t\n !\"$&'" */
+ 6, 7, 2, 2, 2, 2, 0, 0, /* "()*-/:;<" */
+ 2, 0, 2, 2, 8, 2, 9, 0, /* "=>?[\\]`|" */
+ 10, 2 /* "}~" */
+ };
+#endif
+ const char *s;
+ int indx;
+
+ if (c == PEOF) /* 2^8+2 */
+ return CENDFILE;
+#ifdef CONFIG_ASH_ALIAS
+ if (c == PEOA) /* 2^8+1 */
+ indx = 0;
+ else
+#endif
+ if (U_C(c) >= U_C(CTLESC) && U_C(c) <= U_C(CTLQUOTEMARK))
+ return CCTL;
+ else {
+ s = strchr(spec_symbls, c);
+ if (s == 0 || *s == 0)
+ return CWORD;
+ 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
+#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
+ /* 1 PEOA */ CSPCL_CIGN_CIGN_CIGN,
+#endif
+ /* 2 -128 0x80 */ CWORD_CWORD_CWORD_CWORD,
+ /* 3 -127 CTLESC */ CCTL_CCTL_CCTL_CCTL,
+ /* 4 -126 CTLVAR */ CCTL_CCTL_CCTL_CCTL,
+ /* 5 -125 CTLENDVAR */ CCTL_CCTL_CCTL_CCTL,
+ /* 6 -124 CTLBACKQ */ CCTL_CCTL_CCTL_CCTL,
+ /* 7 -123 CTLQUOTE */ CCTL_CCTL_CCTL_CCTL,
+ /* 8 -122 CTLARI */ CCTL_CCTL_CCTL_CCTL,
+ /* 9 -121 CTLENDARI */ CCTL_CCTL_CCTL_CCTL,
+ /* 10 -120 CTLQUOTEMARK */ CCTL_CCTL_CCTL_CCTL,
+ /* 11 -119 */ CWORD_CWORD_CWORD_CWORD,
+ /* 12 -118 */ CWORD_CWORD_CWORD_CWORD,
+ /* 13 -117 */ CWORD_CWORD_CWORD_CWORD,
+ /* 14 -116 */ CWORD_CWORD_CWORD_CWORD,
+ /* 15 -115 */ CWORD_CWORD_CWORD_CWORD,
+ /* 16 -114 */ CWORD_CWORD_CWORD_CWORD,
+ /* 17 -113 */ CWORD_CWORD_CWORD_CWORD,
+ /* 18 -112 */ CWORD_CWORD_CWORD_CWORD,
+ /* 19 -111 */ CWORD_CWORD_CWORD_CWORD,
+ /* 20 -110 */ CWORD_CWORD_CWORD_CWORD,
+ /* 21 -109 */ CWORD_CWORD_CWORD_CWORD,
+ /* 22 -108 */ CWORD_CWORD_CWORD_CWORD,
+ /* 23 -107 */ CWORD_CWORD_CWORD_CWORD,
+ /* 24 -106 */ CWORD_CWORD_CWORD_CWORD,
+ /* 25 -105 */ CWORD_CWORD_CWORD_CWORD,
+ /* 26 -104 */ CWORD_CWORD_CWORD_CWORD,
+ /* 27 -103 */ CWORD_CWORD_CWORD_CWORD,
+ /* 28 -102 */ CWORD_CWORD_CWORD_CWORD,
+ /* 29 -101 */ CWORD_CWORD_CWORD_CWORD,
+ /* 30 -100 */ CWORD_CWORD_CWORD_CWORD,
+ /* 31 -99 */ CWORD_CWORD_CWORD_CWORD,
+ /* 32 -98 */ CWORD_CWORD_CWORD_CWORD,
+ /* 33 -97 */ CWORD_CWORD_CWORD_CWORD,
+ /* 34 -96 */ CWORD_CWORD_CWORD_CWORD,
+ /* 35 -95 */ CWORD_CWORD_CWORD_CWORD,
+ /* 36 -94 */ CWORD_CWORD_CWORD_CWORD,
+ /* 37 -93 */ CWORD_CWORD_CWORD_CWORD,
+ /* 38 -92 */ CWORD_CWORD_CWORD_CWORD,
+ /* 39 -91 */ CWORD_CWORD_CWORD_CWORD,
+ /* 40 -90 */ CWORD_CWORD_CWORD_CWORD,
+ /* 41 -89 */ CWORD_CWORD_CWORD_CWORD,
+ /* 42 -88 */ CWORD_CWORD_CWORD_CWORD,
+ /* 43 -87 */ CWORD_CWORD_CWORD_CWORD,
+ /* 44 -86 */ CWORD_CWORD_CWORD_CWORD,
+ /* 45 -85 */ CWORD_CWORD_CWORD_CWORD,
+ /* 46 -84 */ CWORD_CWORD_CWORD_CWORD,
+ /* 47 -83 */ CWORD_CWORD_CWORD_CWORD,
+ /* 48 -82 */ CWORD_CWORD_CWORD_CWORD,
+ /* 49 -81 */ CWORD_CWORD_CWORD_CWORD,
+ /* 50 -80 */ CWORD_CWORD_CWORD_CWORD,
+ /* 51 -79 */ CWORD_CWORD_CWORD_CWORD,
+ /* 52 -78 */ CWORD_CWORD_CWORD_CWORD,
+ /* 53 -77 */ CWORD_CWORD_CWORD_CWORD,
+ /* 54 -76 */ CWORD_CWORD_CWORD_CWORD,
+ /* 55 -75 */ CWORD_CWORD_CWORD_CWORD,
+ /* 56 -74 */ CWORD_CWORD_CWORD_CWORD,
+ /* 57 -73 */ CWORD_CWORD_CWORD_CWORD,
+ /* 58 -72 */ CWORD_CWORD_CWORD_CWORD,
+ /* 59 -71 */ CWORD_CWORD_CWORD_CWORD,
+ /* 60 -70 */ CWORD_CWORD_CWORD_CWORD,
+ /* 61 -69 */ CWORD_CWORD_CWORD_CWORD,
+ /* 62 -68 */ CWORD_CWORD_CWORD_CWORD,
+ /* 63 -67 */ CWORD_CWORD_CWORD_CWORD,
+ /* 64 -66 */ CWORD_CWORD_CWORD_CWORD,
+ /* 65 -65 */ CWORD_CWORD_CWORD_CWORD,
+ /* 66 -64 */ CWORD_CWORD_CWORD_CWORD,
+ /* 67 -63 */ CWORD_CWORD_CWORD_CWORD,
+ /* 68 -62 */ CWORD_CWORD_CWORD_CWORD,
+ /* 69 -61 */ CWORD_CWORD_CWORD_CWORD,
+ /* 70 -60 */ CWORD_CWORD_CWORD_CWORD,
+ /* 71 -59 */ CWORD_CWORD_CWORD_CWORD,
+ /* 72 -58 */ CWORD_CWORD_CWORD_CWORD,
+ /* 73 -57 */ CWORD_CWORD_CWORD_CWORD,
+ /* 74 -56 */ CWORD_CWORD_CWORD_CWORD,
+ /* 75 -55 */ CWORD_CWORD_CWORD_CWORD,
+ /* 76 -54 */ CWORD_CWORD_CWORD_CWORD,
+ /* 77 -53 */ CWORD_CWORD_CWORD_CWORD,
+ /* 78 -52 */ CWORD_CWORD_CWORD_CWORD,
+ /* 79 -51 */ CWORD_CWORD_CWORD_CWORD,
+ /* 80 -50 */ CWORD_CWORD_CWORD_CWORD,
+ /* 81 -49 */ CWORD_CWORD_CWORD_CWORD,
+ /* 82 -48 */ CWORD_CWORD_CWORD_CWORD,
+ /* 83 -47 */ CWORD_CWORD_CWORD_CWORD,
+ /* 84 -46 */ CWORD_CWORD_CWORD_CWORD,
+ /* 85 -45 */ CWORD_CWORD_CWORD_CWORD,
+ /* 86 -44 */ CWORD_CWORD_CWORD_CWORD,
+ /* 87 -43 */ CWORD_CWORD_CWORD_CWORD,
+ /* 88 -42 */ CWORD_CWORD_CWORD_CWORD,
+ /* 89 -41 */ CWORD_CWORD_CWORD_CWORD,
+ /* 90 -40 */ CWORD_CWORD_CWORD_CWORD,
+ /* 91 -39 */ CWORD_CWORD_CWORD_CWORD,
+ /* 92 -38 */ CWORD_CWORD_CWORD_CWORD,
+ /* 93 -37 */ CWORD_CWORD_CWORD_CWORD,
+ /* 94 -36 */ CWORD_CWORD_CWORD_CWORD,
+ /* 95 -35 */ CWORD_CWORD_CWORD_CWORD,
+ /* 96 -34 */ CWORD_CWORD_CWORD_CWORD,
+ /* 97 -33 */ CWORD_CWORD_CWORD_CWORD,
+ /* 98 -32 */ CWORD_CWORD_CWORD_CWORD,
+ /* 99 -31 */ CWORD_CWORD_CWORD_CWORD,
+ /* 100 -30 */ CWORD_CWORD_CWORD_CWORD,
+ /* 101 -29 */ CWORD_CWORD_CWORD_CWORD,
+ /* 102 -28 */ CWORD_CWORD_CWORD_CWORD,
+ /* 103 -27 */ CWORD_CWORD_CWORD_CWORD,
+ /* 104 -26 */ CWORD_CWORD_CWORD_CWORD,
+ /* 105 -25 */ CWORD_CWORD_CWORD_CWORD,
+ /* 106 -24 */ CWORD_CWORD_CWORD_CWORD,
+ /* 107 -23 */ CWORD_CWORD_CWORD_CWORD,
+ /* 108 -22 */ CWORD_CWORD_CWORD_CWORD,
+ /* 109 -21 */ CWORD_CWORD_CWORD_CWORD,
+ /* 110 -20 */ CWORD_CWORD_CWORD_CWORD,
+ /* 111 -19 */ CWORD_CWORD_CWORD_CWORD,
+ /* 112 -18 */ CWORD_CWORD_CWORD_CWORD,
+ /* 113 -17 */ CWORD_CWORD_CWORD_CWORD,
+ /* 114 -16 */ CWORD_CWORD_CWORD_CWORD,
+ /* 115 -15 */ CWORD_CWORD_CWORD_CWORD,
+ /* 116 -14 */ CWORD_CWORD_CWORD_CWORD,
+ /* 117 -13 */ CWORD_CWORD_CWORD_CWORD,
+ /* 118 -12 */ CWORD_CWORD_CWORD_CWORD,
+ /* 119 -11 */ CWORD_CWORD_CWORD_CWORD,
+ /* 120 -10 */ CWORD_CWORD_CWORD_CWORD,
+ /* 121 -9 */ CWORD_CWORD_CWORD_CWORD,
+ /* 122 -8 */ CWORD_CWORD_CWORD_CWORD,
+ /* 123 -7 */ CWORD_CWORD_CWORD_CWORD,
+ /* 124 -6 */ CWORD_CWORD_CWORD_CWORD,
+ /* 125 -5 */ CWORD_CWORD_CWORD_CWORD,
+ /* 126 -4 */ CWORD_CWORD_CWORD_CWORD,
+ /* 127 -3 */ CWORD_CWORD_CWORD_CWORD,
+ /* 128 -2 */ CWORD_CWORD_CWORD_CWORD,
+ /* 129 -1 */ CWORD_CWORD_CWORD_CWORD,
+ /* 130 0 */ CWORD_CWORD_CWORD_CWORD,
+ /* 131 1 */ CWORD_CWORD_CWORD_CWORD,
+ /* 132 2 */ CWORD_CWORD_CWORD_CWORD,
+ /* 133 3 */ CWORD_CWORD_CWORD_CWORD,
+ /* 134 4 */ CWORD_CWORD_CWORD_CWORD,
+ /* 135 5 */ CWORD_CWORD_CWORD_CWORD,
+ /* 136 6 */ CWORD_CWORD_CWORD_CWORD,
+ /* 137 7 */ CWORD_CWORD_CWORD_CWORD,
+ /* 138 8 */ CWORD_CWORD_CWORD_CWORD,
+ /* 139 9 "\t" */ CSPCL_CWORD_CWORD_CWORD,
+ /* 140 10 "\n" */ CNL_CNL_CNL_CNL,
+ /* 141 11 */ CWORD_CWORD_CWORD_CWORD,
+ /* 142 12 */ CWORD_CWORD_CWORD_CWORD,
+ /* 143 13 */ CWORD_CWORD_CWORD_CWORD,
+ /* 144 14 */ CWORD_CWORD_CWORD_CWORD,
+ /* 145 15 */ CWORD_CWORD_CWORD_CWORD,
+ /* 146 16 */ CWORD_CWORD_CWORD_CWORD,
+ /* 147 17 */ CWORD_CWORD_CWORD_CWORD,
+ /* 148 18 */ CWORD_CWORD_CWORD_CWORD,
+ /* 149 19 */ CWORD_CWORD_CWORD_CWORD,
+ /* 150 20 */ CWORD_CWORD_CWORD_CWORD,
+ /* 151 21 */ CWORD_CWORD_CWORD_CWORD,
+ /* 152 22 */ CWORD_CWORD_CWORD_CWORD,
+ /* 153 23 */ CWORD_CWORD_CWORD_CWORD,
+ /* 154 24 */ CWORD_CWORD_CWORD_CWORD,
+ /* 155 25 */ CWORD_CWORD_CWORD_CWORD,
+ /* 156 26 */ CWORD_CWORD_CWORD_CWORD,
+ /* 157 27 */ CWORD_CWORD_CWORD_CWORD,
+ /* 158 28 */ CWORD_CWORD_CWORD_CWORD,
+ /* 159 29 */ CWORD_CWORD_CWORD_CWORD,
+ /* 160 30 */ CWORD_CWORD_CWORD_CWORD,
+ /* 161 31 */ CWORD_CWORD_CWORD_CWORD,
+ /* 162 32 " " */ CSPCL_CWORD_CWORD_CWORD,
+ /* 163 33 "!" */ CWORD_CCTL_CCTL_CWORD,
+ /* 164 34 """ */ CDQUOTE_CENDQUOTE_CWORD_CWORD,
+ /* 165 35 "#" */ CWORD_CWORD_CWORD_CWORD,
+ /* 166 36 "$" */ CVAR_CVAR_CWORD_CVAR,
+ /* 167 37 "%" */ CWORD_CWORD_CWORD_CWORD,
+ /* 168 38 "&" */ CSPCL_CWORD_CWORD_CWORD,
+ /* 169 39 "'" */ CSQUOTE_CWORD_CENDQUOTE_CWORD,
+ /* 170 40 "(" */ CSPCL_CWORD_CWORD_CLP,
+ /* 171 41 ")" */ CSPCL_CWORD_CWORD_CRP,
+ /* 172 42 "*" */ CWORD_CCTL_CCTL_CWORD,
+ /* 173 43 "+" */ CWORD_CWORD_CWORD_CWORD,
+ /* 174 44 "," */ CWORD_CWORD_CWORD_CWORD,
+ /* 175 45 "-" */ CWORD_CCTL_CCTL_CWORD,
+ /* 176 46 "." */ CWORD_CWORD_CWORD_CWORD,
+ /* 177 47 "/" */ CWORD_CCTL_CCTL_CWORD,
+ /* 178 48 "0" */ CWORD_CWORD_CWORD_CWORD,
+ /* 179 49 "1" */ CWORD_CWORD_CWORD_CWORD,
+ /* 180 50 "2" */ CWORD_CWORD_CWORD_CWORD,
+ /* 181 51 "3" */ CWORD_CWORD_CWORD_CWORD,
+ /* 182 52 "4" */ CWORD_CWORD_CWORD_CWORD,
+ /* 183 53 "5" */ CWORD_CWORD_CWORD_CWORD,
+ /* 184 54 "6" */ CWORD_CWORD_CWORD_CWORD,
+ /* 185 55 "7" */ CWORD_CWORD_CWORD_CWORD,
+ /* 186 56 "8" */ CWORD_CWORD_CWORD_CWORD,
+ /* 187 57 "9" */ CWORD_CWORD_CWORD_CWORD,
+ /* 188 58 ":" */ CWORD_CCTL_CCTL_CWORD,
+ /* 189 59 ";" */ CSPCL_CWORD_CWORD_CWORD,
+ /* 190 60 "<" */ CSPCL_CWORD_CWORD_CWORD,
+ /* 191 61 "=" */ CWORD_CCTL_CCTL_CWORD,
+ /* 192 62 ">" */ CSPCL_CWORD_CWORD_CWORD,
+ /* 193 63 "?" */ CWORD_CCTL_CCTL_CWORD,
+ /* 194 64 "@" */ CWORD_CWORD_CWORD_CWORD,
+ /* 195 65 "A" */ CWORD_CWORD_CWORD_CWORD,
+ /* 196 66 "B" */ CWORD_CWORD_CWORD_CWORD,
+ /* 197 67 "C" */ CWORD_CWORD_CWORD_CWORD,
+ /* 198 68 "D" */ CWORD_CWORD_CWORD_CWORD,
+ /* 199 69 "E" */ CWORD_CWORD_CWORD_CWORD,
+ /* 200 70 "F" */ CWORD_CWORD_CWORD_CWORD,
+ /* 201 71 "G" */ CWORD_CWORD_CWORD_CWORD,
+ /* 202 72 "H" */ CWORD_CWORD_CWORD_CWORD,
+ /* 203 73 "I" */ CWORD_CWORD_CWORD_CWORD,
+ /* 204 74 "J" */ CWORD_CWORD_CWORD_CWORD,
+ /* 205 75 "K" */ CWORD_CWORD_CWORD_CWORD,
+ /* 206 76 "L" */ CWORD_CWORD_CWORD_CWORD,
+ /* 207 77 "M" */ CWORD_CWORD_CWORD_CWORD,
+ /* 208 78 "N" */ CWORD_CWORD_CWORD_CWORD,
+ /* 209 79 "O" */ CWORD_CWORD_CWORD_CWORD,
+ /* 210 80 "P" */ CWORD_CWORD_CWORD_CWORD,
+ /* 211 81 "Q" */ CWORD_CWORD_CWORD_CWORD,
+ /* 212 82 "R" */ CWORD_CWORD_CWORD_CWORD,
+ /* 213 83 "S" */ CWORD_CWORD_CWORD_CWORD,
+ /* 214 84 "T" */ CWORD_CWORD_CWORD_CWORD,
+ /* 215 85 "U" */ CWORD_CWORD_CWORD_CWORD,
+ /* 216 86 "V" */ CWORD_CWORD_CWORD_CWORD,
+ /* 217 87 "W" */ CWORD_CWORD_CWORD_CWORD,
+ /* 218 88 "X" */ CWORD_CWORD_CWORD_CWORD,
+ /* 219 89 "Y" */ CWORD_CWORD_CWORD_CWORD,
+ /* 220 90 "Z" */ CWORD_CWORD_CWORD_CWORD,
+ /* 221 91 "[" */ CWORD_CCTL_CCTL_CWORD,
+ /* 222 92 "\" */ CBACK_CBACK_CCTL_CBACK,
+ /* 223 93 "]" */ CWORD_CCTL_CCTL_CWORD,
+ /* 224 94 "^" */ CWORD_CWORD_CWORD_CWORD,
+ /* 225 95 "_" */ CWORD_CWORD_CWORD_CWORD,
+ /* 226 96 "`" */ CBQUOTE_CBQUOTE_CWORD_CBQUOTE,
+ /* 227 97 "a" */ CWORD_CWORD_CWORD_CWORD,
+ /* 228 98 "b" */ CWORD_CWORD_CWORD_CWORD,
+ /* 229 99 "c" */ CWORD_CWORD_CWORD_CWORD,
+ /* 230 100 "d" */ CWORD_CWORD_CWORD_CWORD,
+ /* 231 101 "e" */ CWORD_CWORD_CWORD_CWORD,
+ /* 232 102 "f" */ CWORD_CWORD_CWORD_CWORD,
+ /* 233 103 "g" */ CWORD_CWORD_CWORD_CWORD,
+ /* 234 104 "h" */ CWORD_CWORD_CWORD_CWORD,
+ /* 235 105 "i" */ CWORD_CWORD_CWORD_CWORD,
+ /* 236 106 "j" */ CWORD_CWORD_CWORD_CWORD,
+ /* 237 107 "k" */ CWORD_CWORD_CWORD_CWORD,
+ /* 238 108 "l" */ CWORD_CWORD_CWORD_CWORD,
+ /* 239 109 "m" */ CWORD_CWORD_CWORD_CWORD,
+ /* 240 110 "n" */ CWORD_CWORD_CWORD_CWORD,
+ /* 241 111 "o" */ CWORD_CWORD_CWORD_CWORD,
+ /* 242 112 "p" */ CWORD_CWORD_CWORD_CWORD,
+ /* 243 113 "q" */ CWORD_CWORD_CWORD_CWORD,
+ /* 244 114 "r" */ CWORD_CWORD_CWORD_CWORD,
+ /* 245 115 "s" */ CWORD_CWORD_CWORD_CWORD,
+ /* 246 116 "t" */ CWORD_CWORD_CWORD_CWORD,
+ /* 247 117 "u" */ CWORD_CWORD_CWORD_CWORD,
+ /* 248 118 "v" */ CWORD_CWORD_CWORD_CWORD,
+ /* 249 119 "w" */ CWORD_CWORD_CWORD_CWORD,
+ /* 250 120 "x" */ CWORD_CWORD_CWORD_CWORD,
+ /* 251 121 "y" */ CWORD_CWORD_CWORD_CWORD,
+ /* 252 122 "z" */ CWORD_CWORD_CWORD_CWORD,
+ /* 253 123 "{" */ CWORD_CWORD_CWORD_CWORD,
+ /* 254 124 "|" */ CSPCL_CWORD_CWORD_CWORD,
+ /* 255 125 "}" */ CENDVAR_CENDVAR_CWORD_CENDVAR,
+ /* 256 126 "~" */ CWORD_CCTL_CCTL_CWORD,
+ /* 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 defpath (defpathvar + 5)
+
+/*
+ * 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 */
+};
+
+/*
+ * The parsefile structure pointed to by the global variable parsefile
+ * contains information about the current file being read.
+ */
+
+
+struct redirtab {
+ struct redirtab *next;
+ int renamed[10];
+ int nullredirs;
+};
+
+static struct redirtab *redirlist;
+static int nullredirs;
+
+extern char **environ;
+
+/* $NetBSD: output.h,v 1.16 2002/11/24 22:35:42 christos Exp $ */
+
+
+static void outstr(const char *, FILE *);
+static void outcslow(int, FILE *);
+static void flushall(void);
+static void flushout(FILE *);
+static int out1fmt(const char *, ...)
+ __attribute__((__format__(__printf__,1,2)));
+static int fmtstr(char *, size_t, const char *, ...)
+ __attribute__((__format__(__printf__,3,4)));
+static void xwrite(int, const void *, size_t);
+
+
+#define outerr(f) ferror(f)
+#define out2c(c) outcslow((c), stderr)
+
+static void out1str(const char *p)
+{
+ outstr(p, stdout);
+}
+
+static void out2str(const char *p)
+{
+ outstr(p, stderr);
+}
+
+static void out1c(char c)
+{
+ char s[2];
+
+ s[0] = c;
+ s[1] = 0;
+ outstr(s, stdout);
+}
+
+/*
+ * Initialization code.
+ */
+
+/*
+ * This routine initializes the builtin variables.
+ */
+
+static inline void
+initvar(void)
+{
+ struct var *vp;
+ struct var *end;
+ struct var **vpp;
+
+ /*
+ * PS1 depends on uid
+ */
+#if defined(CONFIG_FEATURE_COMMAND_EDITING) && defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
+ vps1.text = "PS1=\\w \\$ ";
+#else
+ if (!geteuid())
+ vps1.text = "PS1=# ";
+#endif
+ vp = varinit;
+ end = vp + sizeof(varinit) / sizeof(varinit[0]);
+ do {
+ vpp = hashvar(vp->text);
+ vp->next = *vpp;
+ *vpp = vp;
+ } while (++vp < end);
+}
+
+static inline void
+init(void)
+{
+
+ /* from input.c: */
+ {
+ basepf.nextc = basepf.buf = basebuf;
+ }
+
+ /* from trap.c: */
+ {
+ signal(SIGCHLD, SIG_DFL);
+ }
+
+ /* from var.c: */
+ {
+ char **envp;
+ char ppid[32];
+
+ initvar();
+ for (envp = environ ; *envp ; envp++) {
+ if (strchr(*envp, '=')) {
+ setvareq(*envp, VEXPORT|VTEXTFIXED);
+ }
+ }
+
+ snprintf(ppid, sizeof(ppid), "%d", (int) getppid());
+ setvar("PPID", ppid, 0);
+ setpwd(0, 0);
+ }
+}
+
+/* PEOF (the end of file marker) */
+
+/*
+ * The input line number. Input.c just defines this variable, and saves
+ * and restores it when files are pushed and popped. The user of this
+ * package must set its value.
+ */
+
+static int pgetc(void);
+static int pgetc2(void);
+static int preadbuffer(void);
+static void pungetc(void);
+static void pushstring(char *, void *);
+static void popstring(void);
+static void setinputfile(const char *, int);
+static void setinputfd(int, int);
+static void setinputstring(char *);
+static void popfile(void);
+static void popallfiles(void);
+static void closescript(void);
+
+
+/* $NetBSD: jobs.h,v 1.17 2003/01/22 20:36:04 dsl Exp $ */
+
+
+/* Mode argument to forkshell. Don't change FORK_FG or FORK_BG. */
+#define FORK_FG 0
+#define FORK_BG 1
+#define FORK_NOJOB 2
+
+/* mode flags for showjob(s) */
+#define SHOW_PGID 0x01 /* only show pgid - for jobs -p */
+#define SHOW_PID 0x04 /* include process pid */
+#define SHOW_CHANGED 0x08 /* only jobs whose state has changed */
+
+
+/*
+ * A job structure contains information about a job. A job is either a
+ * single process or a set of processes contained in a pipeline. In the
+ * latter case, pidlist will be non-NULL, and will point to a -1 terminated
+ * array of pids.
+ */
+
+struct procstat {
+ pid_t pid; /* process id */
+ int status; /* last process status from wait() */
+ char *cmd; /* text of command being run */
+};
+
+struct job {
+ struct procstat ps0; /* status of process */
+ struct procstat *ps; /* status or processes when more than one */
+#if JOBS
+ int stopstatus; /* status of a stopped job */
+#endif
+ uint32_t
+ nprocs: 16, /* number of processes */
+ state: 8,
+#define JOBRUNNING 0 /* at least one proc running */
+#define JOBSTOPPED 1 /* all procs are stopped */
+#define JOBDONE 2 /* all procs are completed */
+#if JOBS
+ sigint: 1, /* job was killed by SIGINT */
+ jobctl: 1, /* job running under job control */
+#endif
+ waited: 1, /* true if this entry has been waited for */
+ used: 1, /* true if this entry is in used */
+ changed: 1; /* true if status has changed */
+ struct job *prev_job; /* previous job */
+};
+
+static pid_t backgndpid; /* pid of last background process */
+static int job_warning; /* user was warned about stopped jobs */
+#if JOBS
+static int jobctl; /* true if doing job control */
+#endif
+
+static struct job *makejob(union node *, int);
+static int forkshell(struct job *, union node *, int);
+static int waitforjob(struct job *);
+static int stoppedjobs(void);
+
+#if ! JOBS
+#define setjobctl(on) /* do nothing */
+#else
+static void setjobctl(int);
+static void showjobs(FILE *, int);
+#endif
+
+/* $NetBSD: main.h,v 1.9 2002/11/24 22:35:41 christos Exp $ */
+
+
+/* pid of main shell */
+static int rootpid;
+/* true if we aren't a child of the main shell */
+static int rootshell;
+
+static void readcmdfile(char *);
+static void cmdloop(int);
+
+/* $NetBSD: memalloc.h,v 1.13 2003/01/22 20:36:04 dsl Exp $ */
+
+
+struct stackmark {
+ struct stack_block *stackp;
+ char *stacknxt;
+ size_t stacknleft;
+ struct stackmark *marknext;
+};
+
+/* minimum size of a block */
+#define MINSIZE SHELL_ALIGN(504)
+
+struct stack_block {
+ struct stack_block *prev;
+ char space[MINSIZE];
+};
+
+static struct stack_block stackbase;
+static struct stack_block *stackp = &stackbase;
+static struct stackmark *markp;
+static char *stacknxt = stackbase.space;
+static size_t stacknleft = MINSIZE;
+static char *sstrend = stackbase.space + MINSIZE;
+static int herefd = -1;
+
+
+static pointer ckmalloc(size_t);
+static pointer ckrealloc(pointer, size_t);
+static char *savestr(const char *);
+static pointer stalloc(size_t);
+static void stunalloc(pointer);
+static void setstackmark(struct stackmark *);
+static void popstackmark(struct stackmark *);
+static void growstackblock(void);
+static void *growstackstr(void);
+static char *makestrspace(size_t, char *);
+static char *stnputs(const char *, size_t, char *);
+static char *stputs(const char *, char *);
+
+
+static inline char *_STPUTC(char c, char *p) {
+ if (p == sstrend)
+ p = growstackstr();
+ *p++ = c;
+ return p;
+}
+
+#define stackblock() ((void *)stacknxt)
+#define stackblocksize() stacknleft
+#define STARTSTACKSTR(p) ((p) = stackblock())
+#define STPUTC(c, p) ((p) = _STPUTC((c), (p)))
+#define CHECKSTRSPACE(n, p) \
+ ({ \
+ char *q = (p); \
+ size_t l = (n); \
+ size_t m = sstrend - q; \
+ if (l > m) \
+ (p) = makestrspace(l, q); \
+ 0; \
+ })
+#define USTPUTC(c, p) (*p++ = (c))
+#define STACKSTRNUL(p) ((p) == sstrend? (p = growstackstr(), *p = '\0') : (*p = '\0'))
+#define STUNPUTC(p) (--p)
+#define STTOPC(p) p[-1]
+#define STADJUST(amount, p) (p += (amount))
+
+#define grabstackstr(p) stalloc((char *)(p) - (char *)stackblock())
+#define ungrabstackstr(s, p) stunalloc((s))
+#define stackstrend() ((void *)sstrend)
+
+#define ckfree(p) free((pointer)(p))
+
+/* $NetBSD: mystring.h,v 1.10 2002/11/24 22:35:42 christos Exp $ */
+
+
+#define DOLATSTRLEN 4
+
+static char *prefix(const char *, const char *);
+static int number(const char *);
+static int is_number(const char *);
+static char *single_quote(const char *);
+static char *sstrdup(const char *);
+
+#define equal(s1, s2) (strcmp(s1, s2) == 0)
+#define scopy(s1, s2) ((void)strcpy(s2, s1))
+
+/* $NetBSD: options.h,v 1.16 2003/01/22 20:36:04 dsl Exp $ */
+
+struct shparam {
+ int nparam; /* # of positional parameters (without $0) */
+ unsigned char malloc; /* if parameter list dynamically allocated */
+ char **p; /* parameter list */
+#ifdef CONFIG_ASH_GETOPTS
+ int optind; /* next parameter to be processed by getopts */
+ int optoff; /* used by getopts */
+#endif
+};
+
+
+#define eflag optlist[0]
+#define fflag optlist[1]
+#define Iflag optlist[2]
+#define iflag optlist[3]
+#define mflag optlist[4]
+#define nflag optlist[5]
+#define sflag optlist[6]
+#define xflag optlist[7]
+#define vflag optlist[8]
+#define Cflag optlist[9]
+#define aflag optlist[10]
+#define bflag optlist[11]
+#define uflag optlist[12]
+#define qflag optlist[13]
+
+#ifdef DEBUG
+#define nolog optlist[14]
+#define debug optlist[15]
+#define NOPTS 16
+#else
+#define NOPTS 14
+#endif
+
+/* $NetBSD: options.c,v 1.33 2003/01/22 20:36:04 dsl Exp $ */
+
+
+static const char *const optletters_optnames[NOPTS] = {
+ "e" "errexit",
+ "f" "noglob",
+ "I" "ignoreeof",
+ "i" "interactive",
+ "m" "monitor",
+ "n" "noexec",
+ "s" "stdin",
+ "x" "xtrace",
+ "v" "verbose",
+ "C" "noclobber",
+ "a" "allexport",
+ "b" "notify",
+ "u" "nounset",
+ "q" "quietprofile",
+#ifdef DEBUG
+ "\0" "nolog",
+ "\0" "debug",
+#endif
+};
+
+#define optletters(n) optletters_optnames[(n)][0]
+#define optnames(n) (&optletters_optnames[(n)][1])
+
+
+static char optlist[NOPTS];
+
+
+static char *arg0; /* value of $0 */
+static struct shparam shellparam; /* $@ current positional parameters */
+static char **argptr; /* argument list for builtin commands */
+static char *optionarg; /* set by nextopt (like getopt) */
+static char *optptr; /* used by nextopt */
+
+static char *minusc; /* argument to -c option */
+
+
+static void procargs(int, char **);
+static void optschanged(void);
+static void setparam(char **);
+static void freeparam(volatile struct shparam *);
+static int shiftcmd(int, char **);
+static int setcmd(int, char **);
+static int nextopt(const char *);
+
+/* $NetBSD: redir.h,v 1.14 2002/11/24 22:35:43 christos Exp $ */
+
+/* flags passed to redirect */
+#define REDIR_PUSH 01 /* save previous values of file descriptors */
+
+union node;
+static void redirect(union node *, int);
+static void popredir(int);
+static void clearredir(int);
+static int copyfd(int, int);
+static int redirectsafe(union node *, int);
+
+/* $NetBSD: show.h,v 1.6 2003/01/22 20:36:04 dsl Exp $ */
+
+
+#ifdef DEBUG
+static void showtree(union node *);
+static void trace(const char *, ...);
+static void tracev(const char *, va_list);
+static void trargs(char **);
+static void trputc(int);
+static void trputs(const char *);
+static void opentrace(void);
+#endif
+
+/* $NetBSD: trap.h,v 1.16 2002/11/24 22:35:43 christos Exp $ */
+
+
+/* trap handler commands */
+static char *trap[NSIG];
+/* current value of signal */
+static char sigmode[NSIG - 1];
+/* indicates specified signal received */
+static char gotsig[NSIG - 1];
+
+static void clear_traps(void);
+static void setsignal(int);
+static void ignoresig(int);
+static void onsig(int);
+static void dotrap(void);
+static void setinteractive(int);
+static void exitshell(void) __attribute__((__noreturn__));
+static int decode_signal(const char *, int);
+
+/*
+ * This routine is called when an error or an interrupt occurs in an
+ * interactive shell and control is returned to the main command loop.
+ */
+
+static void
+reset(void)
+{
+ /* from eval.c: */
+ {
+ evalskip = 0;
+ loopnest = 0;
+ funcnest = 0;
+ }
+
+ /* from input.c: */
+ {
+ parselleft = parsenleft = 0; /* clear input buffer */
+ popallfiles();
+ }
+
+ /* from parser.c: */
+ {
+ tokpushback = 0;
+ checkkwd = 0;
+ }
+
+ /* from redir.c: */
+ {
+ clearredir(0);
+ }
+
+}
+
+#ifdef CONFIG_ASH_ALIAS
+static struct alias *atab[ATABSIZE];
+
+static void setalias(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)
+{
+ struct alias *ap, **app;
+
+ app = __lookupalias(name);
+ ap = *app;
+ INTOFF;
+ if (ap) {
+ if (!(ap->flag & ALIASINUSE)) {
+ ckfree(ap->val);
+ }
+ ap->val = savestr(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;
+ *app = ap;
+ }
+ INTON;
+}
+
+static int
+unalias(const char *name)
+{
+ struct alias **app;
+
+ app = __lookupalias(name);
+
+ if (*app) {
+ INTOFF;
+ *app = freealias(*app);
+ INTON;
+ return (0);
+ }
+
+ return (1);
+}
+
+static void
+rmaliases(void)
+{
+ struct alias *ap, **app;
+ int i;
+
+ INTOFF;
+ for (i = 0; i < ATABSIZE; i++) {
+ app = &atab[i];
+ for (ap = *app; ap; ap = *app) {
+ *app = freealias(*app);
+ if (ap == *app) {
+ app = &ap->next;
+ }
+ }
+ }
+ INTON;
+}
+
+static struct alias *
+lookupalias(const char *name, int check)
+{
+ struct alias *ap = *__lookupalias(name);
+
+ if (check && ap && (ap->flag & ALIASINUSE))
+ return (NULL);
+ return (ap);
+}
+
+/*
+ * TODO - sort output
+ */
+static int
+aliascmd(int argc, char **argv)
+{
+ char *n, *v;
+ int ret = 0;
+ struct alias *ap;
+
+ if (argc == 1) {
+ int i;
+
+ for (i = 0; i < ATABSIZE; i++)
+ for (ap = atab[i]; ap; ap = ap->next) {
+ printalias(ap);
+ }
+ return (0);
+ }
+ while ((n = *++argv) != NULL) {
+ if ((v = strchr(n+1, '=')) == NULL) { /* n+1: funny ksh stuff */
+ if ((ap = *__lookupalias(n)) == NULL) {
+ fprintf(stderr, "%s: %s not found\n", "alias", n);
+ ret = 1;
+ } else
+ printalias(ap);
+ } else {
+ *v++ = '\0';
+ setalias(n, v);
+ }
+ }
+
+ return (ret);
+}
+
+static int
+unaliascmd(int argc, char **argv)
+{
+ int i;
+
+ while ((i = nextopt("a")) != '\0') {
+ if (i == 'a') {
+ rmaliases();
+ return (0);
+ }
+ }
+ for (i = 0; *argptr; argptr++) {
+ if (unalias(*argptr)) {
+ fprintf(stderr, "%s: %s not found\n", "unalias", *argptr);
+ i = 1;
+ }
+ }
+
+ return (i);
+}
+
+static struct alias *
+freealias(struct alias *ap) {
+ struct alias *next;
+
+ if (ap->flag & ALIASINUSE) {
+ ap->flag |= ALIASDEAD;
+ return ap;
+ }
+
+ 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));
+}
+
+static struct alias **
+__lookupalias(const char *name) {
+ unsigned int hashval;
+ struct alias **app;
+ const char *p;
+ unsigned int ch;
+
+ p = name;
+
+ ch = (unsigned char)*p;
+ hashval = ch << 4;
+ while (ch) {
+ hashval += ch;
+ ch = (unsigned char)*++p;
+ }
+ app = &atab[hashval % ATABSIZE];
+
+ for (; *app; app = &(*app)->next) {
+ if (equal(name, (*app)->name)) {
+ break;
+ }
+ }
+
+ return app;
+}
+#endif /* CONFIG_ASH_ALIAS */
+
+
+/* $NetBSD: cd.c,v 1.30 2003/01/22 20:36:03 dsl Exp $ */
+
+/*
+ * The cd and pwd commands.
+ */
+
+#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)
+{
+ int flags = 0;
+ int i, j;
+
+ j = 'L';
+ while ((i = nextopt("LP"))) {
+ if (i != j) {
+ flags ^= CD_PHYSICAL;
+ j = i;
+ }
+ }
+
+ return flags;
+}
+
+static int
+cdcmd(int argc, char **argv)
+{
+ 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 (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 (!*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.
+ */
+
+static inline const char *
+updatepwd(const char *dir)
+{
+ char *new;
+ char *p;
+ char *cdcomppath;
+ const char *lim;
+
+ cdcomppath = sstrdup(dir);
+ STARTSTACKSTR(new);
+ if (*dir != '/') {
+ if (curdir == nullstr)
+ return 0;
+ new = stputs(curdir, new);
+ }
+ new = makestrspace(strlen(dir) + 2, new);
+ lim = stackblock() + 1;
+ if (*dir != '/') {
+ if (new[-1] != '/')
+ USTPUTC('/', new);
+ if (new > lim && *lim == '/')
+ lim++;
+ } else {
+ USTPUTC('/', new);
+ cdcomppath++;
+ if (dir[1] == '/' && dir[2] != '/') {
+ USTPUTC('/', new);
+ cdcomppath++;
+ lim++;
+ }
+ }
+ p = strtok(cdcomppath, "/");
+ while (p) {
+ switch(*p) {
+ case '.':
+ if (p[1] == '.' && p[2] == '\0') {
+ while (new > lim) {
+ STUNPUTC(new);
+ if (new[-1] == '/')
+ break;
+ }
+ break;
+ } else if (p[1] == '\0')
+ break;
+ /* fall through */
+ default:
+ new = stputs(p, new);
+ USTPUTC('/', new);
+ }
+ p = strtok(0, "/");
+ }
+ if (new > lim)
+ STUNPUTC(new);
+ *new = 0;
+ return stackblock();
+}
+
+/*
+ * Actually do the chdir. 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;
+
+ TRACE(("docd(\"%s\", %d) called\n", dest, flags));
+
+ INTOFF;
+ if (!(flags & CD_PHYSICAL)) {
+ dir = updatepwd(dest);
+ if (dir)
+ dest = dir;
+ }
+ err = chdir(dest);
+ if (err)
+ goto out;
+ setpwd(dir, 1);
+ hashcd();
+out:
+ INTON;
+ return err;
+}
+
+/*
+ * 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;
+}
+
+static int
+pwdcmd(int argc, char **argv)
+{
+ int flags;
+ const char *dir = curdir;
+
+ flags = cdopt();
+ if (flags) {
+ if (physdir == nullstr)
+ setpwd(dir, 0);
+ dir = physdir;
+ }
+ out1fmt(snlfmt, dir);
+ return 0;
+}
+
+static void
+setpwd(const char *val, int setold)
+{
+ char *oldcur, *dir;
+
+ oldcur = dir = curdir;
+
+ 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);
+ }
+ curdir = dir;
+ INTON;
+ setvar("PWD", dir, VEXPORT);
+}
+
+/* $NetBSD: error.c,v 1.30 2003/01/22 20:36:03 dsl Exp $ */
+
+/*
+ * Errors and exceptions.
+ */
+
+/*
+ * Code to handle exceptions in C.
+ */
+
+
+
+static void exverror(int, const char *, va_list)
+ __attribute__((__noreturn__));
+
+/*
+ * 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".
+ */
+
+static void
+exraise(int e)
+{
+#ifdef DEBUG
+ if (handler == NULL)
+ abort();
+#endif
+ INTOFF;
+
+ exception = e;
+ longjmp(handler->loc, 1);
+}
+
+
+/*
+ * 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.)
+ */
+
+static void
+onint(void) {
+ 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;
+ }
+ exraise(i);
+ /* NOTREACHED */
+}
+
+static void
+exvwarning(const char *msg, va_list ap)
+{
+ 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);
+}
+
+/*
+ * Exverror is called to raise the error exception. If the second argument
+ * is not NULL then error prints an error message using printf style
+ * formatting. It then raises the error exception.
+ */
+static void
+exverror(int cond, const char *msg, va_list ap)
+{
+#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);
+
+ flushall();
+ exraise(cond);
+ /* NOTREACHED */
+}
+
+
+static void
+error(const char *msg, ...)
+{
+ va_list ap;
+
+ va_start(ap, msg);
+ exverror(EXERROR, msg, ap);
+ /* NOTREACHED */
+ va_end(ap);
+}
+
+
+static void
+exerror(int cond, const char *msg, ...)
+{
+ va_list ap;
+
+ va_start(ap, msg);
+ exverror(cond, msg, ap);
+ /* NOTREACHED */
+ va_end(ap);
+}
+
+/*
+ * error/warning routines for external builtins
+ */
+
+static void
+sh_warnx(const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ exvwarning(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);
+}
+
+
+/* $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 **);
+
+
+static const struct builtincmd bltin = {
+ "\0\0", bltincmd
+};
+
+
+/*
+ * Called to reset things after an exception.
+ */
+
+/*
+ * The eval commmand.
+ */
+
+static int
+evalcmd(int argc, char **argv)
+{
+ char *p;
+ char *concat;
+ char **ap;
+
+ 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);
+ }
+ evalstring(p, EV_TESTED);
+ }
+ return exitstatus;
+}
+
+
+/*
+ * Execute a command or commands contained in a string.
+ */
+
+static void
+evalstring(char *s, int flag)
+{
+ union node *n;
+ struct stackmark smark;
+
+ setstackmark(&smark);
+ setinputstring(s);
+
+ while ((n = parsecmd(0)) != NEOF) {
+ evaltree(n, flag);
+ popstackmark(&smark);
+ if (evalskip)
+ break;
+ }
+ popfile();
+ popstackmark(&smark);
+}
+
+
+
+/*
+ * Evaluate a parse tree. The value is left in the global variable
+ * exitstatus.
+ */
+
+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;
+ }
+ TRACE(("pid %d, evaltree(%p: %d, %d) called\n",
+ getpid(), n, n->type, flags));
+ switch (n->type) {
+ default:
+#ifdef DEBUG
+ out1fmt("Node type = %d\n", n->type);
+ flushout(stdout);
+ break;
+#endif
+ case NNOT:
+ evaltree(n->nnot.com, EV_TESTED);
+ status = !exitstatus;
+ goto setstatus;
+ case NREDIR:
+ expredir(n->nredir.redirect);
+ status = redirectsafe(n->nredir.redirect, REDIR_PUSH);
+ if (!status) {
+ evaltree(n->nredir.n, flags & EV_TESTED);
+ status = exitstatus;
+ }
+ popredir(0);
+ goto setstatus;
+ case NCMD:
+ evalfn = evalcommand;
+checkexit:
+ if (eflag && !(flags & EV_TESTED))
+ checkexit = ~0;
+ goto calleval;
+ case NFOR:
+ evalfn = evalfor;
+ goto calleval;
+ case NWHILE:
+ case NUNTIL:
+ evalfn = evalloop;
+ goto calleval;
+ case NSUBSHELL:
+ case NBACKGND:
+ evalfn = evalsubshell;
+ goto calleval;
+ case NPIPE:
+ evalfn = evalpipe;
+ goto checkexit;
+ case NCASE:
+ evalfn = evalcase;
+ goto calleval;
+ case NAND:
+ case NOR:
+ case NSEMI:
+#if NAND + 1 != NOR
+#error NAND + 1 != NOR
+#endif
+#if NOR + 1 != NSEMI
+#error NOR + 1 != NSEMI
+#endif
+ isor = n->type - NAND;
+ evaltree(
+ n->nbinary.ch1,
+ (flags | ((isor >> 1) - 1)) & EV_TESTED
+ );
+ if (!exitstatus == isor)
+ break;
+ if (!evalskip) {
+ n = n->nbinary.ch2;
+evaln:
+ evalfn = evaltree;
+calleval:
+ evalfn(n, flags);
+ break;
+ }
+ break;
+ case NIF:
+ evaltree(n->nif.test, EV_TESTED);
+ if (evalskip)
+ break;
+ if (exitstatus == 0) {
+ n = n->nif.ifpart;
+ goto evaln;
+ } else if (n->nif.elsepart) {
+ n = n->nif.elsepart;
+ goto evaln;
+ }
+ goto success;
+ case NDEFUN:
+ defun(n->narg.text, n->narg.next);
+success:
+ status = 0;
+setstatus:
+ exitstatus = status;
+ break;
+ }
+out:
+ if (pendingsigs)
+ dotrap();
+ if (flags & EV_EXIT || checkexit & exitstatus)
+ exraise(EXEXIT);
+}
+
+
+#if !defined(__alpha__) || (defined(__GNUC__) && __GNUC__ >= 3)
+static
+#endif
+void evaltreenr(union node *, int) __attribute__ ((alias("evaltree"),__noreturn__));
+
+
+static void
+evalloop(union node *n, int flags)
+{
+ int status;
+
+ loopnest++;
+ status = 0;
+ flags &= EV_TESTED;
+ for (;;) {
+ int i;
+
+ 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;
+ }
+ loopnest--;
+ exitstatus = status;
+}
+
+
+
+static void
+evalfor(union node *n, int flags)
+{
+ struct arglist arglist;
+ union node *argp;
+ struct strlist *sp;
+ struct stackmark smark;
+
+ 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;
+ }
+ *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 void
+evalcase(union node *n, int flags)
+{
+ union node *cp;
+ union node *patp;
+ struct arglist arglist;
+ struct stackmark smark;
+
+ 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;
+ }
+ }
+ }
+out:
+ popstackmark(&smark);
+}
+
+
+
+/*
+ * Kick off a subshell to evaluate a tree.
+ */
+
+static void
+evalsubshell(union node *n, int flags)
+{
+ struct job *jp;
+ int backgnd = (n->type == NBACKGND);
+ int status;
+
+ expredir(n->nredir.redirect);
+ if (!backgnd && flags & EV_EXIT && !trap[0])
+ goto nofork;
+ INTOFF;
+ jp = makejob(n, 1);
+ if (forkshell(jp, n, backgnd) == 0) {
+ INTON;
+ flags |= EV_EXIT;
+ if (backgnd)
+ flags &=~ EV_TESTED;
+nofork:
+ redirect(n->nredir.redirect, 0);
+ evaltreenr(n->nredir.n, flags);
+ /* never returns */
+ }
+ status = 0;
+ if (! backgnd)
+ status = waitforjob(jp);
+ exitstatus = status;
+ INTON;
+}
+
+
+
+/*
+ * Compute the names of the files in a redirection list.
+ */
+
+static void
+expredir(union node *n)
+{
+ union node *redir;
+
+ for (redir = n ; redir ; redir = redir->nfile.next) {
+ struct arglist fn;
+ fn.lastp = &fn.list;
+ switch (redir->type) {
+ case NFROMTO:
+ case NFROM:
+ case NTO:
+ case NCLOBBER:
+ case NAPPEND:
+ expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
+ redir->nfile.expfname = fn.list->text;
+ break;
+ case NFROMFD:
+ case NTOFD:
+ if (redir->ndup.vname) {
+ expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE);
+ fixredir(redir, fn.list->text, 1);
+ }
+ break;
+ }
+ }
+}
+
+
+
+/*
+ * Evaluate a pipeline. All the processes in the pipeline are children
+ * of the process creating the pipeline. (This differs from some versions
+ * of the shell, which make the last process in a pipeline the parent
+ * of all the rest.)
+ */
+
+static void
+evalpipe(union node *n, int flags)
+{
+ struct job *jp;
+ struct nodelist *lp;
+ int pipelen;
+ int prevfd;
+ int pip[2];
+
+ 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");
+ }
+ }
+ 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 */
+ }
+ 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));
+ }
+ INTON;
+}
+
+
+
+/*
+ * Execute a command inside back quotes. If it's a builtin command, we
+ * want to save its output in a block obtained from malloc. Otherwise
+ * we fork off a subprocess and get the output of the command via a pipe.
+ * Should be called with interrupts off.
+ */
+
+static void
+evalbackcmd(union node *n, struct backcmd *result)
+{
+ int 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;
+ }
+ herefd = saveherefd;
+out:
+ TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
+ result->fd, result->buf, result->nleft, result->jp));
+}
+
+#ifdef CONFIG_ASH_CMDCMD
+static inline char **
+parse_command_args(char **argv, const char **path)
+{
+ char *cp, c;
+
+ for (;;) {
+ cp = *++argv;
+ if (!cp)
+ return 0;
+ if (*cp++ != '-')
+ break;
+ if (!(c = *cp++))
+ break;
+ if (c == '-' && !*cp) {
+ argv++;
+ break;
+ }
+ do {
+ switch (c) {
+ case 'p':
+ *path = defpath;
+ break;
+ default:
+ /* run 'typecmd' for other options */
+ return 0;
+ }
+ } while ((c = *cp++));
+ }
+ return argv;
+}
+#endif
+
+
+
+/*
+ * Execute a simple command.
+ */
+
+static void
+evalcommand(union node *cmd, int flags)
+{
+ 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);
+
+ /*
+ * 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 sep;
+
+ out2str(ps4val());
+ sep = 0;
+ sep = eprintlist(varlist.list, sep);
+ eprintlist(arglist.list, sep);
+ out2c('\n');
+ flushall();
+ }
+
+ cmd_is_exec = 0;
+ spclbltin = -1;
+
+ /* Now locate the command. */
+ if (argc) {
+ const char *oldpath;
+ int cmd_flag = DO_ERR;
+
+ path += 5;
+ oldpath = path;
+ for (;;) {
+ find_command(argv[0], &cmdentry, cmd_flag, path);
+ if (cmdentry.cmdtype == CMDUNKNOWN) {
+ status = 127;
+ flushout(stderr);
+ goto bail;
+ }
+
+ /* implement bltin and command here */
+ if (cmdentry.cmdtype != CMDBUILTIN)
+ break;
+ if (spclbltin < 0)
+ spclbltin = IS_BUILTIN_SPECIAL(cmdentry.u.cmd);
+ if (cmdentry.u.cmd == EXECCMD)
+ cmd_is_exec++;
+#ifdef CONFIG_ASH_CMDCMD
+ if (cmdentry.u.cmd == COMMANDCMD) {
+
+ path = oldpath;
+ nargv = parse_command_args(argv, &path);
+ if (!nargv)
+ break;
+ argc -= nargv - argv;
+ argv = nargv;
+ cmd_flag |= DO_NOFUNC;
+ } else
+#endif
+ break;
+ }
+ }
+
+ if (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;
+ }
+ break;
+
+ case CMDFUNCTION:
+ listsetvar(varlist.list, 0);
+ if (evalfun(cmdentry.u.func, argc, argv, flags))
+ goto raise;
+ break;
+ }
+
+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;
+}
+
+static int
+evalfun(struct funcnode *func, int argc, char **argv, int flags)
+{
+ volatile struct shparam saveparam;
+ struct localvar *volatile savelocalvars;
+ struct jmploc *volatile savehandler;
+ struct jmploc jmploc;
+ int e;
+
+ saveparam = shellparam;
+ savelocalvars = localvars;
+ if ((e = setjmp(jmploc.loc))) {
+ goto funcdone;
+ }
+ 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;
+ }
+ 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)
+{
+ struct cmdentry entry;
+
+ if (n->type == NCMD && n->ncmd.args)
+ find_command(n->ncmd.args->narg.text, &entry, 0, pathval());
+}
+
+
+
+/*
+ * Builtin commands. Builtin commands whose functions are closely
+ * tied to evaluation are implemented here.
+ */
+
+/*
+ * No command given.
+ */
+
+static int
+bltincmd(int argc, char **argv)
+{
+ /*
+ * Preserve exitstatus of a previous possible redirection
+ * as POSIX mandates
+ */
+ return back_exitstatus;
+}
+
+
+/*
+ * 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, char **argv)
+{
+ int n = argc > 1 ? number(argv[1]) : 1;
+
+ if (n <= 0)
+ error(illnum, argv[1]);
+ if (n > loopnest)
+ n = loopnest;
+ if (n > 0) {
+ evalskip = (**argv == 'c')? SKIPCONT : SKIPBREAK;
+ skipcount = n;
+ }
+ return 0;
+}
+
+
+/*
+ * The return command.
+ */
+
+static int
+returncmd(int argc, char **argv)
+{
+ int ret = argc > 1 ? number(argv[1]) : exitstatus;
+
+ 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;
+ }
+}
+
+
+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;
+}
+
+
+static int
+eprintlist(struct strlist *sp, int sep)
+{
+ while (sp) {
+ const char *p;
+
+ p = " %s" + (1 - sep);
+ sep |= 1;
+ fprintf(stderr, p, sp->text);
+ sp = sp->next;
+ }
+
+ return sep;
+}
+/* $NetBSD: exec.c,v 1.35 2003/01/22 20:36:04 dsl Exp $ */
+
+/*
+ * When commands are first encountered, they are entered in a hash table.
+ * This ensures that a full path search will not have to be done for them
+ * on each invocation.
+ *
+ * We should investigate converting to a linear search, even though that
+ * would make the command name "hash" a misnomer.
+ */
+
+#define CMDTABLESIZE 31 /* should be prime */
+#define ARB 1 /* actual size determined at run time */
+
+
+
+struct tblentry {
+ struct tblentry *next; /* next entry in hash chain */
+ union param param; /* definition of builtin function */
+ short cmdtype; /* index identifying command */
+ char rehash; /* if set, cd done since entry created */
+ char cmdname[ARB]; /* name of command */
+};
+
+
+static struct tblentry *cmdtable[CMDTABLESIZE];
+static int builtinloc = -1; /* index in path of %builtin, or -1 */
+
+
+static void tryexec(char *, char **, char **);
+static void printentry(struct tblentry *);
+static void clearcmdentry(int);
+static struct tblentry *cmdlookup(const char *, int);
+static void delete_cmd_entry(void);
+
+
+/*
+ * Exec a program. Never returns. If you change this routine, you may
+ * have to change the find_command routine as well.
+ */
+
+static void
+shellexec(char **argv, const char *path, int idx)
+{
+ char *cmdname;
+ int e;
+ char **envp;
+
+ clearredir(1);
+ envp = environment();
+ if (strchr(argv[0], '/') != NULL
+#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
+ || find_applet_by_name(argv[0])
+#endif
+ ) {
+ 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);
+ }
+ }
+
+ /* Map to POSIX errors */
+ switch (e) {
+ case EACCES:
+ exerrno = 126;
+ break;
+ case ENOENT:
+ exerrno = 127;
+ break;
+ default:
+ exerrno = 2;
+ break;
+ }
+ TRACE(("shellexec failed for %s, errno %d, suppressint %d\n",
+ argv[0], e, suppressint ));
+ exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC));
+ /* NOTREACHED */
+}
+
+
+static void
+tryexec(char *cmd, char **argv, char **envp)
+{
+ int repeated = 0;
+#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
+ int flg_bb = 0;
+ char *name = cmd;
+
+#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;
+
+ *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";
+ }
+ }
+#endif
+
+repeat:
+#ifdef SYSV
+ do {
+ execve(cmd, argv, envp);
+ } while (errno == EINTR);
+#else
+ execve(cmd, argv, envp);
+#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;
+ }
+}
+
+
+
+/*
+ * 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.
+ */
+
+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++);
+ 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);
+}
+
+
+
+/*** Command hashing code ***/
+
+
+static int
+hashcmd(int argc, char **argv)
+{
+ struct tblentry **pp;
+ struct tblentry *cmdp;
+ int c;
+ struct cmdentry entry;
+ char *name;
+
+ while ((c = nextopt("r")) != '\0') {
+ clearcmdentry(0);
+ return 0;
+ }
+ if (*argptr == NULL) {
+ for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
+ for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
+ if (cmdp->cmdtype == CMDNORMAL)
+ printentry(cmdp);
+ }
+ }
+ 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;
+}
+
+
+static void
+printentry(struct tblentry *cmdp)
+{
+ int idx;
+ const char *path;
+ char *name;
+
+ idx = cmdp->param.index;
+ path = pathval();
+ do {
+ name = padvance(&path, cmdp->cmdname);
+ stunalloc(name);
+ } while (--idx >= 0);
+ out1str(name);
+ out1fmt(snlfmt, cmdp->rehash ? "*" : nullstr);
+}
+
+
+
+/*
+ * Resolve a command name. If you change this routine, you may have to
+ * change the shellexec routine as well.
+ */
+
+static void
+find_command(char *name, struct cmdentry *entry, int act, const char *path)
+{
+ 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;
+ }
+
+#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
+ if (find_applet_by_name(name)) {
+ entry->cmdtype = CMDNORMAL;
+ entry->u.index = -1;
+ 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();
+#endif
+ 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;
+ }
+
+ /* 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 */
+ 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);
+ readcmdfile(fullname);
+ if ((cmdp = cmdlookup(name, 0)) == NULL ||
+ cmdp->cmdtype != CMDFUNCTION)
+ error("%s not defined in %s", name, fullname);
+ stunalloc(fullname);
+ goto success;
+ }
+ TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
+ if (!updatetbl) {
+ entry->cmdtype = CMDNORMAL;
+ entry->u.index = idx;
+ return;
+ }
+ 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;
+
+ bp = bsearch(
+ name, builtincmd, NUMBUILTINS, sizeof(struct builtincmd),
+ pstrcmp
+ );
+ return bp;
+}
+
+
+
+/*
+ * Called when a cd is done. Marks all commands so the next time they
+ * are executed they will be rehashed.
+ */
+
+static void
+hashcd(void)
+{
+ struct tblentry **pp;
+ struct tblentry *cmdp;
+
+ for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
+ for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
+ if (cmdp->cmdtype == CMDNORMAL || (
+ cmdp->cmdtype == CMDBUILTIN &&
+ !(IS_BUILTIN_REGULAR(cmdp->param.cmd)) &&
+ builtinloc > 0
+ ))
+ cmdp->rehash = 1;
+ }
+ }
+}
+
+
+
+/*
+ * 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
+changepath(const char *newval)
+{
+ 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')
+ break;
+ if (*new == '%' && idx_bltin < 0 && prefix(new + 1, "builtin"))
+ idx_bltin = idx;
+ if (*new == ':') {
+ idx++;
+ }
+ new++, old++;
+ }
+ if (builtinloc < 0 && idx_bltin >= 0)
+ builtinloc = idx_bltin; /* zap builtins */
+ if (builtinloc >= 0 && idx_bltin < 0)
+ firstchange = 0;
+ clearcmdentry(firstchange);
+ builtinloc = idx_bltin;
+}
+
+
+/*
+ * Clear out command entries. The argument specifies the first entry in
+ * PATH which has changed.
+ */
+
+static void
+clearcmdentry(int firstchange)
+{
+ struct tblentry **tblp;
+ struct tblentry **pp;
+ struct tblentry *cmdp;
+
+ 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;
+ }
+ }
+ }
+ INTON;
+}
+
+
+
+/*
+ * Locate a command in the command hash table. If "add" is nonzero,
+ * add the command to the table if it is not already present. The
+ * variable "lastcmdentry" is set to point to the address of the link
+ * pointing to the entry, so that delete_cmd_entry can delete the
+ * entry.
+ *
+ * Interrupts must be off if called with add != 0.
+ */
+
+static struct tblentry **lastcmdentry;
+
+
+static struct tblentry *
+cmdlookup(const char *name, int add)
+{
+ unsigned int hashval;
+ const char *p;
+ struct tblentry *cmdp;
+ struct tblentry **pp;
+
+ 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);
+ }
+ lastcmdentry = pp;
+ return cmdp;
+}
+
+/*
+ * Delete the command entry returned on the last lookup.
+ */
+
+static void
+delete_cmd_entry(void)
+{
+ struct tblentry *cmdp;
+
+ INTOFF;
+ cmdp = *lastcmdentry;
+ *lastcmdentry = cmdp->next;
+ if (cmdp->cmdtype == CMDFUNCTION)
+ freefunc(cmdp->param.func);
+ ckfree(cmdp);
+ INTON;
+}
+
+
+/*
+ * Add a new command entry, replacing any existing command entry for
+ * the same name - except special builtins.
+ */
+
+static inline void
+addcmdentry(char *name, struct cmdentry *entry)
+{
+ struct tblentry *cmdp;
+
+ cmdp = cmdlookup(name, 1);
+ if (cmdp->cmdtype == CMDFUNCTION) {
+ freefunc(cmdp->param.func);
+ }
+ cmdp->cmdtype = entry->cmdtype;
+ cmdp->param = entry->u;
+ cmdp->rehash = 0;
+}
+
+/*
+ * Make a copy of a parse tree.
+ */
+
+static inline struct funcnode *
+copyfunc(union node *n)
+{
+ struct funcnode *f;
+ size_t blocksize;
+
+ funcblocksize = offsetof(struct funcnode, n);
+ funcstringsize = 0;
+ calcsize(n);
+ blocksize = funcblocksize;
+ f = ckmalloc(blocksize + funcstringsize);
+ funcblock = (char *) f + offsetof(struct funcnode, n);
+ funcstring = (char *) f + blocksize;
+ copynode(n);
+ f->count = 0;
+ return f;
+}
+
+/*
+ * Define a shell function.
+ */
+
+static void
+defun(char *name, union node *func)
+{
+ struct cmdentry entry;
+
+ INTOFF;
+ entry.cmdtype = CMDFUNCTION;
+ entry.u.func = copyfunc(func);
+ addcmdentry(name, &entry);
+ INTON;
+}
+
+
+/*
+ * Delete a function if it exists.
+ */
+
+static void
+unsetfunc(const char *name)
+{
+ struct tblentry *cmdp;
+
+ if ((cmdp = cmdlookup(name, 0)) != NULL &&
+ cmdp->cmdtype == CMDFUNCTION)
+ delete_cmd_entry();
+}
+
+/*
+ * Locate and print what a word is...
+ */
+
+
+#ifdef CONFIG_ASH_CMDCMD
+static int
+describe_command(char *command, int describe_command_verbose)
+#else
+#define describe_command_verbose 1
+static int
+describe_command(char *command)
+#endif
+{
+ struct cmdentry entry;
+ struct tblentry *cmdp;
+#ifdef CONFIG_ASH_ALIAS
+ const struct alias *ap;
+#endif
+ const char *path = pathval();
+
+ if (describe_command_verbose) {
+ out1str(command);
+ }
+
+ /* First look at the keywords */
+ if (findkwd(command)) {
+ out1str(describe_command_verbose ? " is a shell keyword" : command);
+ goto out;
+ }
+
+#ifdef CONFIG_ASH_ALIAS
+ /* Then look at the aliases */
+ if ((ap = lookupalias(command, 0)) != NULL) {
+ if (describe_command_verbose) {
+ out1fmt(" is an alias for %s", ap->val);
+ } else {
+ out1str("alias ");
+ printalias(ap);
+ return 0;
+ }
+ goto out;
+ }
+#endif
+ /* Then check if it is a tracked alias */
+ if ((cmdp = cmdlookup(command, 0)) != NULL) {
+ entry.cmdtype = cmdp->cmdtype;
+ entry.u = cmdp->param;
+ } else {
+ /* Finally use brute force */
+ find_command(command, &entry, DO_ABS, path);
+ }
+
+ switch (entry.cmdtype) {
+ case CMDNORMAL: {
+ int j = entry.u.index;
+ char *p;
+ if (j == -1) {
+ p = command;
+ } else {
+ do {
+ p = padvance(&path, command);
+ stunalloc(p);
+ } while (--j >= 0);
+ }
+ if (describe_command_verbose) {
+ out1fmt(" is%s %s",
+ (cmdp ? " a tracked alias for" : nullstr), p
+ );
+ } else {
+ out1str(p);
+ }
+ break;
+ }
+
+ case CMDFUNCTION:
+ if (describe_command_verbose) {
+ out1str(" is a shell function");
+ } else {
+ out1str(command);
+ }
+ break;
+
+ case CMDBUILTIN:
+ if (describe_command_verbose) {
+ out1fmt(" is a %sshell builtin",
+ IS_BUILTIN_SPECIAL(entry.u.cmd) ?
+ "special " : nullstr
+ );
+ } else {
+ out1str(command);
+ }
+ break;
+
+ default:
+ if (describe_command_verbose) {
+ out1str(": not found\n");
+ }
+ return 127;
+ }
+
+out:
+ out1c('\n');
+ return 0;
+}
+
+static int
+typecmd(int argc, char **argv)
+{
+ int i;
+ int err = 0;
+
+ for (i = 1; i < argc; i++) {
+#ifdef CONFIG_ASH_CMDCMD
+ err |= describe_command(argv[i], 1);
+#else
+ err |= describe_command(argv[i]);
+#endif
+ }
+ return err;
+}
+
+#ifdef CONFIG_ASH_CMDCMD
+static int
+commandcmd(int argc, char **argv)
+{
+ int c;
+ int default_path = 0;
+ int verify_only = 0;
+ int verbose_verify_only = 0;
+
+ while ((c = nextopt("pvV")) != '\0')
+ switch (c) {
+ default:
+#ifdef DEBUG
+ fprintf(stderr,
+"command: nextopt returned character code 0%o\n", c);
+ return EX_SOFTWARE;
+#endif
+ case 'p':
+ default_path = 1;
+ break;
+ case 'v':
+ verify_only = 1;
+ break;
+ case 'V':
+ verbose_verify_only = 1;
+ break;
+ }
+
+ 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);
+ }
+
+ return 0;
+}
+#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.
+ */
+
+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 */
+};
+
+/* output of current string */
+static char *expdest;
+/* list of back quote expressions */
+static struct nodelist *argbackq;
+/* first struct in list of ifs regions */
+static struct ifsregion ifsfirst;
+/* last struct in list */
+static struct ifsregion *ifslastp;
+/* holds expanded arg list */
+static struct arglist exparg;
+
+static void argstr(char *, int);
+static char *exptilde(char *, 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__));
+
+
+#define pmatch(a, b) !fnmatch((a), (b), 0)
+/*
+ * Prepare a pattern for a glob(3) call.
+ *
+ * Returns an stalloced string.
+ */
+
+static inline char *
+preglob(const char *pattern, int quoted, int flag) {
+ flag |= RMESCAPE_GLOB;
+ if (quoted) {
+ flag |= RMESCAPE_QUOTED;
+ }
+ return _rmescapes((char *)pattern, flag);
+}
+
+
+static size_t
+esclen(const char *start, const char *p) {
+ size_t esc = 0;
+
+ while (p > start && *--p == CTLESC) {
+ esc++;
+ }
+ return esc;
+}
+
+
+/*
+ * Expand shell variables and backquotes inside a here document.
+ */
+
+static inline void
+expandhere(union node *arg, int fd)
+{
+ herefd = fd;
+ expandarg(arg, (struct arglist *)NULL, 0);
+ xwrite(fd, stackblock(), expdest - (char *)stackblock());
+}
+
+
+/*
+ * 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.
+ */
+
+void
+expandarg(union node *arg, struct arglist *arglist, int flag)
+{
+ struct strlist *sp;
+ char *p;
+
+ 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
+ */
+ 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;
+ }
+}
+
+
+
+/*
+ * Perform variable and command substitution. If EXP_FULL is set, output CTLESC
+ * characters to allow for further processing. Otherwise treat
+ * $@ like $* since no splitting will be performed.
+ */
+
+static void
+argstr(char *p, int flag)
+{
+ static const char spclchars[] = {
+ '=',
+ ':',
+ CTLQUOTEMARK,
+ CTLENDVAR,
+ CTLESC,
+ CTLVAR,
+ CTLBACKQ,
+ CTLBACKQ | CTLQUOTE,
+#ifdef CONFIG_ASH_MATH_SUPPORT
+ CTLENDARI,
+#endif
+ 0
+ };
+ const char *reject = spclchars;
+ int c;
+ int quotes = flag & (EXP_FULL | EXP_CASE); /* do CTLESC */
+ int breakall = flag & EXP_WORD;
+ int inquotes;
+ size_t length;
+ int startloc;
+
+ if (!(flag & EXP_VARTILDE)) {
+ reject += 2;
+ } else if (flag & EXP_VARTILDE2) {
+ reject++;
+ }
+ inquotes = 0;
+ length = 0;
+ if (flag & EXP_TILDE) {
+ char *q;
+
+ flag &= ~EXP_TILDE;
+tilde:
+ q = p;
+ if (*q == CTLESC && (flag & EXP_QWORD))
+ q++;
+ if (*q == '~')
+ p = exptilde(p, q, flag);
+ }
+start:
+ startloc = expdest - (char *)stackblock();
+ for (;;) {
+ length += strcspn(p + length, reject);
+ c = p[length];
+ if (c && (!(c & 0x80)
+#ifdef CONFIG_ASH_MATH_SUPPORT
+ || c == CTLENDARI
+#endif
+ )) {
+ /* c == '=' || c == ':' || c == CTLENDARI */
+ length++;
+ }
+ if (length > 0) {
+ int newloc;
+ expdest = stnputs(p, length, expdest);
+ newloc = expdest - (char *)stackblock();
+ if (breakall && !inquotes && newloc > startloc) {
+ recordregion(startloc, newloc, 0);
+ }
+ startloc = newloc;
+ }
+ p += length + 1;
+ length = 0;
+
+ switch (c) {
+ case '\0':
+ goto breakloop;
+ case '=':
+ if (flag & EXP_VARTILDE2) {
+ p--;
+ continue;
+ }
+ flag |= EXP_VARTILDE2;
+ reject++;
+ /* fall through */
+ case ':':
+ /*
+ * sort of a hack - expand tildes in variable
+ * assignments (after the first '=' and after ':'s).
+ */
+ if (*--p == '~') {
+ goto tilde;
+ }
+ continue;
+ }
+
+ switch (c) {
+ case CTLENDVAR: /* ??? */
+ goto breakloop;
+ case CTLQUOTEMARK:
+ /* "$@" syntax adherence hack */
+ if (
+ !inquotes &&
+ !memcmp(p, dolatstr, DOLATSTRLEN) &&
+ (p[4] == CTLQUOTEMARK || (
+ p[4] == CTLENDVAR &&
+ p[5] == CTLQUOTEMARK
+ ))
+ ) {
+ p = evalvar(p + 1, flag) + 1;
+ goto start;
+ }
+ inquotes = !inquotes;
+addquote:
+ if (quotes) {
+ p--;
+ length++;
+ startloc++;
+ }
+ break;
+ case CTLESC:
+ startloc++;
+ length++;
+ goto addquote;
+ case CTLVAR:
+ p = evalvar(p, flag);
+ goto start;
+ case CTLBACKQ:
+ c = 0;
+ case CTLBACKQ|CTLQUOTE:
+ expbackq(argbackq->n, c, quotes);
+ argbackq = argbackq->next;
+ goto start;
+#ifdef CONFIG_ASH_MATH_SUPPORT
+ case CTLENDARI:
+ p--;
+ expari(quotes);
+ goto start;
+#endif
+ }
+ }
+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;
+ char c;
+
+ loc = startp;
+ loc2 = rmesc;
+ do {
+ int match;
+ const char *s = loc2;
+ c = *loc2;
+ if (zero) {
+ *loc2 = '\0';
+ s = rmesc;
+ }
+ match = pmatch(str, s);
+ *loc2 = c;
+ if (match)
+ return loc;
+ if (quotes && *loc == CTLESC)
+ loc++;
+ loc++;
+ loc2++;
+ } while (c);
+ return 0;
+}
+
+
+static char *
+scanright(
+ char *startp, char *rmesc, char *rmescend, char *str, int quotes,
+ int zero
+) {
+ int esc = 0;
+ char *loc;
+ char *loc2;
+
+ for (loc = str - 1, loc2 = rmescend; loc >= startp; loc2--) {
+ int match;
+ char c = *loc2;
+ const char *s = loc2;
+ if (zero) {
+ *loc2 = '\0';
+ s = rmesc;
+ }
+ match = pmatch(str, s);
+ *loc2 = c;
+ if (match)
+ return loc;
+ loc--;
+ if (quotes) {
+ if (--esc < 0) {
+ esc = esclen(startp, loc);
+ }
+ if (esc % 2) {
+ esc--;
+ loc--;
+ }
+ }
+ }
+ return 0;
+}
+
+static const char *
+subevalvar(char *p, char *str, int strloc, int subtype, int startloc, int varflags, int quotes)
+{
+ char *startp;
+ char *loc;
+ int saveherefd = herefd;
+ struct nodelist *saveargbackq = argbackq;
+ int amount;
+ char *rmesc, *rmescend;
+ int zero;
+ char *(*scan)(char *, char *, char *, char *, int , int);
+
+ herefd = -1;
+ argstr(p, subtype != VSASSIGN && subtype != VSQUESTION ? EXP_CASE : 0);
+ STPUTC('\0', expdest);
+ herefd = saveherefd;
+ argbackq = saveargbackq;
+ startp = stackblock() + startloc;
+
+ switch (subtype) {
+ case VSASSIGN:
+ setvar(str, startp, 0);
+ amount = startp - expdest;
+ STADJUST(amount, expdest);
+ return startp;
+
+ case VSQUESTION:
+ varunset(p, str, startp, varflags);
+ /* NOTREACHED */
+ }
+
+ subtype -= VSTRIMRIGHT;
+#ifdef DEBUG
+ if (subtype < 0 || subtype > 3)
+ abort();
+#endif
+
+ rmesc = startp;
+ rmescend = stackblock() + strloc;
+ if (quotes) {
+ rmesc = _rmescapes(startp, RMESCAPE_ALLOC | RMESCAPE_GROW);
+ if (rmesc != startp) {
+ rmescend = expdest;
+ startp = stackblock() + startloc;
+ }
+ }
+ rmescend--;
+ str = stackblock() + strloc;
+ preglob(str, varflags & VSQUOTE, 0);
+
+ /* zero = subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX */
+ zero = subtype >> 1;
+ /* VSTRIMLEFT/VSTRIMRIGHTMAX -> scanleft */
+ scan = (subtype & 1) ^ zero ? scanleft : scanright;
+
+ loc = scan(startp, rmesc, rmescend, str, quotes, zero);
+ if (loc) {
+ if (zero) {
+ memmove(startp, loc, str - loc);
+ loc = startp + (str - loc) - 1;
+ }
+ *loc = '\0';
+ amount = loc - expdest;
+ STADJUST(amount, expdest);
+ }
+ return loc;
+}
+
+
+/*
+ * Expand a variable, and return a pointer to the next character in the
+ * input string.
+ */
+static char *
+evalvar(char *p, int flag)
+{
+ int subtype;
+ int varflags;
+ char *var;
+ int patloc;
+ int c;
+ int set;
+ int startloc;
+ size_t varlen;
+ int easy;
+ int quotes;
+ int quoted;
+
+ quotes = flag & (EXP_FULL | EXP_CASE);
+ varflags = *p++;
+ subtype = varflags & VSTYPE;
+ quoted = varflags & VSQUOTE;
+ var = p;
+ easy = (!quoted || (*var == '@' && shellparam.nparam));
+ varlen = 0;
+ startloc = expdest - (char *)stackblock();
+ p = strchr(p, '=') + 1;
+
+ if (!is_name(*var)) {
+ set = varisset(var, varflags & VSNUL);
+ set--;
+ if (subtype == VSPLUS)
+ goto vsplus;
+ if (++set) {
+ varvalue(var, quoted, flag);
+ if (subtype == VSLENGTH) {
+ varlen =
+ expdest - (char *)stackblock() -
+ startloc;
+ STADJUST(-varlen, expdest);
+ goto vslen;
+ }
+ }
+ } 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
+ );
+ }
+ }
+
+
+ if (subtype == VSMINUS) {
+vsplus:
+ if (!set) {
+ argstr(
+ p, flag | EXP_TILDE |
+ (quoted ? EXP_QWORD : EXP_WORD)
+ );
+ goto end;
+ }
+ if (easy)
+ goto record;
+ goto end;
+ }
+
+ if (subtype == VSASSIGN || subtype == VSQUESTION) {
+ if (!set) {
+ if (subevalvar(p, var, 0, subtype, startloc,
+ varflags, 0)) {
+ varflags &= ~VSNUL;
+ /*
+ * Remove any recorded regions beyond
+ * start of variable
+ */
+ removerecordregions(startloc);
+ goto again;
+ }
+ goto end;
+ }
+ if (easy)
+ goto record;
+ goto end;
+ }
+
+ if (!set && uflag)
+ varunset(p, var, 0, 0);
+
+ if (subtype == VSLENGTH) {
+vslen:
+ cvtnum(varlen);
+ goto record;
+ }
+
+ if (subtype == VSNORMAL) {
+ if (!easy)
+ goto end;
+record:
+ recordregion(startloc, expdest - (char *)stackblock(), quoted);
+ goto end;
+ }
+
+#ifdef DEBUG
+ switch (subtype) {
+ case VSTRIMLEFT:
+ case VSTRIMLEFTMAX:
+ case VSTRIMRIGHT:
+ case VSTRIMRIGHTMAX:
+ break;
+ default:
+ abort();
+ }
+#endif
+
+ if (set) {
+ /*
+ * Terminate the string and start recording the pattern
+ * right after it
+ */
+ STPUTC('\0', expdest);
+ patloc = expdest - (char *)stackblock();
+ if (subevalvar(p, NULL, patloc, subtype,
+ startloc, varflags, quotes) == 0) {
+ int amount = expdest - (
+ (char *)stackblock() + patloc - 1
+ );
+ STADJUST(-amount, expdest);
+ }
+ /* Remove any recorded regions beyond start of variable */
+ removerecordregions(startloc);
+ goto record;
+ }
+
+end:
+ if (subtype != VSNORMAL) { /* skip to end of alternative */
+ int nesting = 1;
+ for (;;) {
+ if ((c = *p++) == CTLESC)
+ p++;
+ else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
+ if (set)
+ argbackq = argbackq->next;
+ } else if (c == CTLVAR) {
+ if ((*p++ & VSTYPE) != VSNORMAL)
+ nesting++;
+ } else if (c == CTLENDVAR) {
+ if (--nesting == 0)
+ break;
+ }
+ }
+ }
+ return p;
+}
+
+
+
+/*
+ * Test whether a specialized variable is set.
+ */
+
+static int
+varisset(char *name, int nulok)
+{
+ 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
+ * searched for IFS characters have been stored by recordregion.
+ */
+static void
+ifsbreakup(char *string, struct arglist *arglist)
+{
+ struct ifsregion *ifsp;
+ struct strlist *sp;
+ char *start;
+ char *p;
+ char *q;
+ const char *ifs, *realifs;
+ int ifsspc;
+ int nulonly;
+
+
+ start = string;
+ if (ifslastp != NULL) {
+ ifsspc = 0;
+ nulonly = 0;
+ realifs = ifsset() ? ifsval() : defifs;
+ ifsp = &ifsfirst;
+ do {
+ p = string + ifsp->begoff;
+ nulonly = ifsp->nulonly;
+ ifs = nulonly ? nullstr : realifs;
+ ifsspc = 0;
+ while (p < string + ifsp->endoff) {
+ 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;
+ p++;
+ if (!nulonly) {
+ for (;;) {
+ if (p >= string + ifsp->endoff) {
+ break;
+ }
+ q = p;
+ if (*p == CTLESC)
+ p++;
+ if (strchr(ifs, *p) == NULL ) {
+ p = q;
+ break;
+ } else if (strchr(defifs, *p) == NULL) {
+ if (ifsspc) {
+ p++;
+ ifsspc = 0;
+ } else {
+ p = q;
+ break;
+ }
+ } else
+ p++;
+ }
+ }
+ start = p;
+ } else
+ p++;
+ }
+ } while ((ifsp = ifsp->next) != NULL);
+ if (nulonly)
+ goto add;
+ }
+
+ if (!*start)
+ return;
+
+add:
+ sp = (struct strlist *)stalloc(sizeof *sp);
+ sp->text = start;
+ *arglist->lastp = sp;
+ arglist->lastp = &sp->next;
+}
+
+static void
+ifsfree(void)
+{
+ struct ifsregion *p;
+
+ INTOFF;
+ p = ifsfirst.next;
+ do {
+ struct ifsregion *ifsp;
+ ifsp = p->next;
+ ckfree(p);
+ p = ifsp;
+ } while (p);
+ ifslastp = NULL;
+ ifsfirst.next = NULL;
+ INTON;
+}
+
+
+
+/*
+ * Expand shell metacharacters. At this point, the only control characters
+ * should be escapes. The results are stored in the list exparg.
+ */
+
+static void
+expandmeta(str, flag)
+ struct strlist *str;
+ int flag;
+{
+ /* TODO - EXP_REDIR */
+
+ while (str) {
+ const char *p;
+ glob_t pglob;
+ int i;
+
+ if (fflag)
+ goto nometa;
+ INTOFF;
+ p = preglob(str->text, 0, RMESCAPE_ALLOC | RMESCAPE_HEAP);
+ i = glob(p, GLOB_NOMAGIC, 0, &pglob);
+ if (p != str->text)
+ ckfree(p);
+ switch (i) {
+ case 0:
+ if (!(pglob.gl_flags & GLOB_MAGCHAR))
+ goto nometa2;
+ addglob(&pglob);
+ globfree(&pglob);
+ INTON;
+ break;
+ case GLOB_NOMATCH:
+nometa2:
+ globfree(&pglob);
+ INTON;
+nometa:
+ *exparg.lastp = str;
+ rmescapes(str->text);
+ exparg.lastp = &str->next;
+ break;
+ default: /* GLOB_NOSPACE */
+ error(bb_msg_memory_exhausted);
+ }
+ str = str->next;
+ }
+}
+
+
+/*
+ * Add the result of glob(3) to the list.
+ */
+
+static void
+addglob(pglob)
+ const glob_t *pglob;
+{
+ char **p = pglob->gl_pathv;
+
+ do {
+ addfname(*p);
+ } while (*++p);
+}
+
+
+/*
+ * Add a file name to the list.
+ */
+
+static void
+addfname(char *name)
+{
+ struct strlist *sp;
+
+ sp = (struct strlist *)stalloc(sizeof *sp);
+ sp->text = sstrdup(name);
+ *exparg.lastp = sp;
+ exparg.lastp = &sp->next;
+}
+
+
+/*
+ * Returns true if the pattern matches the string.
+ */
+
+static inline 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
+casematch(union node *pattern, char *val)
+{
+ struct stackmark smark;
+ int result;
+
+ setstackmark(&smark);
+ argbackq = pattern->narg.backquote;
+ STARTSTACKSTR(expdest);
+ ifslastp = NULL;
+ argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
+ STACKSTRNUL(expdest);
+ result = patmatch(stackblock(), val);
+ popstackmark(&smark);
+ return result;
+}
+
+/*
+ * Our own itoa().
+ */
+
+static int
+cvtnum(long num)
+{
+ int len;
+
+ expdest = makestrspace(32, expdest);
+ len = fmtstr(expdest, 32, "%ld", num);
+ STADJUST(len, expdest);
+ return len;
+}
+
+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;
+ }
+ error("%.*s: %s%s", end - var - 1, var, msg, tail);
+}
+/* $NetBSD: input.c,v 1.37 2002/11/24 22:35:40 christos Exp $ */
+
+
+
+/*
+ * This file implements the input routines used by the parser.
+ */
+
+#define EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */
+#define IBUFSIZ (BUFSIZ + 1)
+
+static void pushfile(void);
+
+/*
+ * Read a line from the script.
+ */
+
+static inline char *
+pfgets(char *line, int len)
+{
+ char *p = line;
+ int nleft = len;
+ int c;
+
+ while (--nleft > 0) {
+ c = pgetc2();
+ if (c == PEOF) {
+ if (p == line)
+ return NULL;
+ break;
+ }
+ *p++ = c;
+ if (c == '\n')
+ break;
+ }
+ *p = '\0';
+ return line;
+}
+
+
+/*
+ * 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())
+
+#ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE
+#define pgetc_macro() pgetc()
+static int
+pgetc(void)
+{
+ return pgetc_as_macro();
+}
+#else
+#define pgetc_macro() pgetc_as_macro()
+static int
+pgetc(void)
+{
+ return pgetc_macro();
+}
+#endif
+
+
+/*
+ * Same as pgetc(), but ignores PEOA.
+ */
+#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)
+{
+ return pgetc_macro();
+}
+#endif
+
+
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+static const char *cmdedit_prompt;
+static inline void putprompt(const char *s)
+{
+ cmdedit_prompt = s;
+}
+#else
+static inline void putprompt(const char *s)
+{
+ out2str(s);
+}
+#endif
+
+static inline int
+preadfd(void)
+{
+ 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
+
+ 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;
+ }
+ }
+ }
+ }
+ return nr;
+}
+
+/*
+ * 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 (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.
+ */
+
+int
+preadbuffer(void)
+{
+ 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;
+
+ case '\n':
+ parsenleft = q - parsenextc;
+ more = 0; /* Stop processing here */
+ break;
+
+ }
+
+ *q++ = *p++;
+check:
+ if (--parselleft <= 0 && more) {
+ parsenleft = q - parsenextc - 1;
+ if (parsenleft < 0)
+ goto again;
+ more = 0;
+ }
+ }
+
+ savec = *q;
+ *q = '\0';
+
+ if (vflag) {
+ out2str(parsenextc);
+ flushout(stderr);
+ }
+
+ *q = savec;
+
+ return *parsenextc++;
+}
+
+/*
+ * Undo the last call to pgetc. Only one character may be pushed back.
+ * PEOF may be pushed back.
+ */
+
+void
+pungetc(void)
+{
+ parsenleft++;
+ parsenextc--;
+}
+
+/*
+ * Push a string back onto the input at this current parsefile level.
+ * We handle aliases this way.
+ */
+void
+pushstring(char *s, void *ap)
+{
+ struct strpush *sp;
+ size_t len;
+
+ len = strlen(s);
+ INTOFF;
+/*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
+ if (parsefile->strpush) {
+ sp = 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;
+ }
+#endif
+ parsenextc = s;
+ parsenleft = len;
+ INTON;
+}
+
+void
+popstring(void)
+{
+ struct strpush *sp = parsefile->strpush;
+
+ INTOFF;
+#ifdef CONFIG_ASH_ALIAS
+ if (sp->ap) {
+ if (parsenextc[-1] == ' ' || parsenextc[-1] == '\t') {
+ checkkwd |= CHKALIAS;
+ }
+ if (sp->string != sp->ap->val) {
+ ckfree(sp->string);
+ }
+ sp->ap->flag &= ~ALIASINUSE;
+ if (sp->ap->flag & ALIASDEAD) {
+ unalias(sp->ap->name);
+ }
+ }
+#endif
+ parsenextc = sp->prevstring;
+ parsenleft = sp->prevnleft;
+/*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
+ parsefile->strpush = sp->prev;
+ if (sp != &(parsefile->basestrpush))
+ ckfree(sp);
+ INTON;
+}
+
+/*
+ * Set the input to take input from a file. If push is set, push the
+ * old input onto the stack first.
+ */
+
+void
+setinputfile(const char *fname, int push)
+{
+ int fd;
+ int fd2;
+
+ INTOFF;
+ if ((fd = open(fname, O_RDONLY)) < 0)
+ error("Can't open %s", fname);
+ if (fd < 10) {
+ fd2 = copyfd(fd, 10);
+ close(fd);
+ if (fd2 < 0)
+ error("Out of file descriptors");
+ fd = fd2;
+ }
+ setinputfd(fd, push);
+ INTON;
+}
+
+
+/*
+ * Like setinputfile, but takes an open file descriptor. Call this with
+ * interrupts off.
+ */
+
+static void
+setinputfd(int fd, int push)
+{
+ (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
+ if (push) {
+ pushfile();
+ parsefile->buf = 0;
+ }
+ parsefile->fd = fd;
+ if (parsefile->buf == NULL)
+ parsefile->buf = ckmalloc(IBUFSIZ);
+ parselleft = parsenleft = 0;
+ plinno = 1;
+}
+
+
+/*
+ * Like setinputfile, but takes input from a string.
+ */
+
+static void
+setinputstring(char *string)
+{
+ 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 void
+pushfile(void)
+{
+ struct parsefile *pf;
+
+ 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;
+}
+
+
+static void
+popfile(void)
+{
+ struct parsefile *pf = parsefile;
+
+ INTOFF;
+ if (pf->fd >= 0)
+ close(pf->fd);
+ if (pf->buf)
+ ckfree(pf->buf);
+ while (pf->strpush)
+ popstring();
+ parsefile = pf->prev;
+ ckfree(pf);
+ parsenleft = parsefile->nleft;
+ parselleft = parsefile->lleft;
+ parsenextc = parsefile->nextc;
+ plinno = parsefile->linno;
+ INTON;
+}
+
+
+/*
+ * Return to top level.
+ */
+
+static void
+popallfiles(void)
+{
+ while (parsefile != &basepf)
+ popfile();
+}
+
+
+
+/*
+ * Close the file(s) that the shell is reading commands from. Called
+ * after a fork is done.
+ */
+
+static void
+closescript(void)
+{
+ popallfiles();
+ if (parsefile->fd > 0) {
+ close(parsefile->fd);
+ parsefile->fd = 0;
+ }
+}
+/* $NetBSD: jobs.c,v 1.56 2002/11/25 12:13:03 agc Exp $ */
+
+
+/* mode flags for set_curjob */
+#define CUR_DELETE 2
+#define CUR_RUNNING 1
+#define CUR_STOPPED 0
+
+/* mode flags for dowait */
+#define DOWAIT_NORMAL 0
+#define DOWAIT_BLOCK 1
+
+/* array of jobs */
+static struct job *jobtab;
+/* size of array */
+static unsigned njobs;
+#if JOBS
+/* pgrp of shell on invocation */
+static int initialpgrp;
+static int ttyfd = -1;
+#endif
+/* current job */
+static struct job *curjob;
+/* number of presumed living untracked jobs */
+static int jobless;
+
+static void set_curjob(struct job *, unsigned);
+#if JOBS
+static int restartjob(struct job *, int);
+static void xtcsetpgrp(int, pid_t);
+static char *commandtext(union node *);
+static void cmdlist(union node *, int);
+static void cmdtxt(union node *);
+static void cmdputs(const char *);
+static void showpipe(struct job *, FILE *);
+#endif
+static int sprint_status(char *, int, int);
+static void freejob(struct job *);
+static struct job *getjob(const char *, int);
+static struct job *growjobtab(void);
+static void forkchild(struct job *, union node *, int);
+static void forkparent(struct job *, union node *, int, pid_t);
+static int dowait(int, struct job *);
+static int getstatus(struct job *);
+
+static void
+set_curjob(struct job *jp, unsigned mode)
+{
+ struct job *jp1;
+ struct job **jpp, **curp;
+
+ /* first remove from list */
+ jpp = curp = &curjob;
+ do {
+ jp1 = *jpp;
+ if (jp1 == jp)
+ break;
+ jpp = &jp1->prev_job;
+ } while (1);
+ *jpp = jp1->prev_job;
+
+ /* Then re-insert in correct position */
+ jpp = curp;
+ switch (mode) {
+ default:
+#ifdef DEBUG
+ abort();
+#endif
+ case CUR_DELETE:
+ /* job being deleted */
+ break;
+ case CUR_RUNNING:
+ /* newly created job or backgrounded job,
+ put after all stopped jobs. */
+ do {
+ jp1 = *jpp;
+#ifdef JOBS
+ if (!jp1 || jp1->state != JOBSTOPPED)
+#endif
+ break;
+ jpp = &jp1->prev_job;
+ } while (1);
+ /* FALLTHROUGH */
+#ifdef JOBS
+ case CUR_STOPPED:
+#endif
+ /* newly stopped job - becomes curjob */
+ jp->prev_job = *jpp;
+ *jpp = jp;
+ break;
+ }
+}
+
+#if JOBS
+/*
+ * Turn job control on and off.
+ *
+ * Note: This code assumes that the third arg to ioctl is a character
+ * pointer, which is true on Berkeley systems but not System V. Since
+ * System V doesn't have job control yet, this isn't a problem now.
+ *
+ * Called with interrupts off.
+ */
+
+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;
+ }
+ 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 (**++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;
+ }
+
+ 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;
+ }
+ name = u_signal_names(*argptr, &signo, -1);
+ if (name)
+ out1fmt(snlfmt, name);
+ else
+ error("invalid signal number or exit status: %s", *argptr);
+ return 0;
+ }
+
+ 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;
+ }
+ } while (*++argv);
+
+ return i;
+}
+#endif /* JOBS */
+
+#if defined(JOBS) || defined(DEBUG)
+static int
+jobno(const struct job *jp)
+{
+ return jp - jobtab + 1;
+}
+#endif
+
+#ifdef JOBS
+static int
+fgcmd(int argc, char **argv)
+{
+ struct job *jp;
+ FILE *out;
+ int mode;
+ int retval;
+
+ mode = (**argv == 'f') ? FORK_FG : FORK_BG;
+ nextopt(nullstr);
+ argv = argptr;
+ out = stdout;
+ do {
+ jp = getjob(*argv, 1);
+ if (mode == FORK_BG) {
+ set_curjob(jp, CUR_RUNNING);
+ fprintf(out, "[%d] ", jobno(jp));
+ }
+ outstr(jp->ps->cmd, out);
+ showpipe(jp, out);
+ retval = restartjob(jp, mode);
+ } while (*argv && *++argv);
+ return retval;
+}
+
+static int bgcmd(int, char **) __attribute__((__alias__("fgcmd")));
+
+
+static int
+restartjob(struct job *jp, int mode)
+{
+ struct procstat *ps;
+ int i;
+ int status;
+ pid_t pgid;
+
+ 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;
+}
+#endif
+
+static int
+sprint_status(char *s, int status, int sigonly)
+{
+ int col;
+ int st;
+
+ col = 0;
+ st = WEXITSTATUS(status);
+ if (!WIFEXITED(status)) {
+ st = WSTOPSIG(status);
+#if JOBS
+ if (!WIFSTOPPED(status))
+ st = WTERMSIG(status);
+#endif
+ if (sigonly) {
+ if (st == SIGINT || st == SIGPIPE)
+ goto out;
+ if (WIFSTOPPED(status))
+ goto out;
+ }
+ st &= 0x7f;
+ col = fmtstr(s, 32, u_signal_names(NULL, &st, 0));
+ if (WCOREDUMP(status)) {
+ col += fmtstr(s + col, 16, " (core dumped)");
+ }
+ } else if (!sigonly) {
+ if (st)
+ col = fmtstr(s, 16, "Done(%d)", st);
+ else
+ col = fmtstr(s, 16, "Done");
+ }
+
+out:
+ return col;
+}
+
+#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;
+
+ if (mode & SHOW_PGID) {
+ /* just output process (group) id of pipeline */
+ fprintf(out, "%d\n", ps->pid);
+ return;
+ }
+
+ col = fmtstr(s, 16, "[%d] ", jobno(jp));
+ indent = col;
+
+ if (jp == curjob)
+ s[col - 2] = '+';
+ else if (curjob && jp == curjob->prev_job)
+ s[col - 2] = '-';
+
+ if (mode & SHOW_PID)
+ col += fmtstr(s + col, 16, "%d ", ps->pid);
+
+ psend = ps + jp->nprocs;
+
+ if (jp->state == JOBRUNNING) {
+ scopy("Running", s + col);
+ col += strlen("Running");
+ } else {
+ int status = psend[-1].status;
+#if JOBS
+ if (jp->state == JOBSTOPPED)
+ status = jp->stopstatus;
+#endif
+ col += sprint_status(s + col, status, 0);
+ }
+
+ goto start;
+
+ do {
+ /* for each process */
+ col = fmtstr(s, 48, " |\n%*c%d ", indent, ' ', ps->pid) - 3;
+
+start:
+ fprintf(
+ out, "%s%*c%s",
+ s, 33 - col >= 0 ? 33 - col : 0, ' ', ps->cmd
+ );
+ if (!(mode & SHOW_PID)) {
+ showpipe(jp, out);
+ break;
+ }
+ if (++ps == psend) {
+ outcslow('\n', out);
+ break;
+ }
+ } while (1);
+
+ jp->changed = 0;
+
+ if (jp->state == JOBDONE) {
+ TRACE(("showjob: freeing job %d\n", jobno(jp)));
+ freejob(jp);
+ }
+}
+
+
+static int
+jobscmd(int argc, char **argv)
+{
+ int mode, m;
+ FILE *out;
+
+ mode = 0;
+ while ((m = nextopt("lp")))
+ if (m == 'l')
+ mode = SHOW_PID;
+ else
+ mode = SHOW_PGID;
+
+ out = stdout;
+ argv = argptr;
+ if (*argv)
+ do
+ showjob(out, getjob(*argv,0), mode);
+ while (*++argv);
+ else
+ showjobs(out, mode);
+
+ return 0;
+}
+
+
+/*
+ * Print a list of jobs. If "change" is nonzero, only print jobs whose
+ * statuses have changed since the last call to showjobs.
+ */
+
+static void
+showjobs(FILE *out, int mode)
+{
+ 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;
+
+ for (jp = curjob; jp; jp = jp->prev_job) {
+ if (!(mode & SHOW_CHANGED) || jp->changed)
+ showjob(out, jp, mode);
+ }
+}
+#endif /* JOBS */
+
+/*
+ * Mark a job structure as unused.
+ */
+
+static void
+freejob(struct job *jp)
+{
+ struct procstat *ps;
+ int i;
+
+ 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;
+}
+
+
+static int
+waitcmd(int argc, char **argv)
+{
+ struct job *job;
+ int retval;
+ struct job *jp;
+
+ EXSIGON();
+
+ nextopt(nullstr);
+ retval = 0;
+
+ argv = argptr;
+ if (!*argv) {
+ /* wait for all jobs */
+ for (;;) {
+ jp = curjob;
+ while (1) {
+ if (!jp) {
+ /* no running procs */
+ goto out;
+ }
+ if (jp->state == JOBRUNNING)
+ break;
+ jp->waited = 1;
+ jp = jp->prev_job;
+ }
+ dowait(DOWAIT_BLOCK, 0);
+ }
+ }
+
+ retval = 127;
+ do {
+ if (**argv != '%') {
+ pid_t pid = number(*argv);
+ job = curjob;
+ goto start;
+ do {
+ if (job->ps[job->nprocs - 1].pid == pid)
+ break;
+ job = job->prev_job;
+start:
+ if (!job)
+ goto repeat;
+ } while (1);
+ } else
+ job = getjob(*argv, 0);
+ /* loop until process terminated or stopped */
+ while (job->state == JOBRUNNING)
+ dowait(DOWAIT_BLOCK, 0);
+ job->waited = 1;
+ retval = getstatus(job);
+repeat:
+ ;
+ } while (*++argv);
+
+out:
+ return retval;
+}
+
+
+
+/*
+ * Convert a job name to a job structure.
+ */
+
+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 *);
+
+ jp = curjob;
+ p = name;
+ if (!p)
+ goto currentjob;
+
+ if (*p != '%')
+ goto err;
+
+ c = *++p;
+ if (!c)
+ goto currentjob;
+
+ if (!p[1]) {
+ if (c == '+' || c == '%') {
+currentjob:
+ err_msg = "No current job";
+ goto check;
+ } else if (c == '-') {
+ if (jp)
+ jp = jp->prev_job;
+ err_msg = "No previous job";
+check:
+ if (!jp)
+ goto err;
+ goto gotit;
+ }
+ }
+
+ if (is_number(p)) {
+ num = atoi(p);
+ if (num < njobs) {
+ jp = jobtab + num - 1;
+ if (jp->used)
+ goto gotit;
+ goto 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";
+ }
+ jp = jp->prev_job;
+ }
+
+gotit:
+#if JOBS
+ err_msg = "job %s not created under job control";
+ if (getctl && jp->jobctl == 0)
+ goto err;
+#endif
+ return jp;
+err:
+ error(err_msg, name);
+}
+
+
+
+/*
+ * Return a new job structure.
+ * 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();
+ break;
+ }
+ if (jp->used == 0)
+ 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));
+ }
+ TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long)node, nprocs,
+ jobno(jp)));
+ return jp;
+}
+
+static struct job *
+growjobtab(void)
+{
+ size_t len;
+ ptrdiff_t offset;
+ struct job *jp, *jq;
+
+ len = njobs * sizeof(*jp);
+ jq = jobtab;
+ jp = ckrealloc(jq, len + 4 * sizeof(*jp));
+
+ offset = (char *)jp - (char *)jq;
+ if (offset) {
+ /* Relocate pointers */
+ size_t l = len;
+
+ jq = (struct job *)((char *)jq + l);
+ while (l) {
+ l -= sizeof(*jp);
+ jq--;
+#define joff(p) ((struct job *)((char *)(p) + l))
+#define jmove(p) (p) = (void *)((char *)(p) + offset)
+ if (likely(joff(jp)->ps == &jq->ps0))
+ jmove(joff(jp)->ps);
+ if (joff(jp)->prev_job)
+ jmove(joff(jp)->prev_job);
+ }
+ if (curjob)
+ jmove(curjob);
+#undef joff
+#undef jmove
+ }
+
+ njobs += 4;
+ jobtab = jp;
+ jp = (struct job *)((char *)jp + len);
+ jq = jp + 3;
+ do {
+ jq->used = 0;
+ } while (--jq >= jp);
+ return jp;
+}
+
+
+/*
+ * Fork 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)
+{
+ int wasroot;
+
+ TRACE(("Child shell %d\n", getpid()));
+ wasroot = rootshell;
+ rootshell = 0;
+
+ closescript();
+ clear_traps();
+#if JOBS
+ /* do job control only in root shell */
+ jobctl = 0;
+ if (mode != FORK_NOJOB && jp->jobctl && wasroot) {
+ pid_t pgrp;
+
+ 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);
+ }
+ }
+ if (wasroot && iflag) {
+ setsignal(SIGINT);
+ setsignal(SIGQUIT);
+ setsignal(SIGTERM);
+ }
+ for (jp = curjob; jp; jp = jp->prev_job)
+ freejob(jp);
+ jobless = 0;
+}
+
+static inline void
+forkparent(struct job *jp, union node *n, int mode, pid_t pid)
+{
+ TRACE(("In parent shell: child = %d\n", pid));
+ if (!jp) {
+ while (jobless && dowait(DOWAIT_NORMAL, 0) > 0);
+ jobless++;
+ return;
+ }
+#if JOBS
+ if (mode != FORK_NOJOB && jp->jobctl) {
+ int pgrp;
+
+ if (jp->nprocs == 0)
+ pgrp = pid;
+ else
+ pgrp = jp->ps[0].pid;
+ /* 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);
+ }
+ 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
+ }
+}
+
+static int
+forkshell(struct job *jp, union node *n, int mode)
+{
+ int pid;
+
+ TRACE(("forkshell(%%%d, %p, %d) called\n", jobno(jp), n, mode));
+ pid = fork();
+ if (pid < 0) {
+ TRACE(("Fork failed, errno=%d", errno));
+ if (jp)
+ freejob(jp);
+ error("Cannot fork");
+ }
+ if (pid == 0)
+ forkchild(jp, n, mode);
+ else
+ forkparent(jp, n, mode, pid);
+ return pid;
+}
+
+/*
+ * Wait for job to finish.
+ *
+ * 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.
+ */
+
+int
+waitforjob(struct job *jp)
+{
+ int st;
+
+ 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);
+ }
+ if (jp->state == JOBDONE)
+#endif
+ freejob(jp);
+ return st;
+}
+
+
+/*
+ * 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.
+ */
+
+static inline int
+waitproc(int block, int *status)
+{
+ int flags = 0;
+
+#if JOBS
+ if (jobctl)
+ flags |= WUNTRACED;
+#endif
+ if (block == 0)
+ flags |= WNOHANG;
+ return wait3(status, flags, (struct rusage *)NULL);
+}
+
+/*
+ * Wait for a process to terminate.
+ */
+
+static int
+dowait(int block, struct job *job)
+{
+ int pid;
+ int status;
+ struct job *jp;
+ struct job *thisjob;
+ int state;
+
+ 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;
+ }
+ if (sp->status == -1)
+ state = JOBRUNNING;
+#ifdef JOBS
+ if (state == JOBRUNNING)
+ continue;
+ if (WIFSTOPPED(sp->status)) {
+ jp->stopstatus = sp->status;
+ state = JOBSTOPPED;
+ }
+#endif
+ } while (++sp < spend);
+ if (thisjob)
+ goto gotjob;
+ }
+#ifdef JOBS
+ if (!WIFSTOPPED(status))
+#endif
+
+ jobless--;
+ goto out;
+
+gotjob:
+ if (state != JOBRUNNING) {
+ thisjob->changed = 1;
+
+ if (thisjob->state != state) {
+ TRACE(("Job %d: changing state from %d to %d\n", jobno(thisjob), thisjob->state, state));
+ thisjob->state = state;
+#ifdef JOBS
+ if (state == JOBSTOPPED) {
+ set_curjob(thisjob, CUR_STOPPED);
+ }
+#endif
+ }
+ }
+
+out:
+ INTON;
+
+ if (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);
+ }
+ }
+ return pid;
+}
+
+
+
+/*
+ * return 1 if there are stopped jobs, otherwise 0
+ */
+int
+stoppedjobs(void)
+{
+ struct job *jp;
+ int retval;
+
+ 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;
+}
+
+/*
+ * Return a string identifying a command (to be printed by the
+ * jobs command).
+ */
+
+#if JOBS
+static char *cmdnextc;
+
+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 savestr(name);
+}
+
+static void
+cmdtxt(union node *n)
+{
+ union node *np;
+ struct nodelist *lp;
+ const char *p;
+ char s[2];
+
+ 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;
+ } else {
+ n = n->nfile.fname;
+ goto donode;
+ }
+ }
+}
+
+static void
+cmdlist(union node *np, int sep)
+{
+ for (; np; np = np->narg.next) {
+ if (!sep)
+ cmdputs(spcstr);
+ cmdtxt(np);
+ if (sep && np->narg.next)
+ cmdputs(spcstr);
+ }
+}
+
+
+static void
+cmdputs(const char *s)
+{
+ const char *p, *str;
+ char c, cc[2] = " ";
+ char *nextc;
+ int subtype = 0;
+ int quoted = 0;
+ static const char *const vstype[16] = {
+ nullstr, "}", "-", "+", "?", "=",
+ "#", "##", "%", "%%"
+ };
+
+ nextc = makestrspace((strlen(s) + 1) * 8, cmdnextc);
+ p = s;
+ while ((c = *p++) != 0) {
+ str = 0;
+ switch (c) {
+ case CTLESC:
+ c = *p++;
+ break;
+ case CTLVAR:
+ subtype = *p++;
+ if ((subtype & VSTYPE) == VSLENGTH)
+ str = "${#";
+ else
+ str = "${";
+ if (!(subtype & VSQUOTE) != !(quoted & 1)) {
+ quoted ^= 1;
+ c = '"';
+ } else
+ goto dostr;
+ break;
+ case CTLENDVAR:
+ quoted >>= 1;
+ subtype = 0;
+ if (quoted & 1) {
+ str = "\"}";
+ goto dostr;
+ }
+ c = '}';
+ break;
+ case CTLBACKQ:
+ str = "$(...)";
+ goto dostr;
+ case CTLBACKQ+CTLQUOTE:
+ str = "\"$(...)\"";
+ goto dostr;
+#ifdef CONFIG_ASH_MATH_SUPPORT
+ case CTLARI:
+ str = "$((";
+ goto dostr;
+ case CTLENDARI:
+ str = "))";
+ goto dostr;
+#endif
+ case CTLQUOTEMARK:
+ quoted ^= 1;
+ c = '"';
+ break;
+ case '=':
+ if (subtype == 0)
+ break;
+ str = vstype[subtype & VSTYPE];
+ if (subtype & VSNUL)
+ c = ':';
+ else
+ c = *str++;
+ if (c != '}')
+ quoted <<= 1;
+ break;
+ case '\'':
+ case '\\':
+ case '"':
+ case '$':
+ /* These can only happen inside quotes */
+ cc[0] = c;
+ str = cc;
+ c = '\\';
+ break;
+ default:
+ break;
+ }
+ USTPUTC(c, nextc);
+ if (!str)
+ continue;
+dostr:
+ while ((c = *str++)) {
+ USTPUTC(c, nextc);
+ }
+ }
+ if (quoted & 1) {
+ USTPUTC('"', nextc);
+ }
+ *nextc = 0;
+ cmdnextc = nextc;
+}
+
+
+static void
+showpipe(struct job *jp, FILE *out)
+{
+ struct procstat *sp;
+ struct procstat *spend;
+
+ spend = jp->ps + jp->nprocs;
+ for (sp = jp->ps + 1; sp < spend; sp++)
+ fprintf(out, " | %s", sp->cmd);
+ outcslow('\n', out);
+ flushall();
+}
+
+static void
+xtcsetpgrp(int fd, pid_t pgrp)
+{
+ if (tcsetpgrp(fd, pgrp))
+ error("Cannot set tty process group (%m)");
+}
+#endif /* JOBS */
+
+static int
+getstatus(struct job *job) {
+ int status;
+ int retval;
+
+ status = job->ps[job->nprocs - 1].status;
+ retval = WEXITSTATUS(status);
+ if (!WIFEXITED(status)) {
+#if JOBS
+ retval = WSTOPSIG(status);
+ if (!WIFSTOPPED(status))
+#endif
+ {
+ /* XXX: limits number of signals */
+ retval = WTERMSIG(status);
+#if JOBS
+ if (retval == SIGINT)
+ job->sigint = 1;
+#endif
+ }
+ retval += 128;
+ }
+ TRACE(("getstatus: job %d, nproc %d, status %x, retval %x\n",
+ jobno(job), job->nprocs, status, retval));
+ return retval;
+}
+
+#ifdef CONFIG_ASH_MAIL
+/* $NetBSD: mail.c,v 1.15 2002/11/24 22:35:40 christos Exp $ */
+
+/*
+ * Routines to check for mail. (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.
+ */
+
+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++);
+#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;
+ }
+ mail_var_path_changed = 0;
+ popstackmark(&smark);
+}
+
+
+static void
+changemail(const char *val)
+{
+ mail_var_path_changed++;
+}
+
+#endif /* CONFIG_ASH_MAIL */
+
+/* $NetBSD: main.c,v 1.46 2002/12/11 19:12:18 christos Exp $ */
+
+
+#if PROFILE
+static short profile_buf[16384];
+extern int etext();
+#endif
+
+static int isloginsh;
+
+static void read_profile(const char *);
+
+/*
+ * 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)
+{
+ char *shinit;
+ volatile int state;
+ struct jmploc jmploc;
+ struct stackmark smark;
+
+#ifdef __GLIBC__
+ dash_errno = __errno_location();
+#endif
+
+#if PROFILE
+ monitor(4, etext, profile_buf, sizeof profile_buf, 50);
+#endif
+ state = 0;
+ if (setjmp(jmploc.loc)) {
+ int status;
+ int e;
+
+ reset();
+
+ e = exception;
+ switch (exception) {
+ case EXEXEC:
+ status = exerrno;
+ break;
+
+ case EXERROR:
+ status = 2;
+ break;
+
+ default:
+ status = exitstatus;
+ break;
+ }
+ exitstatus = status;
+
+ if (e == EXEXIT || state == 0 || iflag == 0 || ! rootshell)
+ exitshell();
+
+ if (e == EXINT ) {
+ outcslow('\n', stderr);
+ }
+ popstackmark(&smark);
+ FORCEINTON; /* enable interrupts */
+ 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);
+#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() &&
+#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 );
+ }
+#endif
+ cmdloop(1);
+ }
+#if PROFILE
+ monitor(0);
+#endif
+#if GPROF
+ {
+ extern void _mcleanup(void);
+ _mcleanup();
+ }
+#endif
+ exitshell();
+ /* NOTREACHED */
+}
+
+
+/*
+ * Read and execute commands. "Top" is nonzero for the top level command
+ * loop; it turns on prompting if the shell is interactive.
+ */
+
+static void
+cmdloop(int top)
+{
+ union node *n;
+ struct stackmark smark;
+ int inter;
+ int numeof = 0;
+
+ TRACE(("cmdloop(%d) called\n", top));
+ 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);
+}
+
+
+
+/*
+ * Read /etc/profile or .profile. Return on error.
+ */
+
+static void
+read_profile(const char *name)
+{
+ int fd;
+ int xflag_set = 0;
+ int vflag_set = 0;
+
+ 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;
+ }
+ cmdloop(0);
+ if (qflag) {
+ if (xflag_set)
+ xflag = 1;
+ if (vflag_set)
+ vflag = 1;
+ }
+ popfile();
+}
+
+
+
+/*
+ * Read a file containing shell functions.
+ */
+
+static void
+readcmdfile(char *name)
+{
+ int fd;
+
+ INTOFF;
+ if ((fd = open(name, O_RDONLY)) >= 0)
+ setinputfd(fd, 1);
+ else
+ error("Can't open %s", name);
+ INTON;
+ cmdloop(0);
+ popfile();
+}
+
+
+/*
+ * Take commands from a file. To be compatible we should do a path
+ * search for the file, which is necessary to find sub-commands.
+ */
+
+static inline char *
+find_dot_file(char *name)
+{
+ char *fullname;
+ const char *path = pathval();
+ struct stat statb;
+
+ /* don't try this for absolute or relative paths */
+ if (strchr(name, '/'))
+ return name;
+
+ 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;
+ }
+ stunalloc(fullname);
+ }
+
+ /* not found in the PATH */
+ error(not_found_msg, name);
+ /* NOTREACHED */
+}
+
+int
+dotcmd(int argc, char **argv)
+{
+ exitstatus = 0;
+
+ if (argc >= 2) { /* That's what SVR2 does */
+ char *fullname;
+ struct stackmark smark;
+
+ setstackmark(&smark);
+ fullname = find_dot_file(argv[1]);
+ setinputfile(fullname, 1);
+ commandname = fullname;
+ cmdloop(0);
+ popfile();
+ popstackmark(&smark);
+ }
+ return exitstatus;
+}
+
+
+static int
+exitcmd(int argc, char **argv)
+{
+ if (stoppedjobs())
+ return 0;
+ if (argc > 1)
+ exitstatus = number(argv[1]);
+ exraise(EXEXIT);
+ /* NOTREACHED */
+}
+
+/* $NetBSD: memalloc.c,v 1.27 2003/01/22 20:36:04 dsl Exp $ */
+
+/*
+ * Like malloc, but returns an error when out of space.
+ */
+
+static pointer
+ckmalloc(size_t nbytes)
+{
+ pointer p;
+
+ p = malloc(nbytes);
+ if (p == NULL)
+ error(bb_msg_memory_exhausted);
+ return p;
+}
+
+
+/*
+ * Same for realloc.
+ */
+
+static pointer
+ckrealloc(pointer p, size_t nbytes)
+{
+ p = realloc(p, nbytes);
+ if (p == NULL)
+ error(bb_msg_memory_exhausted);
+ return p;
+}
+
+
+/*
+ * Make a copy of a string in safe storage.
+ */
+
+static char *
+savestr(const char *s)
+{
+ char *p = strdup(s);
+ if (!p)
+ error(bb_msg_memory_exhausted);
+ return p;
+}
+
+
+/*
+ * Parse trees for commands are allocated in lifo order, so we use a stack
+ * to make this more efficient, and also to avoid all sorts of exception
+ * handling code to handle interrupts in the middle of a parse.
+ *
+ * The size 504 was chosen because the Ultrix malloc handles that size
+ * well.
+ */
+
+
+static pointer
+stalloc(size_t nbytes)
+{
+ char *p;
+ size_t aligned;
+
+ aligned = SHELL_ALIGN(nbytes);
+ if (aligned > 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)
+ 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;
+}
+
+
+void
+stunalloc(pointer p)
+{
+#ifdef DEBUG
+ if (!p || (stacknxt < (char *)p) || ((char *)p < stackp->space)) {
+ write(2, "stunalloc\n", 10);
+ abort();
+ }
+#endif
+ stacknleft += stacknxt - (char *)p;
+ stacknxt = p;
+}
+
+
+
+void
+setstackmark(struct stackmark *mark)
+{
+ mark->stackp = stackp;
+ mark->stacknxt = stacknxt;
+ mark->stacknleft = stacknleft;
+ mark->marknext = markp;
+ markp = mark;
+}
+
+
+void
+popstackmark(struct stackmark *mark)
+{
+ struct stack_block *sp;
+
+ INTOFF;
+ markp = mark->marknext;
+ while (stackp != mark->stackp) {
+ sp = stackp;
+ stackp = sp->prev;
+ ckfree(sp);
+ }
+ stacknxt = mark->stacknxt;
+ stacknleft = mark->stacknleft;
+ sstrend = mark->stacknxt + mark->stacknleft;
+ INTON;
+}
+
+
+/*
+ * 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.
+ */
+
+void
+growstackblock(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;
+
+ /*
+ * Stack marks pointing to the start of the old block
+ * must be relocated to point to the new block
+ */
+ xmark = markp;
+ while (xmark != NULL && xmark->stackp == oldstackp) {
+ xmark->stackp = stackp;
+ xmark->stacknxt = stacknxt;
+ xmark->stacknleft = stacknleft;
+ xmark = xmark->marknext;
+ }
+ INTON;
+ } else {
+ char *oldspace = stacknxt;
+ int oldlen = stacknleft;
+ char *p = stalloc(newlen);
+
+ /* free the space we just allocated */
+ stacknxt = memcpy(p, oldspace, oldlen);
+ stacknleft += newlen;
+ }
+}
+
+static inline void
+grabstackblock(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();
+ }
+ growstackblock();
+ return stackblock() + len;
+}
+
+/*
+ * Called from CHECKSTRSPACE.
+ */
+
+char *
+makestrspace(size_t newlen, char *p)
+{
+ size_t len = p - stacknxt;
+ size_t size = stackblocksize();
+
+ for (;;) {
+ size_t nleft;
+
+ size = stackblocksize();
+ nleft = size - len;
+ if (nleft >= newlen)
+ break;
+ growstackblock();
+ }
+ return stackblock() + len;
+}
+
+char *
+stnputs(const char *s, size_t n, char *p)
+{
+ p = makestrspace(n, p);
+ p = mempcpy(p, s, n);
+ return p;
+}
+
+char *
+stputs(const char *s, char *p)
+{
+ return stnputs(s, strlen(s), p);
+}
+
+/* $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.
+ */
+
+/*
+ * prefix -- see if pfx is a prefix of string.
+ */
+
+char *
+prefix(const char *string, const char *pfx)
+{
+ while (*pfx) {
+ if (*pfx++ != *string++)
+ return 0;
+ }
+ return (char *) string;
+}
+
+
+/*
+ * Convert a string of digits to an integer, printing an error message on
+ * failure.
+ */
+
+int
+number(const char *s)
+{
+
+ if (! is_number(s))
+ error(illnum, s);
+ return atoi(s);
+}
+
+
+
+/*
+ * Check for a valid number. This should be elsewhere.
+ */
+
+int
+is_number(const char *p)
+{
+ do {
+ if (! is_digit(*p))
+ return 0;
+ } while (*++p != '\0');
+ return 1;
+}
+
+
+/*
+ * Produce a possibly single quoted string suitable as input to the shell.
+ * The return string is allocated on the stack.
+ */
+
+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);
+
+ USTPUTC(0, p);
+
+ return stackblock();
+}
+
+/*
+ * Like strdup but works with the ash stack.
+ */
+
+char *
+sstrdup(const char *p)
+{
+ size_t len = strlen(p) + 1;
+ return memcpy(stalloc(len), p, len);
+}
+
+
+static void
+calcsize(union node *n)
+{
+ if (n == NULL)
+ return;
+ funcblocksize += nodesize[n->type];
+ switch (n->type) {
+ case NCMD:
+ calcsize(n->ncmd.redirect);
+ calcsize(n->ncmd.args);
+ calcsize(n->ncmd.assign);
+ break;
+ case NPIPE:
+ sizenodelist(n->npipe.cmdlist);
+ break;
+ case NREDIR:
+ case NBACKGND:
+ case NSUBSHELL:
+ calcsize(n->nredir.redirect);
+ calcsize(n->nredir.n);
+ break;
+ case NAND:
+ case NOR:
+ case NSEMI:
+ case NWHILE:
+ case NUNTIL:
+ calcsize(n->nbinary.ch2);
+ calcsize(n->nbinary.ch1);
+ break;
+ case NIF:
+ calcsize(n->nif.elsepart);
+ calcsize(n->nif.ifpart);
+ calcsize(n->nif.test);
+ break;
+ case NFOR:
+ funcstringsize += strlen(n->nfor.var) + 1;
+ calcsize(n->nfor.body);
+ calcsize(n->nfor.args);
+ break;
+ case NCASE:
+ calcsize(n->ncase.cases);
+ calcsize(n->ncase.expr);
+ break;
+ case NCLIST:
+ calcsize(n->nclist.body);
+ calcsize(n->nclist.pattern);
+ calcsize(n->nclist.next);
+ break;
+ case NDEFUN:
+ case NARG:
+ sizenodelist(n->narg.backquote);
+ funcstringsize += strlen(n->narg.text) + 1;
+ calcsize(n->narg.next);
+ break;
+ case NTO:
+ case NCLOBBER:
+ case NFROM:
+ case NFROMTO:
+ case NAPPEND:
+ calcsize(n->nfile.fname);
+ calcsize(n->nfile.next);
+ break;
+ case NTOFD:
+ case NFROMFD:
+ calcsize(n->ndup.vname);
+ calcsize(n->ndup.next);
+ break;
+ case NHERE:
+ case NXHERE:
+ calcsize(n->nhere.doc);
+ calcsize(n->nhere.next);
+ break;
+ case NNOT:
+ calcsize(n->nnot.com);
+ break;
+ };
+}
+
+
+
+static void
+sizenodelist(struct nodelist *lp)
+{
+ while (lp) {
+ funcblocksize += SHELL_ALIGN(sizeof(struct nodelist));
+ calcsize(lp->n);
+ lp = lp->next;
+ }
+}
+
+
+
+static union node *
+copynode(union node *n)
+{
+ union node *new;
+
+ if (n == NULL)
+ return NULL;
+ new = funcblock;
+ funcblock = (char *) funcblock + nodesize[n->type];
+ switch (n->type) {
+ case NCMD:
+ new->ncmd.redirect = copynode(n->ncmd.redirect);
+ new->ncmd.args = copynode(n->ncmd.args);
+ new->ncmd.assign = copynode(n->ncmd.assign);
+ break;
+ case NPIPE:
+ new->npipe.cmdlist = copynodelist(n->npipe.cmdlist);
+ new->npipe.backgnd = n->npipe.backgnd;
+ break;
+ case NREDIR:
+ case NBACKGND:
+ case NSUBSHELL:
+ new->nredir.redirect = copynode(n->nredir.redirect);
+ new->nredir.n = copynode(n->nredir.n);
+ break;
+ case NAND:
+ case NOR:
+ case NSEMI:
+ case NWHILE:
+ case NUNTIL:
+ new->nbinary.ch2 = copynode(n->nbinary.ch2);
+ new->nbinary.ch1 = copynode(n->nbinary.ch1);
+ break;
+ case NIF:
+ new->nif.elsepart = copynode(n->nif.elsepart);
+ new->nif.ifpart = copynode(n->nif.ifpart);
+ new->nif.test = copynode(n->nif.test);
+ break;
+ case NFOR:
+ new->nfor.var = nodesavestr(n->nfor.var);
+ new->nfor.body = copynode(n->nfor.body);
+ new->nfor.args = copynode(n->nfor.args);
+ break;
+ case NCASE:
+ new->ncase.cases = copynode(n->ncase.cases);
+ new->ncase.expr = copynode(n->ncase.expr);
+ break;
+ case NCLIST:
+ new->nclist.body = copynode(n->nclist.body);
+ new->nclist.pattern = copynode(n->nclist.pattern);
+ new->nclist.next = copynode(n->nclist.next);
+ break;
+ case NDEFUN:
+ case NARG:
+ new->narg.backquote = copynodelist(n->narg.backquote);
+ new->narg.text = nodesavestr(n->narg.text);
+ new->narg.next = copynode(n->narg.next);
+ break;
+ case NTO:
+ case NCLOBBER:
+ case NFROM:
+ case NFROMTO:
+ case NAPPEND:
+ new->nfile.fname = copynode(n->nfile.fname);
+ new->nfile.fd = n->nfile.fd;
+ new->nfile.next = copynode(n->nfile.next);
+ break;
+ case NTOFD:
+ case NFROMFD:
+ new->ndup.vname = copynode(n->ndup.vname);
+ new->ndup.dupfd = n->ndup.dupfd;
+ new->ndup.fd = n->ndup.fd;
+ new->ndup.next = copynode(n->ndup.next);
+ break;
+ case NHERE:
+ case NXHERE:
+ new->nhere.doc = copynode(n->nhere.doc);
+ new->nhere.fd = n->nhere.fd;
+ new->nhere.next = copynode(n->nhere.next);
+ break;
+ case NNOT:
+ new->nnot.com = copynode(n->nnot.com);
+ break;
+ };
+ new->type = n->type;
+ return new;
+}
+
+
+static struct nodelist *
+copynodelist(struct nodelist *lp)
+{
+ struct nodelist *start;
+ struct nodelist **lpp;
+
+ 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 char *
+nodesavestr(char *s)
+{
+ char *rtn = funcstring;
+
+ funcstring = stpcpy(funcstring, s) + 1;
+ return rtn;
+}
+
+
+
+/*
+ * Free a parse tree.
+ */
+
+static void
+freefunc(struct funcnode *f)
+{
+ if (f && --f->count < 0)
+ ckfree(f);
+}
+
+
+static void options(int);
+static void setoption(int, int);
+
+
+/*
+ * Process the shell command line arguments.
+ */
+
+void
+procargs(int argc, char **argv)
+{
+ int i;
+ const char *xminusc;
+ char **xargv;
+
+ 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;
+ }
+
+ shellparam.p = xargv;
+#ifdef CONFIG_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)
+{
+ 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))) {
+ optlist[i] = val;
+ return;
+ }
+ error("Illegal option -o %s", name);
+ }
+}
+
+/*
+ * Process shell options. The global variable argptr contains a pointer
+ * to the argument list; we advance it past the options.
+ */
+
+static void
+options(int cmdline)
+{
+ char *p;
+ int val;
+ int c;
+
+ if (cmdline)
+ minusc = NULL;
+ while ((p = *argptr) != NULL) {
+ argptr++;
+ if ((c = *p++) == '-') {
+ val = 1;
+ if (p[0] == '\0' || (p[0] == '-' && p[1] == '\0')) {
+ if (!cmdline) {
+ /* "-" means turn off -x and -v */
+ if (p[0] == '\0')
+ xflag = vflag = 0;
+ /* "--" means reset params */
+ else if (*argptr == NULL)
+ setparam(argptr);
+ }
+ break; /* "-" or "--" terminates options */
+ }
+ } else if (c == '+') {
+ val = 0;
+ } else {
+ argptr--;
+ break;
+ }
+ while ((c = *p++) != '\0') {
+ if (c == 'c' && cmdline) {
+ minusc = p; /* command is after shell args*/
+ } else if (c == 'o') {
+ minus_o(*argptr, val);
+ if (*argptr)
+ argptr++;
+ } else if (cmdline && (c == '-')) { // long options
+ if (strcmp(p, "login") == 0)
+ isloginsh = 1;
+ break;
+ } else {
+ setoption(c, val);
+ }
+ }
+ }
+}
+
+
+
+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)
+{
+ int n;
+ char **ap1, **ap2;
+
+ n = 1;
+ if (argc > 1)
+ n = number(argv[1]);
+ if (n > shellparam.nparam)
+ error("can't shift that many");
+ INTOFF;
+ shellparam.nparam -= n;
+ for (ap1 = shellparam.p ; --n >= 0 ; ap1++) {
+ if (shellparam.malloc)
+ ckfree(*ap1);
+ }
+ ap2 = shellparam.p;
+ while ((*ap2++ = *ap1++) != NULL);
+#ifdef CONFIG_ASH_GETOPTS
+ shellparam.optind = 1;
+ shellparam.optoff = -1;
+#endif
+ INTON;
+ return 0;
+}
+
+
+
+/*
+ * The set command builtin.
+ */
+
+int
+setcmd(int argc, char **argv)
+{
+ if (argc == 1)
+ return showvars(nullstr, 0, VUNSET);
+ INTOFF;
+ options(0);
+ optschanged();
+ if (*argptr != NULL) {
+ setparam(argptr);
+ }
+ INTON;
+ return 0;
+}
+
+
+#ifdef CONFIG_ASH_GETOPTS
+static void
+getoptsreset(value)
+ const char *value;
+{
+ shellparam.optind = number(value);
+ shellparam.optoff = -1;
+}
+#endif
+
+#ifdef CONFIG_LOCALE_SUPPORT
+static void change_lc_all(const char *value)
+{
+ if (value != 0 && *value != 0)
+ setlocale(LC_ALL, value);
+}
+
+static void change_lc_ctype(const char *value)
+{
+ if (value != 0 && *value != 0)
+ setlocale(LC_CTYPE, value);
+}
+
+#endif
+
+#ifdef CONFIG_ASH_GETOPTS
+static int
+getopts(char *optstr, char *optvar, char **optfirst, int *param_optind, int *optoff)
+{
+ char *p, *q;
+ char c = '?';
+ int done = 0;
+ int err = 0;
+ char s[10];
+ char **optnext = optfirst + *param_optind - 1;
+
+ if (*param_optind <= 1 || *optoff < 0 || !(*(optnext - 1)) ||
+ strlen(*(optnext - 1)) < *optoff)
+ p = NULL;
+ else
+ p = *(optnext - 1) + *optoff;
+ if (p == NULL || *p == '\0') {
+ /* Current word is done, advance */
+ if (optnext == NULL)
+ return 1;
+ p = *optnext;
+ if (p == NULL || *p != '-' || *++p == '\0') {
+atend:
+ p = NULL;
+ done = 1;
+ goto out;
+ }
+ optnext++;
+ if (p[0] == '-' && p[1] == '\0') /* check for "--" */
+ goto atend;
+ }
+
+ c = *p++;
+ for (q = optstr; *q != c; ) {
+ if (*q == '\0') {
+ if (optstr[0] == ':') {
+ s[0] = c;
+ s[1] = '\0';
+ err |= setvarsafe("OPTARG", s, 0);
+ } else {
+ fprintf(stderr, "Illegal option -%c\n", c);
+ (void) unsetvar("OPTARG");
+ }
+ c = '?';
+ goto out;
+ }
+ if (*++q == ':')
+ q++;
+ }
+
+ if (*++q == ':') {
+ if (*p == '\0' && (p = *optnext) == NULL) {
+ if (optstr[0] == ':') {
+ s[0] = c;
+ s[1] = '\0';
+ err |= setvarsafe("OPTARG", s, 0);
+ c = ':';
+ } else {
+ fprintf(stderr, "No arg for -%c option\n", c);
+ (void) unsetvar("OPTARG");
+ c = '?';
+ }
+ goto out;
+ }
+
+ if (p == *optnext)
+ optnext++;
+ err |= setvarsafe("OPTARG", p, 0);
+ p = NULL;
+ } else
+ err |= setvarsafe("OPTARG", nullstr, 0);
+
+out:
+ *optoff = p ? p - *(optnext - 1) : -1;
+ *param_optind = optnext - optfirst + 1;
+ fmtstr(s, sizeof(s), "%d", *param_optind);
+ err |= setvarsafe("OPTIND", s, VNOFUNC);
+ s[0] = c;
+ s[1] = '\0';
+ err |= setvarsafe(optvar, s, 0);
+ if (err) {
+ *param_optind = 1;
+ *optoff = -1;
+ flushall();
+ exraise(EXERROR);
+ }
+ return done;
+}
+
+/*
+ * The getopts builtin. Shellparam.optnext points to the next argument
+ * to be processed. Shellparam.optptr points to the next character to
+ * be processed in the current argument. If shellparam.optnext is NULL,
+ * then it's the first time getopts has been called.
+ */
+
+int
+getoptscmd(int argc, char **argv)
+{
+ char **optbase;
+
+ if (argc < 3)
+ error("Usage: getopts optstring var [arg]");
+ else if (argc == 3) {
+ optbase = shellparam.p;
+ if (shellparam.optind > shellparam.nparam + 1) {
+ shellparam.optind = 1;
+ shellparam.optoff = -1;
+ }
+ }
+ else {
+ optbase = &argv[3];
+ if (shellparam.optind > argc - 2) {
+ shellparam.optind = 1;
+ shellparam.optoff = -1;
+ }
+ }
+
+ return getopts(argv[1], argv[2], optbase, &shellparam.optind,
+ &shellparam.optoff);
+}
+#endif /* CONFIG_ASH_GETOPTS */
+
+/*
+ * XXX - should get rid of. have all builtins use getopt(3). the
+ * 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;
+}
+
+
+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;
+}
+
+
+/*
+ * Version of write which resumes after a signal is caught.
+ */
+
+static void
+xwrite(int fd, const void *p, size_t n)
+{
+ ssize_t i;
+
+ do {
+ i = bb_full_write(fd, p, n);
+ } while (i < 0 && errno == EINTR);
+}
+
+
+/* $NetBSD: parser.c,v 1.54 2002/11/24 22:35:42 christos Exp $ */
+
+
+/*
+ * Shell command parser.
+ */
+
+#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);
+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 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)
+{
+ union node *n1, *n2, *n3;
+ int tok;
+
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
+ if (nlflag == 2 && peektoken())
+ return NULL;
+ n1 = NULL;
+ for (;;) {
+ n2 = andor();
+ tok = readtoken();
+ if (tok == TBACKGND) {
+ if (n2->type == NPIPE) {
+ n2->npipe.backgnd = 1;
+ } else {
+ if (n2->type != NREDIR) {
+ n3 = stalloc(sizeof(struct nredir));
+ n3->nredir.n = n2;
+ n3->nredir.redirect = NULL;
+ n2 = n3;
+ }
+ n2->type = NBACKGND;
+ }
+ }
+ if (n1 == NULL) {
+ n1 = n2;
+ }
+ else {
+ n3 = (union node *)stalloc(sizeof (struct nbinary));
+ n3->type = NSEMI;
+ n3->nbinary.ch1 = n1;
+ n3->nbinary.ch2 = n2;
+ n1 = n3;
+ }
+ switch (tok) {
+ case TBACKGND:
+ case TSEMI:
+ tok = readtoken();
+ /* fall through */
+ case TNL:
+ if (tok == TNL) {
+ parseheredoc();
+ if (nlflag == 1)
+ return n1;
+ } else {
+ tokpushback++;
+ }
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
+ if (peektoken())
+ return n1;
+ break;
+ case TEOF:
+ if (heredoclist)
+ parseheredoc();
+ else
+ pungetc(); /* push back EOF on input */
+ return n1;
+ default:
+ if (nlflag == 1)
+ synexpect(-1);
+ tokpushback++;
+ return n1;
+ }
+ }
+}
+
+
+
+static union node *
+andor(void)
+{
+ union node *n1, *n2, *n3;
+ int t;
+
+ n1 = pipeline();
+ for (;;) {
+ if ((t = readtoken()) == TAND) {
+ t = NAND;
+ } else if (t == TOR) {
+ t = NOR;
+ } else {
+ tokpushback++;
+ return n1;
+ }
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
+ n2 = pipeline();
+ n3 = (union node *)stalloc(sizeof (struct nbinary));
+ n3->type = t;
+ n3->nbinary.ch1 = n1;
+ n3->nbinary.ch2 = n2;
+ n1 = n3;
+ }
+}
+
+
+
+static union node *
+pipeline(void)
+{
+ union node *n1, *n2, *pipenode;
+ struct nodelist *lp, *prev;
+ int negate;
+
+ negate = 0;
+ TRACE(("pipeline: entered\n"));
+ if (readtoken() == TNOT) {
+ negate = !negate;
+ checkkwd = CHKKWD | CHKALIAS;
+ } else
+ tokpushback++;
+ n1 = command();
+ if (readtoken() == TPIPE) {
+ pipenode = (union node *)stalloc(sizeof (struct npipe));
+ pipenode->type = NPIPE;
+ pipenode->npipe.backgnd = 0;
+ lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
+ pipenode->npipe.cmdlist = lp;
+ lp->n = n1;
+ do {
+ prev = lp;
+ lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
+ lp->n = command();
+ prev->next = lp;
+ } while (readtoken() == TPIPE);
+ lp->next = NULL;
+ n1 = pipenode;
+ }
+ tokpushback++;
+ if (negate) {
+ n2 = (union node *)stalloc(sizeof (struct nnot));
+ n2->type = NNOT;
+ n2->nnot.com = n1;
+ return n2;
+ } else
+ return n1;
+}
+
+
+
+static union node *
+command(void)
+{
+ union node *n1, *n2;
+ union node *ap, **app;
+ union node *cp, **cpp;
+ union node *redir, **rpp;
+ union node **rpp2;
+ int t;
+
+ redir = NULL;
+ rpp2 = &redir;
+
+ switch (readtoken()) {
+ default:
+ synexpect(-1);
+ /* NOTREACHED */
+ case TIF:
+ n1 = (union node *)stalloc(sizeof (struct nif));
+ n1->type = NIF;
+ n1->nif.test = list(0);
+ if (readtoken() != TTHEN)
+ synexpect(TTHEN);
+ n1->nif.ifpart = list(0);
+ n2 = n1;
+ while (readtoken() == TELIF) {
+ n2->nif.elsepart = (union node *)stalloc(sizeof (struct nif));
+ n2 = n2->nif.elsepart;
+ n2->type = NIF;
+ n2->nif.test = list(0);
+ if (readtoken() != TTHEN)
+ synexpect(TTHEN);
+ n2->nif.ifpart = list(0);
+ }
+ if (lasttoken == TELSE)
+ n2->nif.elsepart = list(0);
+ else {
+ n2->nif.elsepart = NULL;
+ tokpushback++;
+ }
+ t = TFI;
+ break;
+ case TWHILE:
+ case TUNTIL: {
+ int got;
+ n1 = (union node *)stalloc(sizeof (struct nbinary));
+ n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL;
+ n1->nbinary.ch1 = list(0);
+ if ((got=readtoken()) != TDO) {
+TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : ""));
+ synexpect(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));
+ n1->type = NFOR;
+ n1->nfor.var = wordtext;
+ checkkwd = CHKKWD | CHKALIAS;
+ if (readtoken() == TIN) {
+ app = &ap;
+ while (readtoken() == TWORD) {
+ n2 = (union node *)stalloc(sizeof (struct narg));
+ n2->type = NARG;
+ n2->narg.text = wordtext;
+ n2->narg.backquote = backquotelist;
+ *app = n2;
+ app = &n2->narg.next;
+ }
+ *app = NULL;
+ n1->nfor.args = ap;
+ if (lasttoken != TNL && lasttoken != TSEMI)
+ synexpect(-1);
+ } else {
+ n2 = (union node *)stalloc(sizeof (struct narg));
+ n2->type = NARG;
+ n2->narg.text = (char *)dolatstr;
+ n2->narg.backquote = NULL;
+ n2->narg.next = 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++;
+ }
+ checkkwd = CHKNL | CHKKWD | CHKALIAS;
+ if (readtoken() != TDO)
+ synexpect(TDO);
+ n1->nfor.body = list(0);
+ t = TDONE;
+ break;
+ case TCASE:
+ n1 = (union node *)stalloc(sizeof (struct ncase));
+ n1->type = NCASE;
+ if (readtoken() != TWORD)
+ synexpect(TWORD);
+ n1->ncase.expr = n2 = (union node *)stalloc(sizeof (struct narg));
+ n2->type = NARG;
+ n2->narg.text = wordtext;
+ n2->narg.backquote = backquotelist;
+ n2->narg.next = NULL;
+ do {
+ checkkwd = CHKKWD | CHKALIAS;
+ } while (readtoken() == TNL);
+ if (lasttoken != TIN)
+ synexpect(TIN);
+ cpp = &n1->ncase.cases;
+next_case:
+ checkkwd = CHKNL | CHKKWD;
+ t = readtoken();
+ while(t != TESAC) {
+ if (lasttoken == TLP)
+ readtoken();
+ *cpp = cp = (union node *)stalloc(sizeof (struct nclist));
+ cp->type = NCLIST;
+ app = &cp->nclist.pattern;
+ for (;;) {
+ *app = ap = (union node *)stalloc(sizeof (struct narg));
+ ap->type = NARG;
+ ap->narg.text = wordtext;
+ ap->narg.backquote = backquotelist;
+ if (readtoken() != TPIPE)
+ break;
+ app = &ap->narg.next;
+ readtoken();
+ }
+ ap->narg.next = NULL;
+ if (lasttoken != TRP)
+ synexpect(TRP);
+ cp->nclist.body = list(2);
+
+ cpp = &cp->nclist.next;
+
+ checkkwd = CHKNL | CHKKWD;
+ if ((t = readtoken()) != TESAC) {
+ if (t != TENDCASE)
+ synexpect(TENDCASE);
+ else
+ goto next_case;
+ }
+ }
+ *cpp = NULL;
+ goto redir;
+ case TLP:
+ n1 = (union node *)stalloc(sizeof (struct nredir));
+ n1->type = NSUBSHELL;
+ n1->nredir.n = list(0);
+ n1->nredir.redirect = NULL;
+ t = TRP;
+ break;
+ case TBEGIN:
+ n1 = list(0);
+ t = TEND;
+ break;
+ case TWORD:
+ case TREDIR:
+ tokpushback++;
+ return simplecmd();
+ }
+
+ if (readtoken() != t)
+ synexpect(t);
+
+redir:
+ /* Now check for redirection which may follow command */
+ checkkwd = CHKKWD | CHKALIAS;
+ rpp = rpp2;
+ while (readtoken() == TREDIR) {
+ *rpp = n2 = redirnode;
+ rpp = &n2->nfile.next;
+ parsefname();
+ }
+ tokpushback++;
+ *rpp = NULL;
+ if (redir) {
+ if (n1->type != NSUBSHELL) {
+ n2 = (union node *)stalloc(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)
+{
+ 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;
+ }
+ }
+
+ if (checkkwd & CHKALIAS) {
+#ifdef CONFIG_ASH_ALIAS
+ struct alias *ap;
+ if ((ap = lookupalias(wordtext, 1)) != NULL) {
+ if (*ap->val) {
+ pushstring(ap->val, ap);
+ }
+ goto top;
+ }
+#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];
+ }
+ }
+ }
+}
+
+
+#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
+ * is not NULL, read a here document. In the latter case, eofmark is the
+ * word which marks the end of the document and striptabs is true if
+ * leading tabs should be stripped from the document. The argument firstc
+ * is the first character of the input token or document.
+ *
+ * Because C does not have internal subroutines, I have simulated them
+ * 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)
+{
+ 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 */
+#if __GNUC__
+ /* Avoid longjmp clobbering */
+ (void) &out;
+ (void) &quotef;
+ (void) &dblquote;
+ (void) &varnest;
+ (void) &arinest;
+ (void) &parenlevel;
+ (void) &dqvarnest;
+ (void) &oldstyle;
+ (void) &prevsyntax;
+ (void) &syntax;
+#endif
+
+ startlinno = plinno;
+ dblquote = 0;
+ if (syntax == DQSYNTAX)
+ dblquote = 1;
+ quotef = 0;
+ bqlist = NULL;
+ varnest = 0;
+ arinest = 0;
+ parenlevel = 0;
+ dqvarnest = 0;
+
+ STARTSTACKSTR(out);
+ loop: { /* for each line, until end of word */
+ CHECKEND(); /* set c to PEOF if at end of here document */
+ for (;;) { /* until end of line or end of word */
+ CHECKSTRSPACE(4, out); /* permit 4 calls to USTPUTC */
+ switch(SIT(c, syntax)) {
+ case CNL: /* '\n' */
+ if (syntax == BASESYNTAX)
+ goto endword; /* exit outer loop */
+ USTPUTC(c, out);
+ plinno++;
+ if (doprompt)
+ setprompt(2);
+ c = pgetc();
+ goto loop; /* continue outer loop */
+ case CWORD:
+ USTPUTC(c, out);
+ break;
+ case CCTL:
+ if (eofmark == NULL || dblquote)
+ USTPUTC(CTLESC, out);
+ USTPUTC(c, out);
+ break;
+ case CBACK: /* backslash */
+ c = pgetc2();
+ if (c == PEOF) {
+ USTPUTC(CTLESC, out);
+ USTPUTC('\\', out);
+ pungetc();
+ } else if (c == '\n') {
+ if (doprompt)
+ setprompt(2);
+ } else {
+ if (
+ dblquote &&
+ c != '\\' && c != '`' &&
+ c != '$' && (
+ c != '"' ||
+ eofmark != NULL
+ )
+ ) {
+ USTPUTC(CTLESC, out);
+ USTPUTC('\\', out);
+ }
+ if (SIT(c, SQSYNTAX) == CCTL)
+ USTPUTC(CTLESC, out);
+ USTPUTC(c, out);
+ quotef++;
+ }
+ break;
+ case CSQUOTE:
+ syntax = SQSYNTAX;
+quotemark:
+ if (eofmark == NULL) {
+ USTPUTC(CTLQUOTEMARK, out);
+ }
+ break;
+ case CDQUOTE:
+ syntax = DQSYNTAX;
+ dblquote = 1;
+ goto quotemark;
+ case CENDQUOTE:
+ if (eofmark != NULL && arinest == 0 &&
+ varnest == 0) {
+ USTPUTC(c, out);
+ } else {
+ if (dqvarnest == 0) {
+ syntax = BASESYNTAX;
+ dblquote = 0;
+ }
+ quotef++;
+ goto quotemark;
+ }
+ break;
+ case CVAR: /* '$' */
+ PARSESUB(); /* parse substitution */
+ break;
+ case CENDVAR: /* '}' */
+ if (varnest > 0) {
+ varnest--;
+ if (dqvarnest > 0) {
+ dqvarnest--;
+ }
+ USTPUTC(CTLENDVAR, out);
+ } else {
+ USTPUTC(c, out);
+ }
+ break;
+#ifdef CONFIG_ASH_MATH_SUPPORT
+ case CLP: /* '(' in arithmetic */
+ parenlevel++;
+ USTPUTC(c, out);
+ break;
+ case CRP: /* ')' in arithmetic */
+ if (parenlevel > 0) {
+ USTPUTC(c, out);
+ --parenlevel;
+ } else {
+ if (pgetc() == ')') {
+ if (--arinest == 0) {
+ USTPUTC(CTLENDARI, out);
+ syntax = prevsyntax;
+ if (syntax == DQSYNTAX)
+ dblquote = 1;
+ else
+ dblquote = 0;
+ } else
+ USTPUTC(')', out);
+ } else {
+ /*
+ * unbalanced parens
+ * (don't 2nd guess - no error)
+ */
+ pungetc();
+ USTPUTC(')', out);
+ }
+ }
+ break;
+#endif
+ case CBQUOTE: /* '`' */
+ PARSEBACKQOLD();
+ break;
+ case CENDFILE:
+ goto endword; /* exit outer loop */
+ case CIGN:
+ break;
+ default:
+ if (varnest == 0)
+ goto endword; /* exit outer loop */
+#ifdef CONFIG_ASH_ALIAS
+ if (c != PEOA)
+#endif
+ USTPUTC(c, out);
+
+ }
+ c = pgetc_macro();
+ }
+ }
+endword:
+#ifdef CONFIG_ASH_MATH_SUPPORT
+ if (syntax == ARISYNTAX)
+ synerror("Missing '))'");
+#endif
+ if (syntax != BASESYNTAX && ! parsebackquote && eofmark == NULL)
+ synerror("Unterminated quoted string");
+ if (varnest != 0) {
+ startlinno = plinno;
+ /* { */
+ synerror("Missing '}'");
+ }
+ USTPUTC('\0', out);
+ len = out - (char *)stackblock();
+ out = stackblock();
+ if (eofmark == NULL) {
+ if ((c == '>' || c == '<')
+ && quotef == 0
+ && len <= 2
+ && (*out == '\0' || is_digit(*out))) {
+ PARSEREDIR();
+ return lasttoken = TREDIR;
+ } else {
+ pungetc();
+ }
+ }
+ quoteflag = quotef;
+ backquotelist = bqlist;
+ grabstackblock(len);
+ wordtext = out;
+ return lasttoken = TWORD;
+/* 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 (c == PEOA) {
+ c = pgetc2();
+ }
+#endif
+ if (striptabs) {
+ while (c == '\t') {
+ c = pgetc2();
+ }
+ }
+ if (c == *eofmark) {
+ if (pfgets(line, sizeof line) != NULL) {
+ char *p, *q;
+
+ p = line;
+ for (q = eofmark + 1 ; *q && *p == *q ; p++, q++);
+ if (*p == '\n' && *q == '\0') {
+ c = PEOF;
+ plinno++;
+ needprompt = doprompt;
+ } else {
+ pushstring(line, NULL);
+ }
+ }
+ }
+ }
+ goto checkend_return;
+}
+
+
+/*
+ * 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;
+ union node *np;
+
+ np = (union node *)stalloc(sizeof (struct nfile));
+ if (c == '>') {
+ np->nfile.fd = 1;
+ c = pgetc();
+ if (c == '>')
+ np->type = NAPPEND;
+ else if (c == '|')
+ np->type = NCLOBBER;
+ else if (c == '&')
+ np->type = NTOFD;
+ else {
+ np->type = NTO;
+ pungetc();
+ }
+ } else { /* c == '<' */
+ np->nfile.fd = 0;
+ switch (c = pgetc()) {
+ case '<':
+ if (sizeof (struct nfile) != sizeof (struct nhere)) {
+ np = (union node *)stalloc(sizeof (struct nhere));
+ np->nfile.fd = 0;
+ }
+ np->type = NHERE;
+ heredoc = (struct heredoc *)stalloc(sizeof (struct heredoc));
+ heredoc->here = np;
+ if ((c = pgetc()) == '-') {
+ heredoc->striptabs = 1;
+ } else {
+ heredoc->striptabs = 0;
+ pungetc();
+ }
+ break;
+
+ case '&':
+ np->type = NFROMFD;
+ break;
+
+ case '>':
+ np->type = NFROMTO;
+ break;
+
+ default:
+ np->type = NFROM;
+ pungetc();
+ break;
+ }
+ }
+ if (fd != '\0')
+ np->nfile.fd = digit_val(fd);
+ redirnode = np;
+ goto parseredir_return;
+}
+
+
+/*
+ * Parse a substitution. At this point, we have read the dollar sign
+ * and nothing else.
+ */
+
+parsesub: {
+ int subtype;
+ int typeloc;
+ int flags;
+ char *p;
+ static const char types[] = "}-+?=";
+
+ c = pgetc();
+ if (
+ c <= PEOA_OR_PEOF ||
+ (c != '(' && c != '{' && !is_name(c) && !is_special(c))
+ ) {
+ USTPUTC('$', out);
+ pungetc();
+ } else if (c == '(') { /* $(command) or $((arith)) */
+ if (pgetc() == '(') {
+#ifdef CONFIG_ASH_MATH_SUPPORT
+ PARSEARITH();
+#else
+ synerror("We unsupport $((arith))");
+#endif
+ } else {
+ pungetc();
+ PARSEBACKQNEW();
+ }
+ } else {
+ USTPUTC(CTLVAR, out);
+ typeloc = out - (char *)stackblock();
+ USTPUTC(VSNORMAL, out);
+ subtype = VSNORMAL;
+ if (c == '{') {
+ c = pgetc();
+ if (c == '#') {
+ if ((c = pgetc()) == '}')
+ c = '#';
+ else
+ subtype = VSLENGTH;
+ }
+ else
+ subtype = 0;
+ }
+ if (c > PEOA_OR_PEOF && is_name(c)) {
+ do {
+ STPUTC(c, out);
+ c = pgetc();
+ } while (c > PEOA_OR_PEOF && is_in_name(c));
+ } else if (is_digit(c)) {
+ do {
+ STPUTC(c, out);
+ c = pgetc();
+ } while (is_digit(c));
+ }
+ else if (is_special(c)) {
+ USTPUTC(c, out);
+ c = pgetc();
+ }
+ else
+badsub: synerror("Bad substitution");
+
+ STPUTC('=', out);
+ flags = 0;
+ if (subtype == 0) {
+ switch (c) {
+ case ':':
+ flags = VSNUL;
+ c = pgetc();
+ /*FALLTHROUGH*/
+ default:
+ p = strchr(types, c);
+ if (p == NULL)
+ goto badsub;
+ subtype = p - types + VSNORMAL;
+ break;
+ case '%':
+ case '#':
+ {
+ int cc = c;
+ subtype = c == '#' ? VSTRIMLEFT :
+ VSTRIMRIGHT;
+ c = pgetc();
+ if (c == cc)
+ subtype++;
+ else
+ pungetc();
+ break;
+ }
+ }
+ } else {
+ pungetc();
+ }
+ if (dblquote || arinest)
+ flags |= VSQUOTE;
+ *((char *)stackblock() + typeloc) = subtype | flags;
+ if (subtype != VSNORMAL) {
+ varnest++;
+ if (dblquote || arinest) {
+ dqvarnest++;
+ }
+ }
+ }
+ 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;
+ union node *n;
+ char *volatile str;
+ struct jmploc jmploc;
+ struct jmploc *volatile savehandler;
+ size_t savelen;
+ int saveprompt;
+#ifdef __GNUC__
+ (void) &saveprompt;
+#endif
+
+ savepbq = parsebackquote;
+ if (setjmp(jmploc.loc)) {
+ if (str)
+ ckfree(str);
+ parsebackquote = 0;
+ handler = savehandler;
+ longjmp(handler->loc, 1);
+ }
+ INTOFF;
+ str = NULL;
+ savelen = out - (char *)stackblock();
+ if (savelen > 0) {
+ str = ckmalloc(savelen);
+ memcpy(str, stackblock(), savelen);
+ }
+ savehandler = handler;
+ handler = &jmploc;
+ INTON;
+ if (oldstyle) {
+ /* We must read until the closing backquote, giving special
+ treatment to some slashes, and then push the string and
+ reread it as input, interpreting it normally. */
+ char *pout;
+ int pc;
+ size_t psavelen;
+ char *pstr;
+
+
+ STARTSTACKSTR(pout);
+ for (;;) {
+ if (needprompt) {
+ setprompt(2);
+ needprompt = 0;
+ }
+ switch (pc = pgetc()) {
+ case '`':
+ goto done;
+
+ case '\\':
+ if ((pc = pgetc()) == '\n') {
+ plinno++;
+ if (doprompt)
+ setprompt(2);
+ /*
+ * If eating a newline, avoid putting
+ * the newline into the new character
+ * stream (via the STPUTC after the
+ * switch).
+ */
+ continue;
+ }
+ if (pc != '\\' && pc != '`' && pc != '$'
+ && (!dblquote || pc != '"'))
+ STPUTC('\\', pout);
+ if (pc > PEOA_OR_PEOF) {
+ break;
+ }
+ /* fall through */
+
+ case PEOF:
+#ifdef CONFIG_ASH_ALIAS
+ case PEOA:
+#endif
+ startlinno = plinno;
+ synerror("EOF in backquote substitution");
+
+ case '\n':
+ plinno++;
+ needprompt = doprompt;
+ break;
+
+ default:
+ break;
+ }
+ STPUTC(pc, pout);
+ }
+done:
+ STPUTC('\0', pout);
+ psavelen = pout - (char *)stackblock();
+ if (psavelen > 0) {
+ pstr = grabstackstr(pout);
+ setinputstring(pstr);
+ }
+ }
+ nlpp = &bqlist;
+ while (*nlpp)
+ nlpp = &(*nlpp)->next;
+ *nlpp = (struct nodelist *)stalloc(sizeof (struct nodelist));
+ (*nlpp)->next = NULL;
+ parsebackquote = oldstyle;
+
+ if (oldstyle) {
+ saveprompt = doprompt;
+ doprompt = 0;
+ }
+
+ n = list(2);
+
+ if (oldstyle)
+ doprompt = saveprompt;
+ else {
+ if (readtoken() != TRP)
+ synexpect(TRP);
+ }
+
+ (*nlpp)->n = n;
+ if (oldstyle) {
+ /*
+ * Start reading from old file again, ignoring any pushed back
+ * tokens left from the backquote parsing
+ */
+ popfile();
+ tokpushback = 0;
+ }
+ while (stackblocksize() <= savelen)
+ growstackblock();
+ STARTSTACKSTR(out);
+ if (str) {
+ memcpy(out, str, savelen);
+ STADJUST(savelen, out);
+ INTOFF;
+ ckfree(str);
+ str = NULL;
+ INTON;
+ }
+ parsebackquote = savepbq;
+ handler = savehandler;
+ if (arinest || dblquote)
+ USTPUTC(CTLBACKQ | CTLQUOTE, out);
+ else
+ USTPUTC(CTLBACKQ, out);
+ if (oldstyle)
+ goto parsebackq_oldreturn;
+ else
+ goto parsebackq_newreturn;
+}
+
+#ifdef CONFIG_ASH_MATH_SUPPORT
+/*
+ * Parse an arithmetic expansion (indicate start of one and set state)
+ */
+parsearith: {
+
+ if (++arinest == 1) {
+ prevsyntax = syntax;
+ syntax = ARISYNTAX;
+ USTPUTC(CTLARI, out);
+ if (dblquote)
+ USTPUTC('"',out);
+ else
+ USTPUTC(' ',out);
+ } else {
+ /*
+ * we collapse embedded arithmetic expansion to
+ * parenthesis, which should be equivalent
+ */
+ USTPUTC('(', out);
+ }
+ goto parsearith_return;
+}
+#endif
+
+} /* end of readtoken */
+
+
+
+/*
+ * Returns true if the text contains nothing to expand (no dollar signs
+ * or backquotes).
+ */
+
+static int
+noexpand(char *text)
+{
+ char *p;
+ char c;
+
+ p = text;
+ while ((c = *p++) != '\0') {
+ if (c == CTLQUOTEMARK)
+ continue;
+ if (c == CTLESC)
+ p++;
+ else if (SIT(c, BASESYNTAX) == CCTL)
+ return 0;
+ }
+ 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;
+ }
+ return 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.
+ */
+
+static void synexpect(int token)
+{
+ char msg[64];
+ int l;
+
+ l = sprintf(msg, "%s unexpected", tokname(lasttoken));
+ if (token >= 0)
+ sprintf(msg + l, " (expecting %s)", tokname(token));
+ synerror(msg);
+ /* NOTREACHED */
+}
+
+static void
+synerror(const char *msg)
+{
+ error("Syntax error: %s", msg);
+ /* NOTREACHED */
+}
+
+
+/*
+ * called by editline -- any expansions to the prompt
+ * should be added here.
+ */
+
+static void setprompt(int whichprompt)
+{
+ const char *prompt;
+
+ switch (whichprompt) {
+ case 1:
+ prompt = ps1val();
+ break;
+ case 2:
+ prompt = ps2val();
+ break;
+ default: /* 0 */
+ prompt = nullstr;
+ }
+ putprompt(prompt);
+}
+
+
+static const char *const *findkwd(const char *s)
+{
+ return bsearch(s, tokname_array + KWDOFFSET,
+ (sizeof(tokname_array) / sizeof(const char *)) - KWDOFFSET,
+ sizeof(const char *), pstrcmp);
+}
+
+/* $NetBSD: redir.c,v 1.27 2002/11/24 22:35:42 christos Exp $ */
+
+/*
+ * Code for dealing with input/output redirection.
+ */
+
+#define EMPTY -2 /* marks an unused slot in redirtab */
+#ifndef PIPE_BUF
+# define PIPESIZE 4096 /* amount of buffering in a pipe */
+#else
+# define PIPESIZE PIPE_BUF
+#endif
+
+/*
+ * Open a file in noclobber mode.
+ * The code was copied from bash.
+ */
+static inline int
+noclobberopen(const char *fname)
+{
+ int r, fd;
+ struct stat finfo, finfo2;
+
+ /*
+ * If the file exists and is a regular file, return an error
+ * immediately.
+ */
+ r = stat(fname, &finfo);
+ if (r == 0 && S_ISREG(finfo.st_mode)) {
+ errno = EEXIST;
+ return -1;
+ }
+
+ /*
+ * If the file was not present (r != 0), make sure we open it
+ * exclusively so that if it is created before we open it, our open
+ * will fail. Make sure that we do not truncate an existing file.
+ * Note that we don't turn on O_EXCL unless the stat failed -- if the
+ * file was not a regular file, we leave O_EXCL off.
+ */
+ if (r != 0)
+ return open(fname, O_WRONLY|O_CREAT|O_EXCL, 0666);
+ fd = open(fname, O_WRONLY|O_CREAT, 0666);
+
+ /* If the open failed, return the file descriptor right away. */
+ if (fd < 0)
+ return fd;
+
+ /*
+ * OK, the open succeeded, but the file may have been changed from a
+ * non-regular file to a regular file between the stat and the open.
+ * We are assuming that the O_EXCL open handles the case where FILENAME
+ * did not exist and is symlinked to an existing file between the stat
+ * and open.
+ */
+
+ /*
+ * If we can open it and fstat the file descriptor, and neither check
+ * revealed that it was a regular file, and the file has not been
+ * replaced, return the file descriptor.
+ */
+ if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode) &&
+ finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino)
+ return fd;
+
+ /* The file has been replaced. badness. */
+ close(fd);
+ errno = EEXIST;
+ return -1;
+}
+
+/*
+ * 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 (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);
+ 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);
+#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];
+}
+
+static int
+openredirect(union node *redir)
+{
+ 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;
+ }
+
+ return f;
+ecreate:
+ error("cannot create %s: %s", fname, errmsg(errno, E_CREAT));
+eopen:
+ error("cannot open %s: %s", fname, errmsg(errno, E_OPEN));
+}
+
+static inline void
+dupredirect(union node *redir, int f)
+{
+ int fd = redir->nfile.fd;
+
+ if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) {
+ if (redir->ndup.dupfd >= 0) { /* if not ">&-" */
+ copyfd(redir->ndup.dupfd, fd);
+ }
+ return;
+ }
+
+ if (f != fd) {
+ copyfd(f, fd);
+ close(f);
+ }
+ return;
+}
+
+/*
+ * Process a list of redirection commands. If the REDIR_PUSH flag is set,
+ * old file descriptors are stashed away so that the redirection can be
+ * undone by calling popredir. If the REDIR_BACKQ flag is set, then the
+ * standard output, and the standard error if it becomes a duplicate of
+ * stdout, is saved in memory.
+ */
+
+static void
+redirect(union node *redir, int flags)
+{
+ 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);
+
+ 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);
+ }
+ dupredirect(n, newfd);
+ } while ((n = n->nfile.next));
+ INTON;
+}
+
+
+/*
+ * Undo the effects of the last redirection.
+ */
+
+void
+popredir(int drop)
+{
+ 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;
+}
+
+/*
+ * Undo all redirections. Called on error or interrupt.
+ */
+
+/*
+ * Discard all saved file descriptors.
+ */
+
+void
+clearredir(int drop)
+{
+ for (;;) {
+ nullredirs = 0;
+ if (!redirlist)
+ break;
+ popredir(drop);
+ }
+}
+
+
+/*
+ * Copy a file descriptor to be >= to. Returns -1
+ * if the source file descriptor is closed, EMPTY if there are no unused
+ * file descriptors left.
+ */
+
+int
+copyfd(int from, int to)
+{
+ int newfd;
+
+ newfd = fcntl(from, F_DUPFD, to);
+ if (newfd < 0) {
+ if (errno == EMFILE)
+ return EMPTY;
+ else
+ error("%d: %m", from);
+ }
+ return newfd;
+}
+
+
+int
+redirectsafe(union node *redir, int flags)
+{
+ int err;
+ volatile int saveint;
+ struct jmploc *volatile savehandler = handler;
+ struct jmploc jmploc;
+
+ SAVEINT(saveint);
+ if (!(err = setjmp(jmploc.loc) * 2)) {
+ handler = &jmploc;
+ redirect(redir, flags);
+ }
+ handler = savehandler;
+ if (err && exception != EXERROR)
+ longjmp(handler->loc, 1);
+ RESTOREINT(saveint);
+ return err;
+}
+
+/* $NetBSD: show.c,v 1.24 2003/01/22 20:36:04 dsl Exp $ */
+
+#ifdef DEBUG
+static void shtree(union node *, int, char *, FILE*);
+static void shcmd(union node *, FILE *);
+static void sharg(union node *, FILE *);
+static void indent(int, char *, FILE *);
+static void trstring(char *);
+
+
+void
+showtree(union node *n)
+{
+ trputs("showtree called\n");
+ shtree(n, 1, NULL, stdout);
+}
+
+
+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.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
+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;
+ }
+}
+
+
+
+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
+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);
+ }
+}
+
+
+
+/*
+ * Debugging stuff.
+ */
+
+
+FILE *tracefile;
+
+
+void
+trputc(int c)
+{
+ if (debug != 1)
+ return;
+ putc(c, tracefile);
+}
+
+void
+trace(const char *fmt, ...)
+{
+ va_list va;
+
+ if (debug != 1)
+ return;
+ va_start(va, fmt);
+ (void) vfprintf(tracefile, fmt, va);
+ va_end(va);
+}
+
+void
+tracev(const char *fmt, va_list va)
+{
+ if (debug != 1)
+ return;
+ (void) vfprintf(tracefile, fmt, va);
+}
+
+
+void
+trputs(const char *s)
+{
+ if (debug != 1)
+ return;
+ fputs(s, tracefile);
+}
+
+
+static void
+trstring(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);
+}
+
+
+void
+trargs(char **ap)
+{
+ if (debug != 1)
+ return;
+ while (*ap) {
+ trstring(*ap++);
+ if (*ap)
+ putc(' ', tracefile);
+ else
+ putc('\n', tracefile);
+ }
+}
+
+
+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;
+ }
+ scopy("./trace", s);
+ if (tracefile) {
+ if (!freopen(s, "a", tracefile)) {
+ fprintf(stderr, "Can't re-open %s\n", s);
+ debug = 0;
+ return;
+ }
+ } else {
+ if ((tracefile = fopen(s, "a")) == NULL) {
+ fprintf(stderr, "Can't open %s\n", s);
+ debug = 0;
+ return;
+ }
+ }
+#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 */
+
+
+/* $NetBSD: trap.c,v 1.28 2002/11/24 22:35:43 christos Exp $ */
+
+/*
+ * Sigmode records the current value of the signal handlers for the various
+ * modes. A value of zero means that the current handler is not known.
+ * S_HARD_IGN indicates that the signal was ignored on entry to the shell,
+ */
+
+#define S_DFL 1 /* default signal handling (SIG_DFL) */
+#define S_CATCH 2 /* signal is caught */
+#define S_IGN 3 /* signal is ignored (SIG_IGN) */
+#define S_HARD_IGN 4 /* signal is ignored permenantly */
+#define S_RESET 5 /* temporary - to reset a hard ignored sig */
+
+
+
+/*
+ * The trap builtin.
+ */
+
+int
+trapcmd(int argc, char **argv)
+{
+ char *action;
+ char **ap;
+ int signo;
+
+ nextopt(nullstr);
+ ap = argptr;
+ if (!*ap) {
+ 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);
+ }
+ }
+ return 0;
+ }
+ if (!ap[1])
+ action = NULL;
+ else
+ action = *ap++;
+ while (*ap) {
+ if ((signo = decode_signal(*ap, 0)) < 0)
+ error("%s: bad trap", *ap);
+ INTOFF;
+ if (action) {
+ if (action[0] == '-' && action[1] == '\0')
+ action = NULL;
+ else
+ action = savestr(action);
+ }
+ if (trap[signo])
+ ckfree(trap[signo]);
+ trap[signo] = action;
+ if (signo != 0)
+ setsignal(signo);
+ INTON;
+ 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;
+ }
+ }
+}
+
+
+/*
+ * Set the signal handler for the specified signal. The routine figures
+ * out what it should be set to.
+ */
+
+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)
+{
+ int col, i;
+
+ out1fmt("\nBuilt-in commands:\n-------------------\n");
+ for (col = 0, i = 0; i < NUMBUILTINS; i++) {
+ col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '),
+ builtincmd[i].name + 1);
+ if (col > 60) {
+ out1fmt("\n");
+ col = 0;
+ }
+ }
+#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
+ {
+ extern const struct BB_applet applets[];
+ extern const size_t NUM_APPLETS;
+
+ for (i = 0; i < NUM_APPLETS; i++) {
+
+ col += out1fmt("%c%s", ((col == 0) ? '\t' : ' '), applets[i].name);
+ if (col > 60) {
+ out1fmt("\n");
+ col = 0;
+ }
+ }
+ }
+#endif
+ out1fmt("\n\n");
+ return EXIT_SUCCESS;
+}
+#endif /* CONFIG_FEATURE_SH_EXTRA_QUIET */
+
+/*
+ * Called to exit the shell.
+ */
+
+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;
+}
+
+
+
+/*
+ * The export and readonly commands.
+ */
+
+static int
+exportcmd(int argc, char **argv)
+{
+ struct var *vp;
+ char *name;
+ const char *p;
+ char **aptr;
+ int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT;
+ int notp;
+
+ 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;
+ }
+ }
+ 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);
+ }
+ }
+ 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);
+ }
+ return 0;
+}
+
+
+
+/*
+ * Called after a function returns.
+ * Interrupts must be off.
+ */
+
+static void
+poplocalvars(void)
+{
+ struct localvar *lvp;
+ struct var *vp;
+
+ 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);
+ }
+}
+
+
+/*
+ * 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)
+{
+ char **ap;
+ int i;
+ int flag = 0;
+ int ret = 0;
+
+ while ((i = nextopt("vf")) != '\0') {
+ flag = i;
+ }
+
+ for (ap = argptr; *ap ; ap++) {
+ if (flag != 'f') {
+ i = unsetvar(*ap);
+ ret |= i;
+ if (!(i & 2))
+ continue;
+ }
+ if (flag != 'v')
+ unsetfunc(*ap);
+ }
+ return ret & 1;
+}
+
+
+/*
+ * Unset the specified variable.
+ */
+
+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;
+
+ 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
+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)
+{
+ 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) {
+ struct tms buf;
+ long int 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;
+
+ return (result);
+}
+
+
+/*
+ * The exp(1) builtin.
+ */
+static int
+expcmd(int argc, char **argv)
+{
+ const char *p;
+ char *concat;
+ char **ap;
+ long i;
+
+ if (argc > 1) {
+ p = argv[1];
+ if (argc > 2) {
+ /*
+ * concatenate arguments
+ */
+ STARTSTACKSTR(concat);
+ ap = argv + 2;
+ for (;;) {
+ while (*p)
+ STPUTC(*p++, concat);
+ if ((p = *ap++) == NULL)
+ break;
+ STPUTC(' ', concat);
+ }
+ STPUTC('\0', concat);
+ p = grabstackstr(concat);
+ }
+ } else
+ p = nullstr;
+
+ i = dash_arith(p);
+
+ out1fmt("%ld\n", i);
+ return (! i);
+}
+#endif /* CONFIG_ASH_MATH_SUPPORT */
+
+/* $NetBSD: miscbltin.c,v 1.31 2002/11/24 22:35:41 christos Exp $ */
+
+/*
+ * Miscelaneous builtins.
+ */
+
+#undef rflag
+
+#ifdef __GLIBC__
+#if !defined(__GLIBC__) || __GLIBC__ == 2 && __GLIBC_MINOR__ < 1
+typedef enum __rlimit_resource rlim_t;
+#endif
+#endif
+
+
+/*
+ * The read builtin. The -e option causes backslashes to escape the
+ * following character.
+ *
+ * This uses unbuffered input, which may be avoidable in some cases.
+ */
+
+static int
+readcmd(int argc, char **argv)
+{
+ char **ap;
+ int backslash;
+ char c;
+ int rflag;
+ char *prompt;
+ const char *ifs;
+ char *p;
+ int startword;
+ int status;
+ int i;
+
+ rflag = 0;
+ prompt = NULL;
+ while ((i = nextopt("p:r")) != '\0') {
+ if (i == 'p')
+ prompt = optionarg;
+ else
+ rflag = 1;
+ }
+ if (prompt && isatty(0)) {
+ out2str(prompt);
+ flushall();
+ }
+ if (*(ap = argptr) == NULL)
+ error("arg count");
+ if ((ifs = bltinlookup("IFS")) == NULL)
+ ifs = defifs;
+ status = 0;
+ startword = 1;
+ backslash = 0;
+ STARTSTACKSTR(p);
+ for (;;) {
+ if (read(0, &c, 1) != 1) {
+ status = 1;
+ break;
+ }
+ if (c == '\0')
+ continue;
+ if (backslash) {
+ backslash = 0;
+ if (c != '\n')
+ goto put;
+ continue;
+ }
+ if (!rflag && c == '\\') {
+ backslash++;
+ continue;
+ }
+ if (c == '\n')
+ break;
+ if (startword && *ifs == ' ' && strchr(ifs, c)) {
+ continue;
+ }
+ startword = 0;
+ if (ap[1] != NULL && strchr(ifs, c) != NULL) {
+ STACKSTRNUL(p);
+ setvar(*ap, stackblock(), 0);
+ ap++;
+ startword = 1;
+ STARTSTACKSTR(p);
+ } else {
+put:
+ STPUTC(c, p);
+ }
+ }
+ STACKSTRNUL(p);
+ /* Remove trailing blanks */
+ while ((char *)stackblock() <= --p && strchr(ifs, *p) != NULL)
+ *p = '\0';
+ setvar(*ap, stackblock(), 0);
+ while (*++ap != NULL)
+ setvar(*ap, nullstr, 0);
+ return status;
+}
+
+
+static int umaskcmd(int argc, char **argv)
+{
+ static const char permuser[3] = "ugo";
+ static const char permmode[3] = "rwx";
+ static const short int permmask[] = {
+ S_IRUSR, S_IWUSR, S_IXUSR,
+ S_IRGRP, S_IWGRP, S_IXGRP,
+ S_IROTH, S_IWOTH, S_IXOTH
+ };
+
+ char *ap;
+ mode_t mask;
+ int i;
+ int symbolic_mode = 0;
+
+ while (nextopt("S") != '\0') {
+ symbolic_mode = 1;
+ }
+
+ INTOFF;
+ mask = umask(0);
+ umask(mask);
+ INTON;
+
+ if ((ap = *argptr) == NULL) {
+ if (symbolic_mode) {
+ char buf[18];
+ char *p = buf;
+
+ for (i = 0; i < 3; i++) {
+ int j;
+
+ *p++ = permuser[i];
+ *p++ = '=';
+ for (j = 0; j < 3; j++) {
+ if ((mask & permmask[3 * i + j]) == 0) {
+ *p++ = permmode[j];
+ }
+ }
+ *p++ = ',';
+ }
+ *--p = 0;
+ puts(buf);
+ } else {
+ out1fmt("%.4o\n", mask);
+ }
+ } else {
+ if (is_digit((unsigned char) *ap)) {
+ mask = 0;
+ do {
+ if (*ap >= '8' || *ap < '0')
+ error(illnum, argv[1]);
+ mask = (mask << 3) + (*ap - '0');
+ } while (*++ap != '\0');
+ umask(mask);
+ } else {
+ mask = ~mask & 0777;
+ if (!bb_parse_mode(ap, &mask)) {
+ error("Illegal mode: %s", ap);
+ }
+ umask(~mask & 0777);
+ }
+ }
+ return 0;
+}
+
+/*
+ * ulimit builtin
+ *
+ * This code, originally by Doug Gwyn, Doug Kingston, Eric Gisin, and
+ * Michael Rendell was ripped from pdksh 5.0.8 and hacked for use with
+ * ash by J.T. Conklin.
+ *
+ * Public domain.
+ */
+
+struct limits {
+ const char *name;
+ int cmd;
+ int factor; /* multiply by to get rlim_{cur,max} values */
+ char option;
+};
+
+static const struct limits limits[] = {
+#ifdef RLIMIT_CPU
+ { "time(seconds)", RLIMIT_CPU, 1, 't' },
+#endif
+#ifdef RLIMIT_FSIZE
+ { "file(blocks)", RLIMIT_FSIZE, 512, 'f' },
+#endif
+#ifdef RLIMIT_DATA
+ { "data(kbytes)", RLIMIT_DATA, 1024, 'd' },
+#endif
+#ifdef RLIMIT_STACK
+ { "stack(kbytes)", RLIMIT_STACK, 1024, 's' },
+#endif
+#ifdef RLIMIT_CORE
+ { "coredump(blocks)", RLIMIT_CORE, 512, 'c' },
+#endif
+#ifdef RLIMIT_RSS
+ { "memory(kbytes)", RLIMIT_RSS, 1024, 'm' },
+#endif
+#ifdef RLIMIT_MEMLOCK
+ { "locked memory(kbytes)", RLIMIT_MEMLOCK, 1024, 'l' },
+#endif
+#ifdef RLIMIT_NPROC
+ { "process(processes)", RLIMIT_NPROC, 1, 'p' },
+#endif
+#ifdef RLIMIT_NOFILE
+ { "nofiles(descriptors)", RLIMIT_NOFILE, 1, 'n' },
+#endif
+#ifdef RLIMIT_VMEM
+ { "vmemory(kbytes)", RLIMIT_VMEM, 1024, 'v' },
+#endif
+#ifdef RLIMIT_SWAP
+ { "swap(kbytes)", RLIMIT_SWAP, 1024, 'w' },
+#endif
+ { (char *) 0, 0, 0, '\0' }
+};
+
+int
+ulimitcmd(int argc, char **argv)
+{
+ int c;
+ rlim_t val = 0;
+ enum { SOFT = 0x1, HARD = 0x2 }
+ how = SOFT | HARD;
+ const struct limits *l;
+ int set, all = 0;
+ int optc, what;
+ struct rlimit limit;
+
+ what = 'f';
+ while ((optc = nextopt("HSatfdsmcnpl")) != '\0')
+ switch (optc) {
+ case 'H':
+ how = HARD;
+ break;
+ case 'S':
+ how = SOFT;
+ break;
+ case 'a':
+ all = 1;
+ break;
+ default:
+ what = optc;
+ }
+
+ for (l = limits; l->name && l->option != what; l++)
+ ;
+ if (!l->name)
+ error("internal error (%c)", what);
+
+ set = *argptr ? 1 : 0;
+ if (set) {
+ char *p = *argptr;
+
+ if (all || argptr[1])
+ error("too many arguments");
+ if (strncmp(p, "unlimited\n", 9) == 0)
+ val = RLIM_INFINITY;
+ else {
+ val = (rlim_t) 0;
+
+ while ((c = *p++) >= '0' && c <= '9')
+ {
+ val = (val * 10) + (long)(c - '0');
+ if (val < (rlim_t) 0)
+ break;
+ }
+ if (c)
+ error("bad number");
+ val *= l->factor;
+ }
+ }
+ if (all) {
+ for (l = limits; l->name; l++) {
+ getrlimit(l->cmd, &limit);
+ if (how & SOFT)
+ val = limit.rlim_cur;
+ else if (how & HARD)
+ val = limit.rlim_max;
+
+ out1fmt("%-20s ", l->name);
+ if (val == RLIM_INFINITY)
+ out1fmt("unlimited\n");
+ else
+ {
+ val /= l->factor;
+ out1fmt("%lld\n", (long long) val);
+ }
+ }
+ return 0;
+ }
+
+ getrlimit(l->cmd, &limit);
+ if (set) {
+ if (how & HARD)
+ limit.rlim_max = val;
+ if (how & SOFT)
+ limit.rlim_cur = val;
+ if (setrlimit(l->cmd, &limit) < 0)
+ error("error setting limit (%m)");
+ } else {
+ if (how & SOFT)
+ val = limit.rlim_cur;
+ else if (how & HARD)
+ val = limit.rlim_max;
+
+ if (val == RLIM_INFINITY)
+ out1fmt("unlimited\n");
+ else
+ {
+ val /= l->factor;
+ out1fmt("%lld\n", (long long) val);
+ }
+ }
+ return 0;
+}
+
+#ifdef DEBUG
+const char *bb_applet_name = "debug stuff usage";
+int main(int argc, char **argv)
+{
+ return ash_main(argc, argv);
+}
+#endif
+
+/*-
+ * Copyright (c) 1989, 1991, 1993, 1994
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Kenneth Almquist.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * 3. <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
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
diff --git a/release/src/router/busybox/shell/cmdedit.c b/release/src/router/busybox/shell/cmdedit.c
new file mode 100644
index 00000000..0ab19580
--- /dev/null
+++ b/release/src/router/busybox/shell/cmdedit.c
@@ -0,0 +1,1577 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Termios command line History and Editting.
+ *
+ * Copyright (c) 1986-2003 may safely be consumed by a BSD or GPL license.
+ * Written by: Vladimir Oleynik <dzo@simtreas.ru>
+ *
+ * Used ideas:
+ * Adam Rogoyski <rogoyski@cs.utexas.edu>
+ * Dave Cinege <dcinege@psychosis.com>
+ * Jakub Jelinek (c) 1995
+ * Erik Andersen <andersen@codepoet.org> (Majorly adjusted for busybox)
+ *
+ * This code is 'as is' with no warranty.
+ *
+ *
+ */
+
+/*
+ Usage and Known bugs:
+ Terminal key codes are not extensive, and more will probably
+ need to be added. This version was created on Debian GNU/Linux 2.x.
+ Delete, Backspace, Home, End, and the arrow keys were tested
+ to work in an Xterm and console. Ctrl-A also works as Home.
+ Ctrl-E also works as End.
+
+ Small bugs (simple effect):
+ - not true viewing if terminal size (x*y symbols) less
+ size (prompt + editor`s line + 2 symbols)
+ - not true viewing if length prompt less terminal width
+ */
+
+
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <ctype.h>
+#include <signal.h>
+#include <limits.h>
+
+#include "busybox.h"
+
+#ifdef CONFIG_LOCALE_SUPPORT
+#define Isprint(c) isprint((c))
+#else
+#define Isprint(c) ( (c) >= ' ' && (c) != ((unsigned char)'\233') )
+#endif
+
+#ifndef TEST
+
+#define D(x)
+
+#else
+
+#define CONFIG_FEATURE_COMMAND_EDITING
+#define CONFIG_FEATURE_COMMAND_TAB_COMPLETION
+#define CONFIG_FEATURE_COMMAND_USERNAME_COMPLETION
+#define CONFIG_FEATURE_NONPRINTABLE_INVERSE_PUT
+#define CONFIG_FEATURE_CLEAN_UP
+
+#define D(x) x
+
+#endif /* TEST */
+
+#ifdef CONFIG_FEATURE_COMMAND_TAB_COMPLETION
+#include <dirent.h>
+#include <sys/stat.h>
+#endif
+
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+
+#ifndef CONFIG_FEATURE_COMMAND_TAB_COMPLETION
+#undef CONFIG_FEATURE_COMMAND_USERNAME_COMPLETION
+#endif
+
+#if defined(CONFIG_FEATURE_COMMAND_USERNAME_COMPLETION) || defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
+#define CONFIG_FEATURE_GETUSERNAME_AND_HOMEDIR
+#endif
+
+#ifdef CONFIG_FEATURE_GETUSERNAME_AND_HOMEDIR
+# ifndef TEST
+# include "pwd_.h"
+# else
+# include <pwd.h>
+# endif /* TEST */
+#endif /* advanced FEATURES */
+
+
+/* Maximum length of the linked list for the command line history */
+#ifndef CONFIG_FEATURE_COMMAND_HISTORY
+#define MAX_HISTORY 15
+#else
+#define MAX_HISTORY CONFIG_FEATURE_COMMAND_HISTORY
+#endif
+
+#if MAX_HISTORY < 1
+#warning cmdedit: You set MAX_HISTORY < 1. The history algorithm switched off.
+#else
+static char *history[MAX_HISTORY+1]; /* history + current */
+/* saved history lines */
+static int n_history;
+/* current pointer to history line */
+static int cur_history;
+#endif
+
+#include <termios.h>
+#define setTermSettings(fd,argp) tcsetattr(fd,TCSANOW,argp)
+#define getTermSettings(fd,argp) tcgetattr(fd, argp);
+
+/* Current termio and the previous termio before starting sh */
+static struct termios initial_settings, new_settings;
+
+
+static
+volatile int cmdedit_termw = 80; /* actual terminal width */
+static
+volatile int handlers_sets = 0; /* Set next bites: */
+
+enum {
+ SET_ATEXIT = 1, /* when atexit() has been called
+ and get euid,uid,gid to fast compare */
+ SET_WCHG_HANDLERS = 2, /* winchg signal handler */
+ SET_RESET_TERM = 4, /* if the terminal needs to be reset upon exit */
+};
+
+
+static int cmdedit_x; /* real x terminal position */
+static int cmdedit_y; /* pseudoreal y terminal position */
+static int cmdedit_prmt_len; /* lenght prompt without colores string */
+
+static int cursor; /* required global for signal handler */
+static int len; /* --- "" - - "" - -"- --""-- --""--- */
+static char *command_ps; /* --- "" - - "" - -"- --""-- --""--- */
+static
+#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
+ const
+#endif
+char *cmdedit_prompt; /* --- "" - - "" - -"- --""-- --""--- */
+
+#ifdef CONFIG_FEATURE_GETUSERNAME_AND_HOMEDIR
+static char *user_buf = "";
+static char *home_pwd_buf = "";
+static int my_euid;
+#endif
+
+#ifdef CONFIG_FEATURE_SH_FANCY_PROMPT
+static char *hostname_buf;
+static int num_ok_lines = 1;
+#endif
+
+
+#ifdef CONFIG_FEATURE_COMMAND_TAB_COMPLETION
+
+#ifndef CONFIG_FEATURE_GETUSERNAME_AND_HOMEDIR
+static int my_euid;
+#endif
+
+static int my_uid;
+static int my_gid;
+
+#endif /* CONFIG_FEATURE_COMMAND_TAB_COMPLETION */
+
+static void cmdedit_setwidth(int w, int redraw_flg);
+
+static void win_changed(int nsig)
+{
+ struct winsize win = { 0, 0, 0, 0 };
+ static sighandler_t previous_SIGWINCH_handler; /* for reset */
+
+ /* emulate || signal call */
+ if (nsig == -SIGWINCH || nsig == SIGWINCH) {
+ ioctl(0, TIOCGWINSZ, &win);
+ if (win.ws_col > 0) {
+ cmdedit_setwidth(win.ws_col, nsig == SIGWINCH);
+ }
+ }
+ /* Unix not all standart in recall signal */
+
+ if (nsig == -SIGWINCH) /* save previous handler */
+ previous_SIGWINCH_handler = signal(SIGWINCH, win_changed);
+ else if (nsig == SIGWINCH) /* signaled called handler */
+ signal(SIGWINCH, win_changed); /* set for next call */
+ else /* nsig == 0 */
+ /* set previous handler */
+ signal(SIGWINCH, previous_SIGWINCH_handler); /* reset */
+}
+
+static void cmdedit_reset_term(void)
+{
+ if ((handlers_sets & SET_RESET_TERM) != 0) {
+/* sparc and other have broken termios support: use old termio handling. */
+ setTermSettings(fileno(stdin), (void *) &initial_settings);
+ handlers_sets &= ~SET_RESET_TERM;
+ }
+ if ((handlers_sets & SET_WCHG_HANDLERS) != 0) {
+ /* reset SIGWINCH handler to previous (default) */
+ win_changed(0);
+ handlers_sets &= ~SET_WCHG_HANDLERS;
+ }
+ fflush(stdout);
+}
+
+
+/* special for recount position for scroll and remove terminal margin effect */
+static void cmdedit_set_out_char(int next_char)
+{
+
+ int c = (int)((unsigned char) command_ps[cursor]);
+
+ if (c == 0)
+ c = ' '; /* destroy end char? */
+#ifdef CONFIG_FEATURE_NONPRINTABLE_INVERSE_PUT
+ if (!Isprint(c)) { /* Inverse put non-printable characters */
+ if (c >= 128)
+ c -= 128;
+ if (c < ' ')
+ c += '@';
+ if (c == 127)
+ c = '?';
+ printf("\033[7m%c\033[0m", c);
+ } else
+#endif
+ putchar(c);
+ if (++cmdedit_x >= cmdedit_termw) {
+ /* terminal is scrolled down */
+ cmdedit_y++;
+ cmdedit_x = 0;
+
+ if (!next_char)
+ next_char = ' ';
+ /* destroy "(auto)margin" */
+ putchar(next_char);
+ putchar('\b');
+ }
+ cursor++;
+}
+
+/* Move to end line. Bonus: rewrite line from cursor */
+static void input_end(void)
+{
+ while (cursor < len)
+ cmdedit_set_out_char(0);
+}
+
+/* Go to the next line */
+static void goto_new_line(void)
+{
+ input_end();
+ if (cmdedit_x)
+ putchar('\n');
+}
+
+
+static inline void out1str(const char *s)
+{
+ if ( s )
+ fputs(s, stdout);
+}
+
+static inline void beep(void)
+{
+ putchar('\007');
+}
+
+/* Move back one charactor */
+/* special for slow terminal */
+static void input_backward(int num)
+{
+ if (num > cursor)
+ num = cursor;
+ cursor -= num; /* new cursor (in command, not terminal) */
+
+ if (cmdedit_x >= num) { /* no to up line */
+ cmdedit_x -= num;
+ if (num < 4)
+ while (num-- > 0)
+ putchar('\b');
+
+ else
+ printf("\033[%dD", num);
+ } else {
+ int count_y;
+
+ if (cmdedit_x) {
+ putchar('\r'); /* back to first terminal pos. */
+ num -= cmdedit_x; /* set previous backward */
+ }
+ count_y = 1 + num / cmdedit_termw;
+ printf("\033[%dA", count_y);
+ cmdedit_y -= count_y;
+ /* require forward after uping */
+ cmdedit_x = cmdedit_termw * count_y - num;
+ printf("\033[%dC", cmdedit_x); /* set term cursor */
+ }
+}
+
+static void put_prompt(void)
+{
+ out1str(cmdedit_prompt);
+ cmdedit_x = cmdedit_prmt_len; /* count real x terminal position */
+ cursor = 0;
+ cmdedit_y = 0; /* new quasireal y */
+}
+
+#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
+static void parse_prompt(const char *prmt_ptr)
+{
+ cmdedit_prompt = prmt_ptr;
+ cmdedit_prmt_len = strlen(prmt_ptr);
+ put_prompt();
+}
+#else
+static void parse_prompt(const char *prmt_ptr)
+{
+ int prmt_len = 0;
+ int sub_len = 0;
+ char flg_not_length = '[';
+ char *prmt_mem_ptr = xcalloc(1, 1);
+ char *pwd_buf = xgetcwd(0);
+ char buf2[PATH_MAX + 1];
+ char buf[2];
+ char c;
+ char *pbuf;
+
+ if (!pwd_buf) {
+ pwd_buf=(char *)bb_msg_unknown;
+ }
+
+ while (*prmt_ptr) {
+ pbuf = buf;
+ pbuf[1] = 0;
+ c = *prmt_ptr++;
+ if (c == '\\') {
+ const char *cp = prmt_ptr;
+ int l;
+
+ c = bb_process_escape_sequence(&prmt_ptr);
+ if(prmt_ptr==cp) {
+ if (*cp == 0)
+ break;
+ c = *prmt_ptr++;
+ switch (c) {
+#ifdef CONFIG_FEATURE_GETUSERNAME_AND_HOMEDIR
+ case 'u':
+ pbuf = user_buf;
+ break;
+#endif
+ case 'h':
+ pbuf = hostname_buf;
+ if (pbuf == 0) {
+ pbuf = xcalloc(256, 1);
+ if (gethostname(pbuf, 255) < 0) {
+ strcpy(pbuf, "?");
+ } else {
+ char *s = strchr(pbuf, '.');
+
+ if (s)
+ *s = 0;
+ }
+ hostname_buf = pbuf;
+ }
+ break;
+ case '$':
+ c = my_euid == 0 ? '#' : '$';
+ break;
+#ifdef CONFIG_FEATURE_GETUSERNAME_AND_HOMEDIR
+ case 'w':
+ pbuf = pwd_buf;
+ l = strlen(home_pwd_buf);
+ if (home_pwd_buf[0] != 0 &&
+ strncmp(home_pwd_buf, pbuf, l) == 0 &&
+ (pbuf[l]=='/' || pbuf[l]=='\0') &&
+ strlen(pwd_buf+l)<PATH_MAX) {
+ pbuf = buf2;
+ *pbuf = '~';
+ strcpy(pbuf+1, pwd_buf+l);
+ }
+ break;
+#endif
+ case 'W':
+ pbuf = pwd_buf;
+ cp = strrchr(pbuf,'/');
+ if ( (cp != NULL) && (cp != pbuf) )
+ pbuf += (cp-pbuf)+1;
+ break;
+ case '!':
+ snprintf(pbuf = buf2, sizeof(buf2), "%d", num_ok_lines);
+ break;
+ case 'e': case 'E': /* \e \E = \033 */
+ c = '\033';
+ break;
+ case 'x': case 'X':
+ for (l = 0; l < 3;) {
+ int h;
+ buf2[l++] = *prmt_ptr;
+ buf2[l] = 0;
+ h = strtol(buf2, &pbuf, 16);
+ if (h > UCHAR_MAX || (pbuf - buf2) < l) {
+ l--;
+ break;
+ }
+ prmt_ptr++;
+ }
+ buf2[l] = 0;
+ c = (char)strtol(buf2, 0, 16);
+ if(c==0)
+ c = '?';
+ pbuf = buf;
+ break;
+ case '[': case ']':
+ if (c == flg_not_length) {
+ flg_not_length = flg_not_length == '[' ? ']' : '[';
+ continue;
+ }
+ break;
+ }
+ }
+ }
+ if(pbuf == buf)
+ *pbuf = c;
+ prmt_len += strlen(pbuf);
+ prmt_mem_ptr = strcat(xrealloc(prmt_mem_ptr, prmt_len+1), pbuf);
+ if (flg_not_length == ']')
+ sub_len++;
+ }
+ if(pwd_buf!=(char *)bb_msg_unknown)
+ free(pwd_buf);
+ cmdedit_prompt = prmt_mem_ptr;
+ cmdedit_prmt_len = prmt_len - sub_len;
+ put_prompt();
+}
+#endif
+
+
+/* draw promt, editor line, and clear tail */
+static void redraw(int y, int back_cursor)
+{
+ if (y > 0) /* up to start y */
+ printf("\033[%dA", y);
+ putchar('\r');
+ put_prompt();
+ input_end(); /* rewrite */
+ printf("\033[J"); /* destroy tail after cursor */
+ input_backward(back_cursor);
+}
+
+/* Delete the char in front of the cursor */
+static void input_delete(void)
+{
+ int j = cursor;
+
+ if (j == len)
+ return;
+
+ strcpy(command_ps + j, command_ps + j + 1);
+ len--;
+ input_end(); /* rewtite new line */
+ cmdedit_set_out_char(0); /* destroy end char */
+ input_backward(cursor - j); /* back to old pos cursor */
+}
+
+/* Delete the char in back of the cursor */
+static void input_backspace(void)
+{
+ if (cursor > 0) {
+ input_backward(1);
+ input_delete();
+ }
+}
+
+
+/* Move forward one charactor */
+static void input_forward(void)
+{
+ if (cursor < len)
+ cmdedit_set_out_char(command_ps[cursor + 1]);
+}
+
+
+static void cmdedit_setwidth(int w, int redraw_flg)
+{
+ cmdedit_termw = cmdedit_prmt_len + 2;
+ if (w <= cmdedit_termw) {
+ cmdedit_termw = cmdedit_termw % w;
+ }
+ if (w > cmdedit_termw) {
+ cmdedit_termw = w;
+
+ if (redraw_flg) {
+ /* new y for current cursor */
+ int new_y = (cursor + cmdedit_prmt_len) / w;
+
+ /* redraw */
+ redraw((new_y >= cmdedit_y ? new_y : cmdedit_y), len - cursor);
+ fflush(stdout);
+ }
+ }
+}
+
+static void cmdedit_init(void)
+{
+ cmdedit_prmt_len = 0;
+ if ((handlers_sets & SET_WCHG_HANDLERS) == 0) {
+ /* emulate usage handler to set handler and call yours work */
+ win_changed(-SIGWINCH);
+ handlers_sets |= SET_WCHG_HANDLERS;
+ }
+
+ if ((handlers_sets & SET_ATEXIT) == 0) {
+#ifdef CONFIG_FEATURE_GETUSERNAME_AND_HOMEDIR
+ struct passwd *entry;
+
+ my_euid = geteuid();
+ entry = getpwuid(my_euid);
+ if (entry) {
+ user_buf = bb_xstrdup(entry->pw_name);
+ home_pwd_buf = bb_xstrdup(entry->pw_dir);
+ }
+#endif
+
+#ifdef CONFIG_FEATURE_COMMAND_TAB_COMPLETION
+
+#ifndef CONFIG_FEATURE_GETUSERNAME_AND_HOMEDIR
+ my_euid = geteuid();
+#endif
+ my_uid = getuid();
+ my_gid = getgid();
+#endif /* CONFIG_FEATURE_COMMAND_TAB_COMPLETION */
+ handlers_sets |= SET_ATEXIT;
+ atexit(cmdedit_reset_term); /* be sure to do this only once */
+ }
+}
+
+#ifdef CONFIG_FEATURE_COMMAND_TAB_COMPLETION
+
+static int is_execute(const struct stat *st)
+{
+ if ((!my_euid && (st->st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) ||
+ (my_uid == st->st_uid && (st->st_mode & S_IXUSR)) ||
+ (my_gid == st->st_gid && (st->st_mode & S_IXGRP)) ||
+ (st->st_mode & S_IXOTH)) return TRUE;
+ return FALSE;
+}
+
+#ifdef CONFIG_FEATURE_COMMAND_USERNAME_COMPLETION
+
+static char **username_tab_completion(char *ud, int *num_matches)
+{
+ struct passwd *entry;
+ int userlen;
+ char *temp;
+
+
+ ud++; /* ~user/... to user/... */
+ userlen = strlen(ud);
+
+ if (num_matches == 0) { /* "~/..." or "~user/..." */
+ char *sav_ud = ud - 1;
+ char *home = 0;
+
+ if (*ud == '/') { /* "~/..." */
+ home = home_pwd_buf;
+ } else {
+ /* "~user/..." */
+ temp = strchr(ud, '/');
+ *temp = 0; /* ~user\0 */
+ entry = getpwnam(ud);
+ *temp = '/'; /* restore ~user/... */
+ ud = temp;
+ if (entry)
+ home = entry->pw_dir;
+ }
+ if (home) {
+ if ((userlen + strlen(home) + 1) < BUFSIZ) {
+ char temp2[BUFSIZ]; /* argument size */
+
+ /* /home/user/... */
+ sprintf(temp2, "%s%s", home, ud);
+ strcpy(sav_ud, temp2);
+ }
+ }
+ return 0; /* void, result save to argument :-) */
+ } else {
+ /* "~[^/]*" */
+ char **matches = (char **) NULL;
+ int nm = 0;
+
+ setpwent();
+
+ while ((entry = getpwent()) != NULL) {
+ /* Null usernames should result in all users as possible completions. */
+ if ( /*!userlen || */ !strncmp(ud, entry->pw_name, userlen)) {
+
+ bb_xasprintf(&temp, "~%s/", entry->pw_name);
+ matches = xrealloc(matches, (nm + 1) * sizeof(char *));
+
+ matches[nm++] = temp;
+ }
+ }
+
+ endpwent();
+ (*num_matches) = nm;
+ return (matches);
+ }
+}
+#endif /* CONFIG_FEATURE_COMMAND_USERNAME_COMPLETION */
+
+enum {
+ FIND_EXE_ONLY = 0,
+ FIND_DIR_ONLY = 1,
+ FIND_FILE_ONLY = 2,
+};
+
+static int path_parse(char ***p, int flags)
+{
+ int npth;
+ char *tmp;
+ char *pth;
+
+ /* if not setenv PATH variable, to search cur dir "." */
+ if (flags != FIND_EXE_ONLY || (pth = getenv("PATH")) == 0 ||
+ /* PATH=<empty> or PATH=:<empty> */
+ *pth == 0 || (*pth == ':' && *(pth + 1) == 0)) {
+ return 1;
+ }
+
+ tmp = pth;
+ npth = 0;
+
+ for (;;) {
+ npth++; /* count words is + 1 count ':' */
+ tmp = strchr(tmp, ':');
+ if (tmp) {
+ if (*++tmp == 0)
+ break; /* :<empty> */
+ } else
+ break;
+ }
+
+ *p = xmalloc(npth * sizeof(char *));
+
+ tmp = pth;
+ (*p)[0] = bb_xstrdup(tmp);
+ npth = 1; /* count words is + 1 count ':' */
+
+ for (;;) {
+ tmp = strchr(tmp, ':');
+ if (tmp) {
+ (*p)[0][(tmp - pth)] = 0; /* ':' -> '\0' */
+ if (*++tmp == 0)
+ break; /* :<empty> */
+ } else
+ break;
+ (*p)[npth++] = &(*p)[0][(tmp - pth)]; /* p[next]=p[0][&'\0'+1] */
+ }
+
+ return npth;
+}
+
+static char *add_quote_for_spec_chars(char *found)
+{
+ int l = 0;
+ char *s = xmalloc((strlen(found) + 1) * 2);
+
+ while (*found) {
+ if (strchr(" `\"#$%^&*()=+{}[]:;\'|\\<>", *found))
+ s[l++] = '\\';
+ s[l++] = *found++;
+ }
+ s[l] = 0;
+ return s;
+}
+
+static char **exe_n_cwd_tab_completion(char *command, int *num_matches,
+ int type)
+{
+
+ char **matches = 0;
+ DIR *dir;
+ struct dirent *next;
+ char dirbuf[BUFSIZ];
+ int nm = *num_matches;
+ struct stat st;
+ char *path1[1];
+ char **paths = path1;
+ int npaths;
+ int i;
+ char *found;
+ char *pfind = strrchr(command, '/');
+
+ path1[0] = ".";
+
+ if (pfind == NULL) {
+ /* no dir, if flags==EXE_ONLY - get paths, else "." */
+ npaths = path_parse(&paths, type);
+ pfind = command;
+ } else {
+ /* with dir */
+ /* save for change */
+ strcpy(dirbuf, command);
+ /* set dir only */
+ dirbuf[(pfind - command) + 1] = 0;
+#ifdef CONFIG_FEATURE_COMMAND_USERNAME_COMPLETION
+ if (dirbuf[0] == '~') /* ~/... or ~user/... */
+ username_tab_completion(dirbuf, 0);
+#endif
+ /* "strip" dirname in command */
+ pfind++;
+
+ paths[0] = dirbuf;
+ npaths = 1; /* only 1 dir */
+ }
+
+ for (i = 0; i < npaths; i++) {
+
+ dir = opendir(paths[i]);
+ if (!dir) /* Don't print an error */
+ continue;
+
+ while ((next = readdir(dir)) != NULL) {
+ char *str_found = next->d_name;
+
+ /* matched ? */
+ if (strncmp(str_found, pfind, strlen(pfind)))
+ continue;
+ /* not see .name without .match */
+ if (*str_found == '.' && *pfind == 0) {
+ if (*paths[i] == '/' && paths[i][1] == 0
+ && str_found[1] == 0) str_found = ""; /* only "/" */
+ else
+ continue;
+ }
+ found = concat_path_file(paths[i], str_found);
+ /* hmm, remover in progress? */
+ if (stat(found, &st) < 0)
+ goto cont;
+ /* find with dirs ? */
+ if (paths[i] != dirbuf)
+ strcpy(found, next->d_name); /* only name */
+ if (S_ISDIR(st.st_mode)) {
+ /* name is directory */
+ str_found = found;
+ found = concat_path_file(found, "");
+ free(str_found);
+ str_found = add_quote_for_spec_chars(found);
+ } else {
+ /* not put found file if search only dirs for cd */
+ if (type == FIND_DIR_ONLY)
+ goto cont;
+ str_found = add_quote_for_spec_chars(found);
+ if (type == FIND_FILE_ONLY ||
+ (type == FIND_EXE_ONLY && is_execute(&st)))
+ strcat(str_found, " ");
+ }
+ /* Add it to the list */
+ matches = xrealloc(matches, (nm + 1) * sizeof(char *));
+
+ matches[nm++] = str_found;
+cont:
+ free(found);
+ }
+ closedir(dir);
+ }
+ if (paths != path1) {
+ free(paths[0]); /* allocated memory only in first member */
+ free(paths);
+ }
+ *num_matches = nm;
+ return (matches);
+}
+
+static int match_compare(const void *a, const void *b)
+{
+ return strcmp(*(char **) a, *(char **) b);
+}
+
+
+
+#define QUOT (UCHAR_MAX+1)
+
+#define collapse_pos(is, in) { \
+ memcpy(int_buf+(is), int_buf+(in), (BUFSIZ+1-(is)-(in))*sizeof(int)); \
+ memcpy(pos_buf+(is), pos_buf+(in), (BUFSIZ+1-(is)-(in))*sizeof(int)); }
+
+static int find_match(char *matchBuf, int *len_with_quotes)
+{
+ int i, j;
+ int command_mode;
+ int c, c2;
+ int int_buf[BUFSIZ + 1];
+ int pos_buf[BUFSIZ + 1];
+
+ /* set to integer dimension characters and own positions */
+ for (i = 0;; i++) {
+ int_buf[i] = (int) ((unsigned char) matchBuf[i]);
+ if (int_buf[i] == 0) {
+ pos_buf[i] = -1; /* indicator end line */
+ break;
+ } else
+ pos_buf[i] = i;
+ }
+
+ /* mask \+symbol and convert '\t' to ' ' */
+ for (i = j = 0; matchBuf[i]; i++, j++)
+ if (matchBuf[i] == '\\') {
+ collapse_pos(j, j + 1);
+ int_buf[j] |= QUOT;
+ i++;
+#ifdef CONFIG_FEATURE_NONPRINTABLE_INVERSE_PUT
+ if (matchBuf[i] == '\t') /* algorithm equivalent */
+ int_buf[j] = ' ' | QUOT;
+#endif
+ }
+#ifdef CONFIG_FEATURE_NONPRINTABLE_INVERSE_PUT
+ else if (matchBuf[i] == '\t')
+ int_buf[j] = ' ';
+#endif
+
+ /* mask "symbols" or 'symbols' */
+ c2 = 0;
+ for (i = 0; int_buf[i]; i++) {
+ c = int_buf[i];
+ if (c == '\'' || c == '"') {
+ if (c2 == 0)
+ c2 = c;
+ else {
+ if (c == c2)
+ c2 = 0;
+ else
+ int_buf[i] |= QUOT;
+ }
+ } else if (c2 != 0 && c != '$')
+ int_buf[i] |= QUOT;
+ }
+
+ /* skip commands with arguments if line have commands delimiters */
+ /* ';' ';;' '&' '|' '&&' '||' but `>&' `<&' `>|' */
+ for (i = 0; int_buf[i]; i++) {
+ c = int_buf[i];
+ c2 = int_buf[i + 1];
+ j = i ? int_buf[i - 1] : -1;
+ command_mode = 0;
+ if (c == ';' || c == '&' || c == '|') {
+ command_mode = 1 + (c == c2);
+ if (c == '&') {
+ if (j == '>' || j == '<')
+ command_mode = 0;
+ } else if (c == '|' && j == '>')
+ command_mode = 0;
+ }
+ if (command_mode) {
+ collapse_pos(0, i + command_mode);
+ i = -1; /* hack incremet */
+ }
+ }
+ /* collapse `command...` */
+ for (i = 0; int_buf[i]; i++)
+ if (int_buf[i] == '`') {
+ for (j = i + 1; int_buf[j]; j++)
+ if (int_buf[j] == '`') {
+ collapse_pos(i, j + 1);
+ j = 0;
+ break;
+ }
+ if (j) {
+ /* not found close ` - command mode, collapse all previous */
+ collapse_pos(0, i + 1);
+ break;
+ } else
+ i--; /* hack incremet */
+ }
+
+ /* collapse (command...(command...)...) or {command...{command...}...} */
+ c = 0; /* "recursive" level */
+ c2 = 0;
+ for (i = 0; int_buf[i]; i++)
+ if (int_buf[i] == '(' || int_buf[i] == '{') {
+ if (int_buf[i] == '(')
+ c++;
+ else
+ c2++;
+ collapse_pos(0, i + 1);
+ i = -1; /* hack incremet */
+ }
+ for (i = 0; pos_buf[i] >= 0 && (c > 0 || c2 > 0); i++)
+ if ((int_buf[i] == ')' && c > 0) || (int_buf[i] == '}' && c2 > 0)) {
+ if (int_buf[i] == ')')
+ c--;
+ else
+ c2--;
+ collapse_pos(0, i + 1);
+ i = -1; /* hack incremet */
+ }
+
+ /* skip first not quote space */
+ for (i = 0; int_buf[i]; i++)
+ if (int_buf[i] != ' ')
+ break;
+ if (i)
+ collapse_pos(0, i);
+
+ /* set find mode for completion */
+ command_mode = FIND_EXE_ONLY;
+ for (i = 0; int_buf[i]; i++)
+ if (int_buf[i] == ' ' || int_buf[i] == '<' || int_buf[i] == '>') {
+ if (int_buf[i] == ' ' && command_mode == FIND_EXE_ONLY
+ && matchBuf[pos_buf[0]]=='c'
+ && matchBuf[pos_buf[1]]=='d' )
+ command_mode = FIND_DIR_ONLY;
+ else {
+ command_mode = FIND_FILE_ONLY;
+ break;
+ }
+ }
+ /* "strlen" */
+ for (i = 0; int_buf[i]; i++);
+ /* find last word */
+ for (--i; i >= 0; i--) {
+ c = int_buf[i];
+ if (c == ' ' || c == '<' || c == '>' || c == '|' || c == '&') {
+ collapse_pos(0, i + 1);
+ break;
+ }
+ }
+ /* skip first not quoted '\'' or '"' */
+ for (i = 0; int_buf[i] == '\'' || int_buf[i] == '"'; i++);
+ /* collapse quote or unquote // or /~ */
+ while ((int_buf[i] & ~QUOT) == '/' &&
+ ((int_buf[i + 1] & ~QUOT) == '/'
+ || (int_buf[i + 1] & ~QUOT) == '~')) {
+ i++;
+ }
+
+ /* set only match and destroy quotes */
+ j = 0;
+ for (c = 0; pos_buf[i] >= 0; i++) {
+ matchBuf[c++] = matchBuf[pos_buf[i]];
+ j = pos_buf[i] + 1;
+ }
+ matchBuf[c] = 0;
+ /* old lenght matchBuf with quotes symbols */
+ *len_with_quotes = j ? j - pos_buf[0] : 0;
+
+ return command_mode;
+}
+
+/*
+ display by column original ideas from ls applet,
+ very optimize by my :)
+*/
+static void showfiles(char **matches, int nfiles)
+{
+ int ncols, row;
+ int column_width = 0;
+ int nrows = nfiles;
+
+ /* find the longest file name- use that as the column width */
+ for (row = 0; row < nrows; row++) {
+ int l = strlen(matches[row]);
+
+ if (column_width < l)
+ column_width = l;
+ }
+ column_width += 2; /* min space for columns */
+ ncols = cmdedit_termw / column_width;
+
+ if (ncols > 1) {
+ nrows /= ncols;
+ if(nfiles % ncols)
+ nrows++; /* round up fractionals */
+ column_width = -column_width; /* for printf("%-Ns", ...); */
+ } else {
+ ncols = 1;
+ }
+ for (row = 0; row < nrows; row++) {
+ int n = row;
+ int nc;
+
+ for(nc = 1; nc < ncols && n+nrows < nfiles; n += nrows, nc++)
+ printf("%*s", column_width, matches[n]);
+ printf("%s\n", matches[n]);
+ }
+}
+
+
+static void input_tab(int *lastWasTab)
+{
+ /* Do TAB completion */
+ static int num_matches;
+ static char **matches;
+
+ if (lastWasTab == 0) { /* free all memory */
+ if (matches) {
+ while (num_matches > 0)
+ free(matches[--num_matches]);
+ free(matches);
+ matches = (char **) NULL;
+ }
+ return;
+ }
+ if (! *lastWasTab) {
+
+ char *tmp;
+ int len_found;
+ char matchBuf[BUFSIZ];
+ int find_type;
+ int recalc_pos;
+
+ *lastWasTab = TRUE; /* flop trigger */
+
+ /* Make a local copy of the string -- up
+ * to the position of the cursor */
+ tmp = strncpy(matchBuf, command_ps, cursor);
+ tmp[cursor] = 0;
+
+ find_type = find_match(matchBuf, &recalc_pos);
+
+ /* Free up any memory already allocated */
+ input_tab(0);
+
+#ifdef CONFIG_FEATURE_COMMAND_USERNAME_COMPLETION
+ /* If the word starts with `~' and there is no slash in the word,
+ * then try completing this word as a username. */
+
+ if (matchBuf[0] == '~' && strchr(matchBuf, '/') == 0)
+ matches = username_tab_completion(matchBuf, &num_matches);
+#endif
+ /* Try to match any executable in our path and everything
+ * in the current working directory that matches. */
+ if (!matches)
+ matches =
+ exe_n_cwd_tab_completion(matchBuf,
+ &num_matches, find_type);
+ /* Remove duplicate found */
+ if(matches) {
+ int i, j;
+ /* bubble */
+ for(i=0; i<(num_matches-1); i++)
+ for(j=i+1; j<num_matches; j++)
+ if(matches[i]!=0 && matches[j]!=0 &&
+ strcmp(matches[i], matches[j])==0) {
+ free(matches[j]);
+ matches[j]=0;
+ }
+ j=num_matches;
+ num_matches = 0;
+ for(i=0; i<j; i++)
+ if(matches[i]) {
+ if(!strcmp(matches[i], "./"))
+ matches[i][1]=0;
+ else if(!strcmp(matches[i], "../"))
+ matches[i][2]=0;
+ matches[num_matches++]=matches[i];
+ }
+ }
+ /* Did we find exactly one match? */
+ if (!matches || num_matches > 1) {
+ char *tmp1;
+
+ beep();
+ if (!matches)
+ return; /* not found */
+ /* sort */
+ qsort(matches, num_matches, sizeof(char *), match_compare);
+
+ /* find minimal match */
+ tmp = bb_xstrdup(matches[0]);
+ for (tmp1 = tmp; *tmp1; tmp1++)
+ for (len_found = 1; len_found < num_matches; len_found++)
+ if (matches[len_found][(tmp1 - tmp)] != *tmp1) {
+ *tmp1 = 0;
+ break;
+ }
+ if (*tmp == 0) { /* have unique */
+ free(tmp);
+ return;
+ }
+ } else { /* one match */
+ tmp = matches[0];
+ /* for next completion current found */
+ *lastWasTab = FALSE;
+ }
+
+ len_found = strlen(tmp);
+ /* have space to placed match? */
+ if ((len_found - strlen(matchBuf) + len) < BUFSIZ) {
+
+ /* before word for match */
+ command_ps[cursor - recalc_pos] = 0;
+ /* save tail line */
+ strcpy(matchBuf, command_ps + cursor);
+ /* add match */
+ strcat(command_ps, tmp);
+ /* add tail */
+ strcat(command_ps, matchBuf);
+ /* back to begin word for match */
+ input_backward(recalc_pos);
+ /* new pos */
+ recalc_pos = cursor + len_found;
+ /* new len */
+ len = strlen(command_ps);
+ /* write out the matched command */
+ redraw(cmdedit_y, len - recalc_pos);
+ }
+ if (tmp != matches[0])
+ free(tmp);
+ } else {
+ /* Ok -- the last char was a TAB. Since they
+ * just hit TAB again, print a list of all the
+ * available choices... */
+ if (matches && num_matches > 0) {
+ int sav_cursor = cursor; /* change goto_new_line() */
+
+ /* Go to the next line */
+ goto_new_line();
+ showfiles(matches, num_matches);
+ redraw(0, len - sav_cursor);
+ }
+ }
+}
+#endif /* CONFIG_FEATURE_COMMAND_TAB_COMPLETION */
+
+#if MAX_HISTORY >= 1
+static void get_previous_history(void)
+{
+ if(command_ps[0] != 0 || history[cur_history] == 0) {
+ free(history[cur_history]);
+ history[cur_history] = bb_xstrdup(command_ps);
+ }
+ cur_history--;
+}
+
+static int get_next_history(void)
+{
+ int ch = cur_history;
+
+ if (ch < n_history) {
+ get_previous_history(); /* save the current history line */
+ return (cur_history = ch+1);
+ } else {
+ beep();
+ return 0;
+ }
+}
+
+#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
+extern void load_history ( const char *fromfile )
+{
+ FILE *fp;
+ int hi;
+
+ /* cleanup old */
+
+ for(hi = n_history; hi > 0; ) {
+ hi--;
+ free ( history [hi] );
+ }
+
+ if (( fp = fopen ( fromfile, "r" ))) {
+
+ for ( hi = 0; hi < MAX_HISTORY; ) {
+ char * hl = bb_get_chomped_line_from_file(fp);
+ int l;
+
+ if(!hl)
+ break;
+ l = strlen(hl);
+ if(l >= BUFSIZ)
+ hl[BUFSIZ-1] = 0;
+ if(l == 0 || hl[0] == ' ') {
+ free(hl);
+ continue;
+ }
+ history [hi++] = hl;
+ }
+ fclose ( fp );
+ }
+ cur_history = n_history = hi;
+}
+
+extern void save_history ( const char *tofile )
+{
+ FILE *fp = fopen ( tofile, "w" );
+
+ if ( fp ) {
+ int i;
+
+ for ( i = 0; i < n_history; i++ ) {
+ fputs ( history [i], fp );
+ fputc ( '\n', fp );
+ }
+ fclose ( fp );
+ }
+}
+#endif
+
+#endif
+
+enum {
+ ESC = 27,
+ DEL = 127,
+};
+
+
+/*
+ * This function is used to grab a character buffer
+ * from the input file descriptor and allows you to
+ * a string with full command editing (sortof like
+ * a mini readline).
+ *
+ * The following standard commands are not implemented:
+ * ESC-b -- Move back one word
+ * ESC-f -- Move forward one word
+ * ESC-d -- Delete back one word
+ * ESC-h -- Delete forward one word
+ * CTL-t -- Transpose two characters
+ *
+ * Furthermore, the "vi" command editing keys are not implemented.
+ *
+ */
+
+
+int cmdedit_read_input(char *prompt, char command[BUFSIZ])
+{
+
+ int break_out = 0;
+ int lastWasTab = FALSE;
+ unsigned char c = 0;
+
+ /* prepare before init handlers */
+ cmdedit_y = 0; /* quasireal y, not true work if line > xt*yt */
+ len = 0;
+ command_ps = command;
+
+ getTermSettings(0, (void *) &initial_settings);
+ memcpy(&new_settings, &initial_settings, sizeof(struct termios));
+ new_settings.c_lflag &= ~ICANON; /* unbuffered input */
+ /* Turn off echoing and CTRL-C, so we can trap it */
+ new_settings.c_lflag &= ~(ECHO | ECHONL | ISIG);
+#ifndef linux
+ /* Hmm, in linux c_cc[] not parsed if set ~ICANON */
+ new_settings.c_cc[VMIN] = 1;
+ new_settings.c_cc[VTIME] = 0;
+ /* Turn off CTRL-C, so we can trap it */
+# ifndef _POSIX_VDISABLE
+# define _POSIX_VDISABLE '\0'
+# endif
+ new_settings.c_cc[VINTR] = _POSIX_VDISABLE;
+#endif
+ command[0] = 0;
+
+ setTermSettings(0, (void *) &new_settings);
+ handlers_sets |= SET_RESET_TERM;
+
+ /* Now initialize things */
+ cmdedit_init();
+ /* Print out the command prompt */
+ parse_prompt(prompt);
+
+ while (1) {
+
+ fflush(stdout); /* buffered out to fast */
+
+ if (safe_read(0, &c, 1) < 1)
+ /* if we can't read input then exit */
+ goto prepare_to_die;
+
+ switch (c) {
+ case '\n':
+ case '\r':
+ /* Enter */
+ goto_new_line();
+ break_out = 1;
+ break;
+ case 1:
+ /* Control-a -- Beginning of line */
+ input_backward(cursor);
+ break;
+ case 2:
+ /* Control-b -- Move back one character */
+ input_backward(1);
+ break;
+ case 3:
+ /* Control-c -- stop gathering input */
+ goto_new_line();
+ command[0] = 0;
+ len = 0;
+#if !defined(CONFIG_ASH)
+ lastWasTab = FALSE;
+ put_prompt();
+#else
+ break_out = 2;
+#endif
+ break;
+ case 4:
+ /* Control-d -- Delete one character, or exit
+ * if the len=0 and no chars to delete */
+ if (len == 0) {
+prepare_to_die:
+#if !defined(CONFIG_ASH)
+ printf("exit");
+ goto_new_line();
+ /* cmdedit_reset_term() called in atexit */
+ exit(EXIT_SUCCESS);
+#else
+ break_out = -1; /* for control stoped jobs */
+ break;
+#endif
+ } else {
+ input_delete();
+ }
+ break;
+ case 5:
+ /* Control-e -- End of line */
+ input_end();
+ break;
+ case 6:
+ /* Control-f -- Move forward one character */
+ input_forward();
+ break;
+ case '\b':
+ case DEL:
+ /* Control-h and DEL */
+ input_backspace();
+ break;
+ case '\t':
+#ifdef CONFIG_FEATURE_COMMAND_TAB_COMPLETION
+ input_tab(&lastWasTab);
+#endif
+ break;
+ case 11:
+ /* Control-k -- clear to end of line */
+ *(command + cursor) = 0;
+ len = cursor;
+ printf("\033[J");
+ break;
+ case 12:
+ /* Control-l -- clear screen */
+ printf("\033[H");
+ redraw(0, len-cursor);
+ break;
+#if MAX_HISTORY >= 1
+ case 14:
+ /* Control-n -- Get next command in history */
+ if (get_next_history())
+ goto rewrite_line;
+ break;
+ case 16:
+ /* Control-p -- Get previous command from history */
+ if (cur_history > 0) {
+ get_previous_history();
+ goto rewrite_line;
+ } else {
+ beep();
+ }
+ break;
+#endif
+ case 21:
+ /* Control-U -- Clear line before cursor */
+ if (cursor) {
+ strcpy(command, command + cursor);
+ redraw(cmdedit_y, len -= cursor);
+ }
+ break;
+ case ESC:{
+ /* escape sequence follows */
+ if (safe_read(0, &c, 1) < 1)
+ goto prepare_to_die;
+ /* different vt100 emulations */
+ if (c == '[' || c == 'O') {
+ if (safe_read(0, &c, 1) < 1)
+ goto prepare_to_die;
+ }
+ switch (c) {
+#ifdef CONFIG_FEATURE_COMMAND_TAB_COMPLETION
+ case '\t': /* Alt-Tab */
+
+ input_tab(&lastWasTab);
+ break;
+#endif
+#if MAX_HISTORY >= 1
+ case 'A':
+ /* Up Arrow -- Get previous command from history */
+ if (cur_history > 0) {
+ get_previous_history();
+ goto rewrite_line;
+ } else {
+ beep();
+ }
+ break;
+ case 'B':
+ /* Down Arrow -- Get next command in history */
+ if (!get_next_history())
+ break;
+ /* Rewrite the line with the selected history item */
+rewrite_line:
+ /* change command */
+ len = strlen(strcpy(command, history[cur_history]));
+ /* redraw and go to end line */
+ redraw(cmdedit_y, 0);
+ break;
+#endif
+ case 'C':
+ /* Right Arrow -- Move forward one character */
+ input_forward();
+ break;
+ case 'D':
+ /* Left Arrow -- Move back one character */
+ input_backward(1);
+ break;
+ case '3':
+ /* Delete */
+ input_delete();
+ break;
+ case '1':
+ case 'H':
+ /* Home (Ctrl-A) */
+ input_backward(cursor);
+ break;
+ case '4':
+ case 'F':
+ /* End (Ctrl-E) */
+ input_end();
+ break;
+ default:
+ if (!(c >= '1' && c <= '9'))
+ c = 0;
+ beep();
+ }
+ if (c >= '1' && c <= '9')
+ do
+ if (safe_read(0, &c, 1) < 1)
+ goto prepare_to_die;
+ while (c != '~');
+ break;
+ }
+
+ default: /* If it's regular input, do the normal thing */
+#ifdef CONFIG_FEATURE_NONPRINTABLE_INVERSE_PUT
+ /* Control-V -- Add non-printable symbol */
+ if (c == 22) {
+ if (safe_read(0, &c, 1) < 1)
+ goto prepare_to_die;
+ if (c == 0) {
+ beep();
+ break;
+ }
+ } else
+#endif
+ if (!Isprint(c)) /* Skip non-printable characters */
+ break;
+
+ if (len >= (BUFSIZ - 2)) /* Need to leave space for enter */
+ break;
+
+ len++;
+
+ if (cursor == (len - 1)) { /* Append if at the end of the line */
+ *(command + cursor) = c;
+ *(command + cursor + 1) = 0;
+ cmdedit_set_out_char(0);
+ } else { /* Insert otherwise */
+ int sc = cursor;
+
+ memmove(command + sc + 1, command + sc, len - sc);
+ *(command + sc) = c;
+ sc++;
+ /* rewrite from cursor */
+ input_end();
+ /* to prev x pos + 1 */
+ input_backward(cursor - sc);
+ }
+
+ break;
+ }
+ if (break_out) /* Enter is the command terminator, no more input. */
+ break;
+
+ if (c != '\t')
+ lastWasTab = FALSE;
+ }
+
+ setTermSettings(0, (void *) &initial_settings);
+ handlers_sets &= ~SET_RESET_TERM;
+
+#if MAX_HISTORY >= 1
+ /* Handle command history log */
+ /* cleanup may be saved current command line */
+ free(history[MAX_HISTORY]);
+ history[MAX_HISTORY] = 0;
+ if (len) { /* no put empty line */
+ int i = n_history;
+ /* After max history, remove the oldest command */
+ if (i >= MAX_HISTORY) {
+ free(history[0]);
+ for(i = 0; i < (MAX_HISTORY-1); i++)
+ history[i] = history[i+1];
+ }
+ history[i++] = bb_xstrdup(command);
+ cur_history = i;
+ n_history = i;
+#if defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
+ num_ok_lines++;
+#endif
+ }
+#else /* MAX_HISTORY < 1 */
+#if defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
+ if (len) { /* no put empty line */
+ num_ok_lines++;
+ }
+#endif
+#endif /* MAX_HISTORY >= 1 */
+ if(break_out == 1) {
+ command[len++] = '\n'; /* set '\n' */
+ command[len] = 0;
+ }
+#if defined(CONFIG_FEATURE_CLEAN_UP) && defined(CONFIG_FEATURE_COMMAND_TAB_COMPLETION)
+ input_tab(0); /* strong free */
+#endif
+#if defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
+ free(cmdedit_prompt);
+#endif
+ cmdedit_reset_term();
+#if !defined(CONFIG_ASH)
+ return len;
+#else
+ return break_out < 0 ? break_out : len;
+#endif
+}
+
+
+
+#endif /* CONFIG_FEATURE_COMMAND_EDITING */
+
+
+#ifdef TEST
+
+const char *bb_applet_name = "debug stuff usage";
+const char *memory_exhausted = "Memory exhausted";
+
+#ifdef CONFIG_FEATURE_NONPRINTABLE_INVERSE_PUT
+#include <locale.h>
+#endif
+
+int main(int argc, char **argv)
+{
+ char buff[BUFSIZ];
+ char *prompt =
+#if defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
+ "\\[\\033[32;1m\\]\\u@\\[\\x1b[33;1m\\]\\h:\
+\\[\\033[34;1m\\]\\w\\[\\033[35;1m\\] \
+\\!\\[\\e[36;1m\\]\\$ \\[\\E[0m\\]";
+#else
+ "% ";
+#endif
+
+#ifdef CONFIG_FEATURE_NONPRINTABLE_INVERSE_PUT
+ setlocale(LC_ALL, "");
+#endif
+ while(1) {
+ int l;
+ cmdedit_read_input(prompt, buff);
+ l = strlen(buff);
+ if(l==0)
+ break;
+ if(l > 0 && buff[l-1] == '\n')
+ buff[l-1] = 0;
+ printf("*** cmdedit_read_input() returned line =%s=\n", buff);
+ }
+ printf("*** cmdedit_read_input() detect ^C\n");
+ return 0;
+}
+
+#endif /* TEST */
diff --git a/release/src/router/busybox/shell/cmdedit.h b/release/src/router/busybox/shell/cmdedit.h
new file mode 100644
index 00000000..991dafcd
--- /dev/null
+++ b/release/src/router/busybox/shell/cmdedit.h
@@ -0,0 +1,11 @@
+#ifndef CMDEDIT_H
+#define CMDEDIT_H
+
+int cmdedit_read_input(char* promptStr, char* command);
+
+#ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
+void load_history ( const char *fromfile );
+void save_history ( const char *tofile );
+#endif
+
+#endif /* CMDEDIT_H */
diff --git a/release/src/router/busybox/shell/hush.c b/release/src/router/busybox/shell/hush.c
new file mode 100644
index 00000000..84818ffa
--- /dev/null
+++ b/release/src/router/busybox/shell/hush.c
@@ -0,0 +1,2975 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * sh.c -- a prototype Bourne shell grammar parser
+ * Intended to follow the original Thompson and Ritchie
+ * "small and simple is beautiful" philosophy, which
+ * incidentally is a good match to today's BusyBox.
+ *
+ * Copyright (C) 2000,2001 Larry Doolittle <larry@doolittle.boa.org>
+ *
+ * Credits:
+ * The parser routines proper are all original material, first
+ * written Dec 2000 and Jan 2001 by Larry Doolittle. The
+ * execution engine, the builtins, and much of the underlying
+ * support has been adapted from busybox-0.49pre's lash, which is
+ * Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
+ * written by Erik Andersen <andersen@codepoet.org>. That, in turn,
+ * is based in part on ladsh.c, by Michael K. Johnson and Erik W.
+ * Troan, which they placed in the public domain. I don't know
+ * how much of the Johnson/Troan code has survived the repeated
+ * rewrites.
+ *
+ * Other credits:
+ * simple_itoa() was lifted from boa-0.93.15
+ * b_addchr() derived from similar w_addchar function in glibc-2.2
+ * setup_redirect(), redirect_opt_num(), and big chunks of main()
+ * and many builtins derived from contributions by Erik Andersen
+ * miscellaneous bugfixes from Matt Kraai
+ *
+ * There are two big (and related) architecture differences between
+ * this parser and the lash parser. One is that this version is
+ * actually designed from the ground up to understand nearly all
+ * of the Bourne grammar. The second, consequential change is that
+ * the parser and input reader have been turned inside out. Now,
+ * the parser is in control, and asks for input as needed. The old
+ * way had the input reader in control, and it asked for parsing to
+ * take place as needed. The new way makes it much easier to properly
+ * handle the recursion implicit in the various substitutions, especially
+ * across continuation lines.
+ *
+ * Bash grammar not implemented: (how many of these were in original sh?)
+ * $@ (those sure look like weird quoting rules)
+ * $_
+ * ! negation operator for pipes
+ * &> and >& redirection of stdout+stderr
+ * Brace Expansion
+ * Tilde Expansion
+ * fancy forms of Parameter Expansion
+ * aliases
+ * Arithmetic Expansion
+ * <(list) and >(list) Process Substitution
+ * reserved words: case, esac, select, function
+ * Here Documents ( << word )
+ * Functions
+ * Major bugs:
+ * job handling woefully incomplete and buggy
+ * reserved word execution woefully incomplete and buggy
+ * to-do:
+ * port selected bugfixes from post-0.49 busybox lash - done?
+ * finish implementing reserved words: for, while, until, do, done
+ * change { and } from special chars to reserved words
+ * builtins: break, continue, eval, return, set, trap, ulimit
+ * test magic exec
+ * handle children going into background
+ * clean up recognition of null pipes
+ * check setting of global_argc and global_argv
+ * control-C handling, probably with longjmp
+ * follow IFS rules more precisely, including update semantics
+ * figure out what to do with backslash-newline
+ * explain why we use signal instead of sigaction
+ * propagate syntax errors, die on resource errors?
+ * continuation lines, both explicit and implicit - done?
+ * memory leak finding and plugging - done?
+ * more testing, especially quoting rules and redirection
+ * document how quoting rules not precisely followed for variable assignments
+ * maybe change map[] to use 2-bit entries
+ * (eventually) remove all the printf's
+ *
+ * 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
+ */
+#include <ctype.h> /* isalpha, isdigit */
+#include <unistd.h> /* getpid */
+#include <stdlib.h> /* getenv, atoi */
+#include <string.h> /* strchr */
+#include <stdio.h> /* popen etc. */
+#include <glob.h> /* glob, of course */
+#include <stdarg.h> /* va_list */
+#include <errno.h>
+#include <fcntl.h>
+#include <getopt.h> /* should be pretty obvious */
+
+#include <sys/stat.h> /* ulimit */
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <signal.h>
+
+/* #include <dmalloc.h> */
+/* #define DEBUG_SHELL */
+
+#if 1
+#include "busybox.h"
+#include "cmdedit.h"
+#else
+#define bb_applet_name "hush"
+#include "standalone.h"
+#define hush_main main
+#undef CONFIG_FEATURE_SH_FANCY_PROMPT
+#define BB_BANNER
+#endif
+#define SPECIAL_VAR_SYMBOL 03
+#define FLAG_EXIT_FROM_LOOP 1
+#define FLAG_PARSE_SEMICOLON (1 << 1) /* symbol ';' is special for parser */
+#define FLAG_REPARSING (1 << 2) /* >=2nd pass */
+
+typedef enum {
+ REDIRECT_INPUT = 1,
+ REDIRECT_OVERWRITE = 2,
+ REDIRECT_APPEND = 3,
+ REDIRECT_HEREIS = 4,
+ REDIRECT_IO = 5
+} redir_type;
+
+/* The descrip member of this structure is only used to make debugging
+ * output pretty */
+struct {int mode; int default_fd; char *descrip;} redir_table[] = {
+ { 0, 0, "()" },
+ { O_RDONLY, 0, "<" },
+ { O_CREAT|O_TRUNC|O_WRONLY, 1, ">" },
+ { O_CREAT|O_APPEND|O_WRONLY, 1, ">>" },
+ { O_RDONLY, -1, "<<" },
+ { O_RDWR, 1, "<>" }
+};
+
+typedef enum {
+ PIPE_SEQ = 1,
+ PIPE_AND = 2,
+ PIPE_OR = 3,
+ PIPE_BG = 4,
+} pipe_style;
+
+/* might eventually control execution */
+typedef enum {
+ RES_NONE = 0,
+ RES_IF = 1,
+ RES_THEN = 2,
+ RES_ELIF = 3,
+ RES_ELSE = 4,
+ RES_FI = 5,
+ RES_FOR = 6,
+ RES_WHILE = 7,
+ RES_UNTIL = 8,
+ RES_DO = 9,
+ RES_DONE = 10,
+ RES_XXXX = 11,
+ RES_IN = 12,
+ RES_SNTX = 13
+} reserved_style;
+#define FLAG_END (1<<RES_NONE)
+#define FLAG_IF (1<<RES_IF)
+#define FLAG_THEN (1<<RES_THEN)
+#define FLAG_ELIF (1<<RES_ELIF)
+#define FLAG_ELSE (1<<RES_ELSE)
+#define FLAG_FI (1<<RES_FI)
+#define FLAG_FOR (1<<RES_FOR)
+#define FLAG_WHILE (1<<RES_WHILE)
+#define FLAG_UNTIL (1<<RES_UNTIL)
+#define FLAG_DO (1<<RES_DO)
+#define FLAG_DONE (1<<RES_DONE)
+#define FLAG_IN (1<<RES_IN)
+#define FLAG_START (1<<RES_XXXX)
+
+/* This holds pointers to the various results of parsing */
+struct p_context {
+ struct child_prog *child;
+ struct pipe *list_head;
+ struct pipe *pipe;
+ struct redir_struct *pending_redirect;
+ reserved_style w;
+ int old_flag; /* for figuring out valid reserved words */
+ struct p_context *stack;
+ int type; /* define type of parser : ";$" common or special symbol */
+ /* How about quoting status? */
+};
+
+struct redir_struct {
+ redir_type type; /* type of redirection */
+ int fd; /* file descriptor being redirected */
+ int dup; /* -1, or file descriptor being duplicated */
+ struct redir_struct *next; /* pointer to the next redirect in the list */
+ glob_t word; /* *word.gl_pathv is the filename */
+};
+
+struct child_prog {
+ pid_t pid; /* 0 if exited */
+ char **argv; /* program name and arguments */
+ struct pipe *group; /* if non-NULL, first in group or subshell */
+ int subshell; /* flag, non-zero if group must be forked */
+ struct redir_struct *redirects; /* I/O redirections */
+ glob_t glob_result; /* result of parameter globbing */
+ int is_stopped; /* is the program currently running? */
+ struct pipe *family; /* pointer back to the child's parent pipe */
+ int sp; /* number of SPECIAL_VAR_SYMBOL */
+ int type;
+};
+
+struct pipe {
+ int jobid; /* job number */
+ int num_progs; /* total number of programs in job */
+ int running_progs; /* number of programs running */
+ char *text; /* name of job */
+ char *cmdbuf; /* buffer various argv's point into */
+ pid_t pgrp; /* process group ID for the job */
+ struct child_prog *progs; /* array of commands in pipe */
+ struct pipe *next; /* to track background commands */
+ int stopped_progs; /* number of programs alive, but stopped */
+ int job_context; /* bitmask defining current context */
+ pipe_style followup; /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */
+ reserved_style r_mode; /* supports if, for, while, until */
+};
+
+struct close_me {
+ int fd;
+ struct close_me *next;
+};
+
+struct variables {
+ char *name;
+ char *value;
+ int flg_export;
+ int flg_read_only;
+ struct variables *next;
+};
+
+/* globals, connect us to the outside world
+ * the first three support $?, $#, and $1 */
+char **global_argv;
+unsigned int global_argc;
+unsigned int last_return_code;
+extern char **environ; /* This is in <unistd.h>, but protected with __USE_GNU */
+
+/* "globals" within this file */
+static char *ifs;
+static char map[256];
+static int fake_mode;
+static int interactive;
+static struct close_me *close_me_head;
+static const char *cwd;
+static struct pipe *job_list;
+static unsigned int last_bg_pid;
+static unsigned int last_jobid;
+static unsigned int shell_terminal;
+static char *PS1;
+static char *PS2;
+struct variables shell_ver = { "HUSH_VERSION", "0.01", 1, 1, 0 };
+struct variables *top_vars = &shell_ver;
+
+
+#define B_CHUNK (100)
+#define B_NOSPAC 1
+
+typedef struct {
+ char *data;
+ int length;
+ int maxlen;
+ int quote;
+ int nonnull;
+} o_string;
+#define NULL_O_STRING {NULL,0,0,0,0}
+/* used for initialization:
+ o_string foo = NULL_O_STRING; */
+
+/* I can almost use ordinary FILE *. Is open_memstream() universally
+ * available? Where is it documented? */
+struct in_str {
+ const char *p;
+ char peek_buf[2];
+ int __promptme;
+ int promptmode;
+ FILE *file;
+ int (*get) (struct in_str *);
+ int (*peek) (struct in_str *);
+};
+#define b_getch(input) ((input)->get(input))
+#define b_peek(input) ((input)->peek(input))
+
+#define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
+
+struct built_in_command {
+ char *cmd; /* name */
+ char *descr; /* description */
+ int (*function) (struct child_prog *); /* function ptr */
+};
+
+/* belongs in busybox.h */
+static inline int max(int a, int b) {
+ return (a>b)?a:b;
+}
+
+/* This should be in utility.c */
+#ifdef DEBUG_SHELL
+static void debug_printf(const char *format, ...)
+{
+ va_list args;
+ va_start(args, format);
+ vfprintf(stderr, format, args);
+ va_end(args);
+}
+#else
+static inline void debug_printf(const char *format, ...) { }
+#endif
+#define final_printf debug_printf
+
+static void __syntax(char *file, int line) {
+ bb_error_msg("syntax error %s:%d", file, line);
+}
+#define syntax() __syntax(__FILE__, __LINE__)
+
+/* Index of subroutines: */
+/* function prototypes for builtins */
+static int builtin_cd(struct child_prog *child);
+static int builtin_env(struct child_prog *child);
+static int builtin_eval(struct child_prog *child);
+static int builtin_exec(struct child_prog *child);
+static int builtin_exit(struct child_prog *child);
+static int builtin_export(struct child_prog *child);
+static int builtin_fg_bg(struct child_prog *child);
+static int builtin_help(struct child_prog *child);
+static int builtin_jobs(struct child_prog *child);
+static int builtin_pwd(struct child_prog *child);
+static int builtin_read(struct child_prog *child);
+static int builtin_set(struct child_prog *child);
+static int builtin_shift(struct child_prog *child);
+static int builtin_source(struct child_prog *child);
+static int builtin_umask(struct child_prog *child);
+static int builtin_unset(struct child_prog *child);
+static int builtin_not_written(struct child_prog *child);
+/* o_string manipulation: */
+static int b_check_space(o_string *o, int len);
+static int b_addchr(o_string *o, int ch);
+static void b_reset(o_string *o);
+static int b_addqchr(o_string *o, int ch, int quote);
+static int b_adduint(o_string *o, unsigned int i);
+/* in_str manipulations: */
+static int static_get(struct in_str *i);
+static int static_peek(struct in_str *i);
+static int file_get(struct in_str *i);
+static int file_peek(struct in_str *i);
+static void setup_file_in_str(struct in_str *i, FILE *f);
+static void setup_string_in_str(struct in_str *i, const char *s);
+/* close_me manipulations: */
+static void mark_open(int fd);
+static void mark_closed(int fd);
+static void close_all(void);
+/* "run" the final data structures: */
+static char *indenter(int i);
+static int free_pipe_list(struct pipe *head, int indent);
+static int free_pipe(struct pipe *pi, int indent);
+/* really run the final data structures: */
+static int setup_redirects(struct child_prog *prog, int squirrel[]);
+static int run_list_real(struct pipe *pi);
+static void pseudo_exec(struct child_prog *child) __attribute__ ((noreturn));
+static int run_pipe_real(struct pipe *pi);
+/* extended glob support: */
+static int globhack(const char *src, int flags, glob_t *pglob);
+static int glob_needed(const char *s);
+static int xglob(o_string *dest, int flags, glob_t *pglob);
+/* variable assignment: */
+static int is_assignment(const char *s);
+/* data structure manipulation: */
+static int setup_redirect(struct p_context *ctx, int fd, redir_type style, struct in_str *input);
+static void initialize_context(struct p_context *ctx);
+static int done_word(o_string *dest, struct p_context *ctx);
+static int done_command(struct p_context *ctx);
+static int done_pipe(struct p_context *ctx, pipe_style type);
+/* primary string parsing: */
+static int redirect_dup_num(struct in_str *input);
+static int redirect_opt_num(o_string *o);
+static int process_command_subs(o_string *dest, struct p_context *ctx, struct in_str *input, int subst_end);
+static int parse_group(o_string *dest, struct p_context *ctx, struct in_str *input, int ch);
+static char *lookup_param(char *src);
+static char *make_string(char **inp);
+static int handle_dollar(o_string *dest, struct p_context *ctx, struct in_str *input);
+static int parse_string(o_string *dest, struct p_context *ctx, const char *src);
+static int parse_stream(o_string *dest, struct p_context *ctx, struct in_str *input0, int end_trigger);
+/* setup: */
+static int parse_stream_outer(struct in_str *inp, int flag);
+static int parse_string_outer(const char *s, int flag);
+static int parse_file_outer(FILE *f);
+/* job management: */
+static int checkjobs(struct pipe* fg_pipe);
+static void insert_bg_job(struct pipe *pi);
+static void remove_bg_job(struct pipe *pi);
+/* local variable support */
+static char **make_list_in(char **inp, char *name);
+static char *insert_var_value(char *inp);
+static char *get_local_var(const char *var);
+static void unset_local_var(const char *name);
+static int set_local_var(const char *s, int flg_export);
+
+/* Table of built-in functions. They can be forked or not, depending on
+ * context: within pipes, they fork. As simple commands, they do not.
+ * When used in non-forking context, they can change global variables
+ * in the parent shell process. If forked, of course they can not.
+ * For example, 'unset foo | whatever' will parse and run, but foo will
+ * still be set at the end. */
+static struct built_in_command bltins[] = {
+ {"bg", "Resume a job in the background", builtin_fg_bg},
+ {"break", "Exit for, while or until loop", builtin_not_written},
+ {"cd", "Change working directory", builtin_cd},
+ {"continue", "Continue for, while or until loop", builtin_not_written},
+ {"env", "Print all environment variables", builtin_env},
+ {"eval", "Construct and run shell command", builtin_eval},
+ {"exec", "Exec command, replacing this shell with the exec'd process",
+ builtin_exec},
+ {"exit", "Exit from shell()", builtin_exit},
+ {"export", "Set environment variable", builtin_export},
+ {"fg", "Bring job into the foreground", builtin_fg_bg},
+ {"jobs", "Lists the active jobs", builtin_jobs},
+ {"pwd", "Print current directory", builtin_pwd},
+ {"read", "Input environment variable", builtin_read},
+ {"return", "Return from a function", builtin_not_written},
+ {"set", "Set/unset shell local variables", builtin_set},
+ {"shift", "Shift positional parameters", builtin_shift},
+ {"trap", "Trap signals", builtin_not_written},
+ {"ulimit","Controls resource limits", builtin_not_written},
+ {"umask","Sets file creation mask", builtin_umask},
+ {"unset", "Unset environment variable", builtin_unset},
+ {".", "Source-in and run commands in a file", builtin_source},
+ {"help", "List shell built-in commands", builtin_help},
+ {NULL, NULL, NULL}
+};
+
+static const char *set_cwd(void)
+{
+ if(cwd==bb_msg_unknown)
+ cwd = NULL; /* xgetcwd(arg) called free(arg) */
+ cwd = xgetcwd((char *)cwd);
+ if (!cwd)
+ cwd = bb_msg_unknown;
+ return cwd;
+}
+
+/* built-in 'eval' handler */
+static int builtin_eval(struct child_prog *child)
+{
+ char *str = NULL;
+ int rcode = EXIT_SUCCESS;
+
+ if (child->argv[1]) {
+ str = make_string(child->argv + 1);
+ parse_string_outer(str, FLAG_EXIT_FROM_LOOP |
+ FLAG_PARSE_SEMICOLON);
+ free(str);
+ rcode = last_return_code;
+ }
+ return rcode;
+}
+
+/* built-in 'cd <path>' handler */
+static int builtin_cd(struct child_prog *child)
+{
+ char *newdir;
+ if (child->argv[1] == NULL)
+ newdir = getenv("HOME");
+ else
+ newdir = child->argv[1];
+ if (chdir(newdir)) {
+ printf("cd: %s: %s\n", newdir, strerror(errno));
+ return EXIT_FAILURE;
+ }
+ set_cwd();
+ return EXIT_SUCCESS;
+}
+
+/* built-in 'env' handler */
+static int builtin_env(struct child_prog *dummy)
+{
+ char **e = environ;
+ if (e == NULL) return EXIT_FAILURE;
+ for (; *e; e++) {
+ puts(*e);
+ }
+ return EXIT_SUCCESS;
+}
+
+/* built-in 'exec' handler */
+static int builtin_exec(struct child_prog *child)
+{
+ if (child->argv[1] == NULL)
+ return EXIT_SUCCESS; /* Really? */
+ child->argv++;
+ pseudo_exec(child);
+ /* never returns */
+}
+
+/* built-in 'exit' handler */
+static int builtin_exit(struct child_prog *child)
+{
+ if (child->argv[1] == NULL)
+ exit(last_return_code);
+ exit (atoi(child->argv[1]));
+}
+
+/* built-in 'export VAR=value' handler */
+static int builtin_export(struct child_prog *child)
+{
+ int res = 0;
+ char *name = child->argv[1];
+
+ if (name == NULL) {
+ return (builtin_env(child));
+ }
+
+ name = strdup(name);
+
+ if(name) {
+ char *value = strchr(name, '=');
+
+ if (!value) {
+ char *tmp;
+ /* They are exporting something without an =VALUE */
+
+ value = get_local_var(name);
+ if (value) {
+ size_t ln = strlen(name);
+
+ tmp = realloc(name, ln+strlen(value)+2);
+ if(tmp==NULL)
+ res = -1;
+ else {
+ sprintf(tmp+ln, "=%s", value);
+ name = tmp;
+ }
+ } else {
+ /* bash does not return an error when trying to export
+ * an undefined variable. Do likewise. */
+ res = 1;
+ }
+ }
+ }
+ if (res<0)
+ bb_perror_msg("export");
+ else if(res==0)
+ res = set_local_var(name, 1);
+ else
+ res = 0;
+ free(name);
+ return res;
+}
+
+/* built-in 'fg' and 'bg' handler */
+static int builtin_fg_bg(struct child_prog *child)
+{
+ int i, jobnum;
+ struct pipe *pi=NULL;
+
+ if (!interactive)
+ return EXIT_FAILURE;
+ /* If they gave us no args, assume they want the last backgrounded task */
+ if (!child->argv[1]) {
+ for (pi = job_list; pi; pi = pi->next) {
+ if (pi->jobid == last_jobid) {
+ break;
+ }
+ }
+ if (!pi) {
+ bb_error_msg("%s: no current job", child->argv[0]);
+ return EXIT_FAILURE;
+ }
+ } else {
+ if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) {
+ bb_error_msg("%s: bad argument '%s'", child->argv[0], child->argv[1]);
+ return EXIT_FAILURE;
+ }
+ for (pi = job_list; pi; pi = pi->next) {
+ if (pi->jobid == jobnum) {
+ break;
+ }
+ }
+ if (!pi) {
+ bb_error_msg("%s: %d: no such job", child->argv[0], jobnum);
+ return EXIT_FAILURE;
+ }
+ }
+
+ if (*child->argv[0] == 'f') {
+ /* Put the job into the foreground. */
+ tcsetpgrp(shell_terminal, pi->pgrp);
+ }
+
+ /* Restart the processes in the job */
+ for (i = 0; i < pi->num_progs; i++)
+ pi->progs[i].is_stopped = 0;
+
+ if ( (i=kill(- pi->pgrp, SIGCONT)) < 0) {
+ if (i == ESRCH) {
+ remove_bg_job(pi);
+ } else {
+ bb_perror_msg("kill (SIGCONT)");
+ }
+ }
+
+ pi->stopped_progs = 0;
+ return EXIT_SUCCESS;
+}
+
+/* built-in 'help' handler */
+static int builtin_help(struct child_prog *dummy)
+{
+ struct built_in_command *x;
+
+ printf("\nBuilt-in commands:\n");
+ printf("-------------------\n");
+ for (x = bltins; x->cmd; x++) {
+ if (x->descr==NULL)
+ continue;
+ printf("%s\t%s\n", x->cmd, x->descr);
+ }
+ printf("\n\n");
+ return EXIT_SUCCESS;
+}
+
+/* built-in 'jobs' handler */
+static int builtin_jobs(struct child_prog *child)
+{
+ struct pipe *job;
+ char *status_string;
+
+ for (job = job_list; job; job = job->next) {
+ if (job->running_progs == job->stopped_progs)
+ status_string = "Stopped";
+ else
+ status_string = "Running";
+
+ printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
+ }
+ return EXIT_SUCCESS;
+}
+
+
+/* built-in 'pwd' handler */
+static int builtin_pwd(struct child_prog *dummy)
+{
+ puts(set_cwd());
+ return EXIT_SUCCESS;
+}
+
+/* built-in 'read VAR' handler */
+static int builtin_read(struct child_prog *child)
+{
+ int res;
+
+ if (child->argv[1]) {
+ char string[BUFSIZ];
+ char *var = 0;
+
+ string[0] = 0; /* In case stdin has only EOF */
+ /* read string */
+ fgets(string, sizeof(string), stdin);
+ chomp(string);
+ var = malloc(strlen(child->argv[1])+strlen(string)+2);
+ if(var) {
+ sprintf(var, "%s=%s", child->argv[1], string);
+ res = set_local_var(var, 0);
+ } else
+ res = -1;
+ if (res)
+ fprintf(stderr, "read: %m\n");
+ free(var); /* So not move up to avoid breaking errno */
+ return res;
+ } else {
+ do res=getchar(); while(res!='\n' && res!=EOF);
+ return 0;
+ }
+}
+
+/* built-in 'set VAR=value' handler */
+static int builtin_set(struct child_prog *child)
+{
+ char *temp = child->argv[1];
+ struct variables *e;
+
+ if (temp == NULL)
+ for(e = top_vars; e; e=e->next)
+ printf("%s=%s\n", e->name, e->value);
+ else
+ set_local_var(temp, 0);
+
+ return EXIT_SUCCESS;
+}
+
+
+/* Built-in 'shift' handler */
+static int builtin_shift(struct child_prog *child)
+{
+ int n=1;
+ if (child->argv[1]) {
+ n=atoi(child->argv[1]);
+ }
+ if (n>=0 && n<global_argc) {
+ /* XXX This probably breaks $0 */
+ global_argc -= n;
+ global_argv += n;
+ return EXIT_SUCCESS;
+ } else {
+ return EXIT_FAILURE;
+ }
+}
+
+/* Built-in '.' handler (read-in and execute commands from file) */
+static int builtin_source(struct child_prog *child)
+{
+ FILE *input;
+ int status;
+
+ if (child->argv[1] == NULL)
+ return EXIT_FAILURE;
+
+ /* XXX search through $PATH is missing */
+ input = fopen(child->argv[1], "r");
+ if (!input) {
+ bb_error_msg("Couldn't open file '%s'", child->argv[1]);
+ return EXIT_FAILURE;
+ }
+
+ /* Now run the file */
+ /* XXX argv and argc are broken; need to save old global_argv
+ * (pointer only is OK!) on this stack frame,
+ * set global_argv=child->argv+1, recurse, and restore. */
+ mark_open(fileno(input));
+ status = parse_file_outer(input);
+ mark_closed(fileno(input));
+ fclose(input);
+ return (status);
+}
+
+static int builtin_umask(struct child_prog *child)
+{
+ mode_t new_umask;
+ const char *arg = child->argv[1];
+ char *end;
+ if (arg) {
+ new_umask=strtoul(arg, &end, 8);
+ if (*end!='\0' || end == arg) {
+ return EXIT_FAILURE;
+ }
+ } else {
+ printf("%.3o\n", (unsigned int) (new_umask=umask(0)));
+ }
+ umask(new_umask);
+ return EXIT_SUCCESS;
+}
+
+/* built-in 'unset VAR' handler */
+static int builtin_unset(struct child_prog *child)
+{
+ /* bash returned already true */
+ unset_local_var(child->argv[1]);
+ return EXIT_SUCCESS;
+}
+
+static int builtin_not_written(struct child_prog *child)
+{
+ printf("builtin_%s not written\n",child->argv[0]);
+ return EXIT_FAILURE;
+}
+
+static int b_check_space(o_string *o, int len)
+{
+ /* It would be easy to drop a more restrictive policy
+ * in here, such as setting a maximum string length */
+ if (o->length + len > o->maxlen) {
+ char *old_data = o->data;
+ /* assert (data == NULL || o->maxlen != 0); */
+ o->maxlen += max(2*len, B_CHUNK);
+ o->data = realloc(o->data, 1 + o->maxlen);
+ if (o->data == NULL) {
+ free(old_data);
+ }
+ }
+ return o->data == NULL;
+}
+
+static int b_addchr(o_string *o, int ch)
+{
+ debug_printf("b_addchr: %c %d %p\n", ch, o->length, o);
+ if (b_check_space(o, 1)) return B_NOSPAC;
+ o->data[o->length] = ch;
+ o->length++;
+ o->data[o->length] = '\0';
+ return 0;
+}
+
+static void b_reset(o_string *o)
+{
+ o->length = 0;
+ o->nonnull = 0;
+ if (o->data != NULL) *o->data = '\0';
+}
+
+static void b_free(o_string *o)
+{
+ b_reset(o);
+ free(o->data);
+ o->data = NULL;
+ o->maxlen = 0;
+}
+
+/* My analysis of quoting semantics tells me that state information
+ * is associated with a destination, not a source.
+ */
+static int b_addqchr(o_string *o, int ch, int quote)
+{
+ if (quote && strchr("*?[\\",ch)) {
+ int rc;
+ rc = b_addchr(o, '\\');
+ if (rc) return rc;
+ }
+ return b_addchr(o, ch);
+}
+
+/* belongs in utility.c */
+char *simple_itoa(unsigned int i)
+{
+ /* 21 digits plus null terminator, good for 64-bit or smaller ints */
+ static char local[22];
+ char *p = &local[21];
+ *p-- = '\0';
+ do {
+ *p-- = '0' + i % 10;
+ i /= 10;
+ } while (i > 0);
+ return p + 1;
+}
+
+static int b_adduint(o_string *o, unsigned int i)
+{
+ int r;
+ char *p = simple_itoa(i);
+ /* no escape checking necessary */
+ do r=b_addchr(o, *p++); while (r==0 && *p);
+ return r;
+}
+
+static int static_get(struct in_str *i)
+{
+ int ch=*i->p++;
+ if (ch=='\0') return EOF;
+ return ch;
+}
+
+static int static_peek(struct in_str *i)
+{
+ return *i->p;
+}
+
+static inline void cmdedit_set_initial_prompt(void)
+{
+#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
+ PS1 = NULL;
+#else
+ PS1 = getenv("PS1");
+ if(PS1==0)
+ PS1 = "\\w \\$ ";
+#endif
+}
+
+static inline void setup_prompt_string(int promptmode, char **prompt_str)
+{
+ debug_printf("setup_prompt_string %d ",promptmode);
+#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
+ /* Set up the prompt */
+ if (promptmode == 1) {
+ free(PS1);
+ PS1=xmalloc(strlen(cwd)+4);
+ sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# ");
+ *prompt_str = PS1;
+ } else {
+ *prompt_str = PS2;
+ }
+#else
+ *prompt_str = (promptmode==1)? PS1 : PS2;
+#endif
+ debug_printf("result %s\n",*prompt_str);
+}
+
+static void get_user_input(struct in_str *i)
+{
+ char *prompt_str;
+ static char the_command[BUFSIZ];
+
+ setup_prompt_string(i->promptmode, &prompt_str);
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+ /*
+ ** enable command line editing only while a command line
+ ** is actually being read; otherwise, we'll end up bequeathing
+ ** atexit() handlers and other unwanted stuff to our
+ ** child processes (rob@sysgo.de)
+ */
+ cmdedit_read_input(prompt_str, the_command);
+#else
+ fputs(prompt_str, stdout);
+ fflush(stdout);
+ the_command[0]=fgetc(i->file);
+ the_command[1]='\0';
+#endif
+ fflush(stdout);
+ i->p = the_command;
+}
+
+/* This is the magic location that prints prompts
+ * and gets data back from the user */
+static int file_get(struct in_str *i)
+{
+ int ch;
+
+ ch = 0;
+ /* If there is data waiting, eat it up */
+ if (i->p && *i->p) {
+ ch=*i->p++;
+ } else {
+ /* need to double check i->file because we might be doing something
+ * more complicated by now, like sourcing or substituting. */
+ if (i->__promptme && interactive && i->file == stdin) {
+ while(! i->p || (interactive && strlen(i->p)==0) ) {
+ get_user_input(i);
+ }
+ i->promptmode=2;
+ i->__promptme = 0;
+ if (i->p && *i->p) {
+ ch=*i->p++;
+ }
+ } else {
+ ch = fgetc(i->file);
+ }
+
+ debug_printf("b_getch: got a %d\n", ch);
+ }
+ if (ch == '\n') i->__promptme=1;
+ return ch;
+}
+
+/* All the callers guarantee this routine will never be
+ * used right after a newline, so prompting is not needed.
+ */
+static int file_peek(struct in_str *i)
+{
+ if (i->p && *i->p) {
+ return *i->p;
+ } else {
+ i->peek_buf[0] = fgetc(i->file);
+ i->peek_buf[1] = '\0';
+ i->p = i->peek_buf;
+ debug_printf("b_peek: got a %d\n", *i->p);
+ return *i->p;
+ }
+}
+
+static void setup_file_in_str(struct in_str *i, FILE *f)
+{
+ i->peek = file_peek;
+ i->get = file_get;
+ i->__promptme=1;
+ i->promptmode=1;
+ i->file = f;
+ i->p = NULL;
+}
+
+static void setup_string_in_str(struct in_str *i, const char *s)
+{
+ i->peek = static_peek;
+ i->get = static_get;
+ i->__promptme=1;
+ i->promptmode=1;
+ i->p = s;
+}
+
+static void mark_open(int fd)
+{
+ struct close_me *new = xmalloc(sizeof(struct close_me));
+ new->fd = fd;
+ new->next = close_me_head;
+ close_me_head = new;
+}
+
+static void mark_closed(int fd)
+{
+ struct close_me *tmp;
+ if (close_me_head == NULL || close_me_head->fd != fd)
+ bb_error_msg_and_die("corrupt close_me");
+ tmp = close_me_head;
+ close_me_head = close_me_head->next;
+ free(tmp);
+}
+
+static void close_all(void)
+{
+ struct close_me *c;
+ for (c=close_me_head; c; c=c->next) {
+ close(c->fd);
+ }
+ close_me_head = NULL;
+}
+
+/* squirrel != NULL means we squirrel away copies of stdin, stdout,
+ * and stderr if they are redirected. */
+static int setup_redirects(struct child_prog *prog, int squirrel[])
+{
+ int openfd, mode;
+ struct redir_struct *redir;
+
+ for (redir=prog->redirects; redir; redir=redir->next) {
+ if (redir->dup == -1 && redir->word.gl_pathv == NULL) {
+ /* something went wrong in the parse. Pretend it didn't happen */
+ continue;
+ }
+ if (redir->dup == -1) {
+ mode=redir_table[redir->type].mode;
+ openfd = open(redir->word.gl_pathv[0], mode, 0666);
+ if (openfd < 0) {
+ /* this could get lost if stderr has been redirected, but
+ bash and ash both lose it as well (though zsh doesn't!) */
+ bb_perror_msg("error opening %s", redir->word.gl_pathv[0]);
+ return 1;
+ }
+ } else {
+ openfd = redir->dup;
+ }
+
+ if (openfd != redir->fd) {
+ if (squirrel && redir->fd < 3) {
+ squirrel[redir->fd] = dup(redir->fd);
+ }
+ if (openfd == -3) {
+ close(openfd);
+ } else {
+ dup2(openfd, redir->fd);
+ if (redir->dup == -1)
+ close (openfd);
+ }
+ }
+ }
+ return 0;
+}
+
+static void restore_redirects(int squirrel[])
+{
+ int i, fd;
+ for (i=0; i<3; i++) {
+ fd = squirrel[i];
+ if (fd != -1) {
+ /* No error checking. I sure wouldn't know what
+ * to do with an error if I found one! */
+ dup2(fd, i);
+ close(fd);
+ }
+ }
+}
+
+/* never returns */
+/* XXX no exit() here. If you don't exec, use _exit instead.
+ * The at_exit handlers apparently confuse the calling process,
+ * in particular stdin handling. Not sure why? */
+static void pseudo_exec(struct child_prog *child)
+{
+ int i, rcode;
+ char *p;
+ struct built_in_command *x;
+ if (child->argv) {
+ for (i=0; is_assignment(child->argv[i]); i++) {
+ debug_printf("pid %d environment modification: %s\n",getpid(),child->argv[i]);
+ p = insert_var_value(child->argv[i]);
+ putenv(strdup(p));
+ if (p != child->argv[i]) free(p);
+ }
+ child->argv+=i; /* XXX this hack isn't so horrible, since we are about
+ to exit, and therefore don't need to keep data
+ structures consistent for free() use. */
+ /* If a variable is assigned in a forest, and nobody listens,
+ * was it ever really set?
+ */
+ if (child->argv[0] == NULL) {
+ _exit(EXIT_SUCCESS);
+ }
+
+ /*
+ * Check if the command matches any of the builtins.
+ * Depending on context, this might be redundant. But it's
+ * easier to waste a few CPU cycles than it is to figure out
+ * if this is one of those cases.
+ */
+ for (x = bltins; x->cmd; x++) {
+ if (strcmp(child->argv[0], x->cmd) == 0 ) {
+ debug_printf("builtin exec %s\n", child->argv[0]);
+ rcode = x->function(child);
+ fflush(stdout);
+ _exit(rcode);
+ }
+ }
+
+ /* Check if the command matches any busybox internal commands
+ * ("applets") here.
+ * FIXME: This feature is not 100% safe, since
+ * BusyBox is not fully reentrant, so we have no guarantee the things
+ * from the .bss are still zeroed, or that things from .data are still
+ * at their defaults. We could exec ourself from /proc/self/exe, but I
+ * really dislike relying on /proc for things. We could exec ourself
+ * from global_argv[0], but if we are in a chroot, we may not be able
+ * to find ourself... */
+#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
+ {
+ int argc_l;
+ char** argv_l=child->argv;
+ char *name = child->argv[0];
+
+#ifdef CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN
+ /* Following discussions from November 2000 on the busybox mailing
+ * list, the default configuration, (without
+ * bb_get_last_path_component()) lets the user force use of an
+ * external command by specifying the full (with slashes) filename.
+ * If you enable CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN, then applets
+ * _aways_ override external commands, so if you want to run
+ * /bin/cat, it will use BusyBox cat even if /bin/cat exists on the
+ * filesystem and is _not_ busybox. Some systems may want this,
+ * most do not. */
+ name = bb_get_last_path_component(name);
+#endif
+ /* Count argc for use in a second... */
+ for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++);
+ optind = 1;
+ debug_printf("running applet %s\n", name);
+ run_applet_by_name(name, argc_l, child->argv);
+ }
+#endif
+ debug_printf("exec of %s\n",child->argv[0]);
+ execvp(child->argv[0],child->argv);
+ bb_perror_msg("couldn't exec: %s",child->argv[0]);
+ _exit(1);
+ } else if (child->group) {
+ debug_printf("runtime nesting to group\n");
+ interactive=0; /* crucial!!!! */
+ rcode = run_list_real(child->group);
+ /* OK to leak memory by not calling free_pipe_list,
+ * since this process is about to exit */
+ _exit(rcode);
+ } else {
+ /* Can happen. See what bash does with ">foo" by itself. */
+ debug_printf("trying to pseudo_exec null command\n");
+ _exit(EXIT_SUCCESS);
+ }
+}
+
+static void insert_bg_job(struct pipe *pi)
+{
+ struct pipe *thejob;
+
+ /* Linear search for the ID of the job to use */
+ pi->jobid = 1;
+ for (thejob = job_list; thejob; thejob = thejob->next)
+ if (thejob->jobid >= pi->jobid)
+ pi->jobid = thejob->jobid + 1;
+
+ /* add thejob to the list of running jobs */
+ if (!job_list) {
+ thejob = job_list = xmalloc(sizeof(*thejob));
+ } else {
+ for (thejob = job_list; thejob->next; thejob = thejob->next) /* nothing */;
+ thejob->next = xmalloc(sizeof(*thejob));
+ thejob = thejob->next;
+ }
+
+ /* physically copy the struct job */
+ memcpy(thejob, pi, sizeof(struct pipe));
+ thejob->next = NULL;
+ thejob->running_progs = thejob->num_progs;
+ thejob->stopped_progs = 0;
+ thejob->text = xmalloc(BUFSIZ); /* cmdedit buffer size */
+
+ //if (pi->progs[0] && pi->progs[0].argv && pi->progs[0].argv[0])
+ {
+ char *bar=thejob->text;
+ char **foo=pi->progs[0].argv;
+ while(foo && *foo) {
+ bar += sprintf(bar, "%s ", *foo++);
+ }
+ }
+
+ /* we don't wait for background thejobs to return -- append it
+ to the list of backgrounded thejobs and leave it alone */
+ printf("[%d] %d\n", thejob->jobid, thejob->progs[0].pid);
+ last_bg_pid = thejob->progs[0].pid;
+ last_jobid = thejob->jobid;
+}
+
+/* remove a backgrounded job */
+static void remove_bg_job(struct pipe *pi)
+{
+ struct pipe *prev_pipe;
+
+ if (pi == job_list) {
+ job_list = pi->next;
+ } else {
+ prev_pipe = job_list;
+ while (prev_pipe->next != pi)
+ prev_pipe = prev_pipe->next;
+ prev_pipe->next = pi->next;
+ }
+ if (job_list)
+ last_jobid = job_list->jobid;
+ else
+ last_jobid = 0;
+
+ pi->stopped_progs = 0;
+ free_pipe(pi, 0);
+ free(pi);
+}
+
+/* Checks to see if any processes have exited -- if they
+ have, figure out why and see if a job has completed */
+static int checkjobs(struct pipe* fg_pipe)
+{
+ int attributes;
+ int status;
+ int prognum = 0;
+ struct pipe *pi;
+ pid_t childpid;
+
+ attributes = WUNTRACED;
+ if (fg_pipe==NULL) {
+ attributes |= WNOHANG;
+ }
+
+ while ((childpid = waitpid(-1, &status, attributes)) > 0) {
+ if (fg_pipe) {
+ int i, rcode = 0;
+ for (i=0; i < fg_pipe->num_progs; i++) {
+ if (fg_pipe->progs[i].pid == childpid) {
+ if (i==fg_pipe->num_progs-1)
+ rcode=WEXITSTATUS(status);
+ (fg_pipe->num_progs)--;
+ return(rcode);
+ }
+ }
+ }
+
+ for (pi = job_list; pi; pi = pi->next) {
+ prognum = 0;
+ while (prognum < pi->num_progs && pi->progs[prognum].pid != childpid) {
+ prognum++;
+ }
+ if (prognum < pi->num_progs)
+ break;
+ }
+
+ if(pi==NULL) {
+ debug_printf("checkjobs: pid %d was not in our list!\n", childpid);
+ continue;
+ }
+
+ if (WIFEXITED(status) || WIFSIGNALED(status)) {
+ /* child exited */
+ pi->running_progs--;
+ pi->progs[prognum].pid = 0;
+
+ if (!pi->running_progs) {
+ printf(JOB_STATUS_FORMAT, pi->jobid, "Done", pi->text);
+ remove_bg_job(pi);
+ }
+ } else {
+ /* child stopped */
+ pi->stopped_progs++;
+ pi->progs[prognum].is_stopped = 1;
+
+#if 0
+ /* Printing this stuff is a pain, since it tends to
+ * overwrite the prompt an inconveinient moments. So
+ * don't do that. */
+ if (pi->stopped_progs == pi->num_progs) {
+ printf("\n"JOB_STATUS_FORMAT, pi->jobid, "Stopped", pi->text);
+ }
+#endif
+ }
+ }
+
+ if (childpid == -1 && errno != ECHILD)
+ bb_perror_msg("waitpid");
+
+ /* move the shell to the foreground */
+ //if (interactive && tcsetpgrp(shell_terminal, getpgid(0)))
+ // bb_perror_msg("tcsetpgrp-2");
+ return -1;
+}
+
+/* Figure out our controlling tty, checking in order stderr,
+ * stdin, and stdout. If check_pgrp is set, also check that
+ * we belong to the foreground process group associated with
+ * that tty. The value of shell_terminal is needed in order to call
+ * tcsetpgrp(shell_terminal, ...); */
+void controlling_tty(int check_pgrp)
+{
+ pid_t curpgrp;
+
+ if ((curpgrp = tcgetpgrp(shell_terminal = 2)) < 0
+ && (curpgrp = tcgetpgrp(shell_terminal = 0)) < 0
+ && (curpgrp = tcgetpgrp(shell_terminal = 1)) < 0)
+ goto shell_terminal_error;
+
+ if (check_pgrp && curpgrp != getpgid(0))
+ goto shell_terminal_error;
+
+ return;
+
+shell_terminal_error:
+ shell_terminal = -1;
+ return;
+}
+
+/* run_pipe_real() starts all the jobs, but doesn't wait for anything
+ * to finish. See checkjobs().
+ *
+ * return code is normally -1, when the caller has to wait for children
+ * to finish to determine the exit status of the pipe. If the pipe
+ * is a simple builtin command, however, the action is done by the
+ * time run_pipe_real returns, and the exit code is provided as the
+ * return value.
+ *
+ * The input of the pipe is always stdin, the output is always
+ * stdout. The outpipe[] mechanism in BusyBox-0.48 lash is bogus,
+ * because it tries to avoid running the command substitution in
+ * subshell, when that is in fact necessary. The subshell process
+ * now has its stdout directed to the input of the appropriate pipe,
+ * so this routine is noticeably simpler.
+ */
+static int run_pipe_real(struct pipe *pi)
+{
+ int i;
+ int nextin, nextout;
+ int pipefds[2]; /* pipefds[0] is for reading */
+ struct child_prog *child;
+ struct built_in_command *x;
+ char *p;
+
+ nextin = 0;
+ pi->pgrp = -1;
+
+ /* Check if this is a simple builtin (not part of a pipe).
+ * Builtins within pipes have to fork anyway, and are handled in
+ * pseudo_exec. "echo foo | read bar" doesn't work on bash, either.
+ */
+ if (pi->num_progs == 1) child = & (pi->progs[0]);
+ if (pi->num_progs == 1 && child->group && child->subshell == 0) {
+ int squirrel[] = {-1, -1, -1};
+ int rcode;
+ debug_printf("non-subshell grouping\n");
+ setup_redirects(child, squirrel);
+ /* XXX could we merge code with following builtin case,
+ * by creating a pseudo builtin that calls run_list_real? */
+ rcode = run_list_real(child->group);
+ restore_redirects(squirrel);
+ return rcode;
+ } else if (pi->num_progs == 1 && pi->progs[0].argv != NULL) {
+ for (i=0; is_assignment(child->argv[i]); i++) { /* nothing */ }
+ if (i!=0 && child->argv[i]==NULL) {
+ /* assignments, but no command: set the local environment */
+ for (i=0; child->argv[i]!=NULL; i++) {
+
+ /* Ok, this case is tricky. We have to decide if this is a
+ * local variable, or an already exported variable. If it is
+ * already exported, we have to export the new value. If it is
+ * not exported, we need only set this as a local variable.
+ * This junk is all to decide whether or not to export this
+ * variable. */
+ int export_me=0;
+ char *name, *value;
+ name = bb_xstrdup(child->argv[i]);
+ debug_printf("Local environment set: %s\n", name);
+ value = strchr(name, '=');
+ if (value)
+ *value=0;
+ if ( get_local_var(name)) {
+ export_me=1;
+ }
+ free(name);
+ p = insert_var_value(child->argv[i]);
+ set_local_var(p, export_me);
+ if (p != child->argv[i]) free(p);
+ }
+ return EXIT_SUCCESS; /* don't worry about errors in set_local_var() yet */
+ }
+ for (i = 0; is_assignment(child->argv[i]); i++) {
+ p = insert_var_value(child->argv[i]);
+ putenv(strdup(p));
+ if (p != child->argv[i]) {
+ child->sp--;
+ free(p);
+ }
+ }
+ if (child->sp) {
+ char * str = NULL;
+
+ str = make_string((child->argv + i));
+ parse_string_outer(str, FLAG_EXIT_FROM_LOOP | FLAG_REPARSING);
+ free(str);
+ return last_return_code;
+ }
+ for (x = bltins; x->cmd; x++) {
+ if (strcmp(child->argv[i], x->cmd) == 0 ) {
+ int squirrel[] = {-1, -1, -1};
+ int rcode;
+ if (x->function == builtin_exec && child->argv[i+1]==NULL) {
+ debug_printf("magic exec\n");
+ setup_redirects(child,NULL);
+ return EXIT_SUCCESS;
+ }
+ debug_printf("builtin inline %s\n", child->argv[0]);
+ /* XXX setup_redirects acts on file descriptors, not FILEs.
+ * This is perfect for work that comes after exec().
+ * Is it really safe for inline use? Experimentally,
+ * things seem to work with glibc. */
+ setup_redirects(child, squirrel);
+ child->argv+=i; /* XXX horrible hack */
+ rcode = x->function(child);
+ child->argv-=i; /* XXX restore hack so free() can work right */
+ restore_redirects(squirrel);
+ return rcode;
+ }
+ }
+ }
+
+ for (i = 0; i < pi->num_progs; i++) {
+ child = & (pi->progs[i]);
+
+ /* pipes are inserted between pairs of commands */
+ if ((i + 1) < pi->num_progs) {
+ if (pipe(pipefds)<0) bb_perror_msg_and_die("pipe");
+ nextout = pipefds[1];
+ } else {
+ nextout=1;
+ pipefds[0] = -1;
+ }
+
+ /* XXX test for failed fork()? */
+#if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__)
+ if (!(child->pid = fork()))
+#else
+ if (!(child->pid = vfork()))
+#endif
+ {
+ /* Set the handling for job control signals back to the default. */
+ signal(SIGINT, SIG_DFL);
+ signal(SIGQUIT, SIG_DFL);
+ signal(SIGTERM, SIG_DFL);
+ signal(SIGTSTP, SIG_DFL);
+ signal(SIGTTIN, SIG_DFL);
+ signal(SIGTTOU, SIG_DFL);
+ signal(SIGCHLD, SIG_DFL);
+
+ close_all();
+
+ if (nextin != 0) {
+ dup2(nextin, 0);
+ close(nextin);
+ }
+ if (nextout != 1) {
+ dup2(nextout, 1);
+ close(nextout);
+ }
+ if (pipefds[0]!=-1) {
+ close(pipefds[0]); /* opposite end of our output pipe */
+ }
+
+ /* Like bash, explicit redirects override pipes,
+ * and the pipe fd is available for dup'ing. */
+ setup_redirects(child,NULL);
+
+ if (interactive && pi->followup!=PIPE_BG) {
+ /* If we (the child) win the race, put ourselves in the process
+ * group whose leader is the first process in this pipe. */
+ if (pi->pgrp < 0) {
+ pi->pgrp = getpid();
+ }
+ if (setpgid(0, pi->pgrp) == 0) {
+ tcsetpgrp(2, pi->pgrp);
+ }
+ }
+
+ pseudo_exec(child);
+ }
+
+
+ /* put our child in the process group whose leader is the
+ first process in this pipe */
+ if (pi->pgrp < 0) {
+ pi->pgrp = child->pid;
+ }
+ /* Don't check for errors. The child may be dead already,
+ * in which case setpgid returns error code EACCES. */
+ setpgid(child->pid, pi->pgrp);
+
+ if (nextin != 0)
+ close(nextin);
+ if (nextout != 1)
+ close(nextout);
+
+ /* If there isn't another process, nextin is garbage
+ but it doesn't matter */
+ nextin = pipefds[0];
+ }
+ return -1;
+}
+
+static int run_list_real(struct pipe *pi)
+{
+ char *save_name = NULL;
+ char **list = NULL;
+ char **save_list = NULL;
+ struct pipe *rpipe;
+ int flag_rep = 0;
+ int save_num_progs;
+ int rcode=0, flag_skip=1;
+ int flag_restore = 0;
+ int if_code=0, next_if_code=0; /* need double-buffer to handle elif */
+ reserved_style rmode, skip_more_in_this_rmode=RES_XXXX;
+ /* check syntax for "for" */
+ for (rpipe = pi; rpipe; rpipe = rpipe->next) {
+ if ((rpipe->r_mode == RES_IN ||
+ rpipe->r_mode == RES_FOR) &&
+ (rpipe->next == NULL)) {
+ syntax();
+ return 1;
+ }
+ if ((rpipe->r_mode == RES_IN &&
+ (rpipe->next->r_mode == RES_IN &&
+ rpipe->next->progs->argv != NULL))||
+ (rpipe->r_mode == RES_FOR &&
+ rpipe->next->r_mode != RES_IN)) {
+ syntax();
+ return 1;
+ }
+ }
+ for (; pi; pi = (flag_restore != 0) ? rpipe : pi->next) {
+ if (pi->r_mode == RES_WHILE || pi->r_mode == RES_UNTIL ||
+ pi->r_mode == RES_FOR) {
+ flag_restore = 0;
+ if (!rpipe) {
+ flag_rep = 0;
+ rpipe = pi;
+ }
+ }
+ rmode = pi->r_mode;
+ debug_printf("rmode=%d if_code=%d next_if_code=%d skip_more=%d\n", rmode, if_code, next_if_code, skip_more_in_this_rmode);
+ if (rmode == skip_more_in_this_rmode && flag_skip) {
+ if (pi->followup == PIPE_SEQ) flag_skip=0;
+ continue;
+ }
+ flag_skip = 1;
+ skip_more_in_this_rmode = RES_XXXX;
+ if (rmode == RES_THEN || rmode == RES_ELSE) if_code = next_if_code;
+ if (rmode == RES_THEN && if_code) continue;
+ if (rmode == RES_ELSE && !if_code) continue;
+ if (rmode == RES_ELIF && !if_code) continue;
+ if (rmode == RES_FOR && pi->num_progs) {
+ if (!list) {
+ /* if no variable values after "in" we skip "for" */
+ if (!pi->next->progs->argv) continue;
+ /* create list of variable values */
+ list = make_list_in(pi->next->progs->argv,
+ pi->progs->argv[0]);
+ save_list = list;
+ save_name = pi->progs->argv[0];
+ pi->progs->argv[0] = NULL;
+ flag_rep = 1;
+ }
+ if (!(*list)) {
+ free(pi->progs->argv[0]);
+ free(save_list);
+ list = NULL;
+ flag_rep = 0;
+ pi->progs->argv[0] = save_name;
+ pi->progs->glob_result.gl_pathv[0] =
+ pi->progs->argv[0];
+ continue;
+ } else {
+ /* insert new value from list for variable */
+ if (pi->progs->argv[0])
+ free(pi->progs->argv[0]);
+ pi->progs->argv[0] = *list++;
+ pi->progs->glob_result.gl_pathv[0] =
+ pi->progs->argv[0];
+ }
+ }
+ if (rmode == RES_IN) continue;
+ if (rmode == RES_DO) {
+ if (!flag_rep) continue;
+ }
+ if ((rmode == RES_DONE)) {
+ if (flag_rep) {
+ flag_restore = 1;
+ } else {
+ rpipe = NULL;
+ }
+ }
+ if (pi->num_progs == 0) continue;
+ save_num_progs = pi->num_progs; /* save number of programs */
+ rcode = run_pipe_real(pi);
+ debug_printf("run_pipe_real returned %d\n",rcode);
+ if (rcode!=-1) {
+ /* We only ran a builtin: rcode was set by the return value
+ * of run_pipe_real(), and we don't need to wait for anything. */
+ } else if (pi->followup==PIPE_BG) {
+ /* XXX check bash's behavior with nontrivial pipes */
+ /* XXX compute jobid */
+ /* XXX what does bash do with attempts to background builtins? */
+ insert_bg_job(pi);
+ rcode = EXIT_SUCCESS;
+ } else {
+ if (interactive) {
+ /* move the new process group into the foreground */
+ if (tcsetpgrp(shell_terminal, pi->pgrp) && errno != ENOTTY)
+ bb_perror_msg("tcsetpgrp-3");
+ rcode = checkjobs(pi);
+ /* move the shell to the foreground */
+ if (tcsetpgrp(shell_terminal, getpgid(0)) && errno != ENOTTY)
+ bb_perror_msg("tcsetpgrp-4");
+ } else {
+ rcode = checkjobs(pi);
+ }
+ debug_printf("checkjobs returned %d\n",rcode);
+ }
+ last_return_code=rcode;
+ pi->num_progs = save_num_progs; /* restore number of programs */
+ if ( rmode == RES_IF || rmode == RES_ELIF )
+ next_if_code=rcode; /* can be overwritten a number of times */
+ if (rmode == RES_WHILE)
+ flag_rep = !last_return_code;
+ if (rmode == RES_UNTIL)
+ flag_rep = last_return_code;
+ if ( (rcode==EXIT_SUCCESS && pi->followup==PIPE_OR) ||
+ (rcode!=EXIT_SUCCESS && pi->followup==PIPE_AND) )
+ skip_more_in_this_rmode=rmode;
+ checkjobs(NULL);
+ }
+ return rcode;
+}
+
+/* broken, of course, but OK for testing */
+static char *indenter(int i)
+{
+ static char blanks[]=" ";
+ return &blanks[sizeof(blanks)-i-1];
+}
+
+/* return code is the exit status of the pipe */
+static int free_pipe(struct pipe *pi, int indent)
+{
+ char **p;
+ struct child_prog *child;
+ struct redir_struct *r, *rnext;
+ int a, i, ret_code=0;
+ char *ind = indenter(indent);
+
+ if (pi->stopped_progs > 0)
+ return ret_code;
+ final_printf("%s run pipe: (pid %d)\n",ind,getpid());
+ for (i=0; i<pi->num_progs; i++) {
+ child = &pi->progs[i];
+ final_printf("%s command %d:\n",ind,i);
+ if (child->argv) {
+ for (a=0,p=child->argv; *p; a++,p++) {
+ final_printf("%s argv[%d] = %s\n",ind,a,*p);
+ }
+ globfree(&child->glob_result);
+ child->argv=NULL;
+ } else if (child->group) {
+ final_printf("%s begin group (subshell:%d)\n",ind, child->subshell);
+ ret_code = free_pipe_list(child->group,indent+3);
+ final_printf("%s end group\n",ind);
+ } else {
+ final_printf("%s (nil)\n",ind);
+ }
+ for (r=child->redirects; r; r=rnext) {
+ final_printf("%s redirect %d%s", ind, r->fd, redir_table[r->type].descrip);
+ if (r->dup == -1) {
+ /* guard against the case >$FOO, where foo is unset or blank */
+ if (r->word.gl_pathv) {
+ final_printf(" %s\n", *r->word.gl_pathv);
+ globfree(&r->word);
+ }
+ } else {
+ final_printf("&%d\n", r->dup);
+ }
+ rnext=r->next;
+ free(r);
+ }
+ child->redirects=NULL;
+ }
+ free(pi->progs); /* children are an array, they get freed all at once */
+ pi->progs=NULL;
+ return ret_code;
+}
+
+static int free_pipe_list(struct pipe *head, int indent)
+{
+ int rcode=0; /* if list has no members */
+ struct pipe *pi, *next;
+ char *ind = indenter(indent);
+ for (pi=head; pi; pi=next) {
+ final_printf("%s pipe reserved mode %d\n", ind, pi->r_mode);
+ rcode = free_pipe(pi, indent);
+ final_printf("%s pipe followup code %d\n", ind, pi->followup);
+ next=pi->next;
+ pi->next=NULL;
+ free(pi);
+ }
+ return rcode;
+}
+
+/* Select which version we will use */
+static int run_list(struct pipe *pi)
+{
+ int rcode=0;
+ if (fake_mode==0) {
+ rcode = run_list_real(pi);
+ }
+ /* free_pipe_list has the side effect of clearing memory
+ * In the long run that function can be merged with run_list_real,
+ * but doing that now would hobble the debugging effort. */
+ free_pipe_list(pi,0);
+ return rcode;
+}
+
+/* The API for glob is arguably broken. This routine pushes a non-matching
+ * string into the output structure, removing non-backslashed backslashes.
+ * If someone can prove me wrong, by performing this function within the
+ * original glob(3) api, feel free to rewrite this routine into oblivion.
+ * Return code (0 vs. GLOB_NOSPACE) matches glob(3).
+ * XXX broken if the last character is '\\', check that before calling.
+ */
+static int globhack(const char *src, int flags, glob_t *pglob)
+{
+ int cnt=0, pathc;
+ const char *s;
+ char *dest;
+ for (cnt=1, s=src; s && *s; s++) {
+ if (*s == '\\') s++;
+ cnt++;
+ }
+ dest = malloc(cnt);
+ if (!dest) return GLOB_NOSPACE;
+ if (!(flags & GLOB_APPEND)) {
+ pglob->gl_pathv=NULL;
+ pglob->gl_pathc=0;
+ pglob->gl_offs=0;
+ pglob->gl_offs=0;
+ }
+ pathc = ++pglob->gl_pathc;
+ pglob->gl_pathv = realloc(pglob->gl_pathv, (pathc+1)*sizeof(*pglob->gl_pathv));
+ if (pglob->gl_pathv == NULL) return GLOB_NOSPACE;
+ pglob->gl_pathv[pathc-1]=dest;
+ pglob->gl_pathv[pathc]=NULL;
+ for (s=src; s && *s; s++, dest++) {
+ if (*s == '\\') s++;
+ *dest = *s;
+ }
+ *dest='\0';
+ return 0;
+}
+
+/* XXX broken if the last character is '\\', check that before calling */
+static int glob_needed(const char *s)
+{
+ for (; *s; s++) {
+ if (*s == '\\') s++;
+ if (strchr("*[?",*s)) return 1;
+ }
+ return 0;
+}
+
+#if 0
+static void globprint(glob_t *pglob)
+{
+ int i;
+ debug_printf("glob_t at %p:\n", pglob);
+ debug_printf(" gl_pathc=%d gl_pathv=%p gl_offs=%d gl_flags=%d\n",
+ pglob->gl_pathc, pglob->gl_pathv, pglob->gl_offs, pglob->gl_flags);
+ for (i=0; i<pglob->gl_pathc; i++)
+ debug_printf("pglob->gl_pathv[%d] = %p = %s\n", i,
+ pglob->gl_pathv[i], pglob->gl_pathv[i]);
+}
+#endif
+
+static int xglob(o_string *dest, int flags, glob_t *pglob)
+{
+ int gr;
+
+ /* short-circuit for null word */
+ /* we can code this better when the debug_printf's are gone */
+ if (dest->length == 0) {
+ if (dest->nonnull) {
+ /* bash man page calls this an "explicit" null */
+ gr = globhack(dest->data, flags, pglob);
+ debug_printf("globhack returned %d\n",gr);
+ } else {
+ return 0;
+ }
+ } else if (glob_needed(dest->data)) {
+ gr = glob(dest->data, flags, NULL, pglob);
+ debug_printf("glob returned %d\n",gr);
+ if (gr == GLOB_NOMATCH) {
+ /* quote removal, or more accurately, backslash removal */
+ gr = globhack(dest->data, flags, pglob);
+ debug_printf("globhack returned %d\n",gr);
+ }
+ } else {
+ gr = globhack(dest->data, flags, pglob);
+ debug_printf("globhack returned %d\n",gr);
+ }
+ if (gr == GLOB_NOSPACE)
+ bb_error_msg_and_die("out of memory during glob");
+ if (gr != 0) { /* GLOB_ABORTED ? */
+ bb_error_msg("glob(3) error %d",gr);
+ }
+ /* globprint(glob_target); */
+ return gr;
+}
+
+/* This is used to get/check local shell variables */
+static char *get_local_var(const char *s)
+{
+ struct variables *cur;
+
+ if (!s)
+ return NULL;
+ for (cur = top_vars; cur; cur=cur->next)
+ if(strcmp(cur->name, s)==0)
+ return cur->value;
+ return NULL;
+}
+
+/* This is used to set local shell variables
+ flg_export==0 if only local (not exporting) variable
+ flg_export==1 if "new" exporting environ
+ flg_export>1 if current startup environ (not call putenv()) */
+static int set_local_var(const char *s, int flg_export)
+{
+ char *name, *value;
+ int result=0;
+ struct variables *cur;
+
+ name=strdup(s);
+
+ /* Assume when we enter this function that we are already in
+ * NAME=VALUE format. So the first order of business is to
+ * split 's' on the '=' into 'name' and 'value' */
+ value = strchr(name, '=');
+ if (value==0 && ++value==0) {
+ free(name);
+ return -1;
+ }
+ *value++ = 0;
+
+ for(cur = top_vars; cur; cur = cur->next) {
+ if(strcmp(cur->name, name)==0)
+ break;
+ }
+
+ if(cur) {
+ if(strcmp(cur->value, value)==0) {
+ if(flg_export>0 && cur->flg_export==0)
+ cur->flg_export=flg_export;
+ else
+ result++;
+ } else {
+ if(cur->flg_read_only) {
+ bb_error_msg("%s: readonly variable", name);
+ result = -1;
+ } else {
+ if(flg_export>0 || cur->flg_export>1)
+ cur->flg_export=1;
+ free(cur->value);
+
+ cur->value = strdup(value);
+ }
+ }
+ } else {
+ cur = malloc(sizeof(struct variables));
+ if(!cur) {
+ result = -1;
+ } else {
+ cur->name = strdup(name);
+ if(cur->name == 0) {
+ free(cur);
+ result = -1;
+ } else {
+ struct variables *bottom = top_vars;
+ cur->value = strdup(value);
+ cur->next = 0;
+ cur->flg_export = flg_export;
+ cur->flg_read_only = 0;
+ while(bottom->next) bottom=bottom->next;
+ bottom->next = cur;
+ }
+ }
+ }
+
+ if(result==0 && cur->flg_export==1) {
+ *(value-1) = '=';
+ result = putenv(name);
+ } else {
+ free(name);
+ if(result>0) /* equivalent to previous set */
+ result = 0;
+ }
+ return result;
+}
+
+static void unset_local_var(const char *name)
+{
+ struct variables *cur;
+
+ if (name) {
+ for (cur = top_vars; cur; cur=cur->next) {
+ if(strcmp(cur->name, name)==0)
+ break;
+ }
+ if(cur!=0) {
+ struct variables *next = top_vars;
+ if(cur->flg_read_only) {
+ bb_error_msg("%s: readonly variable", name);
+ return;
+ } else {
+ if(cur->flg_export)
+ unsetenv(cur->name);
+ free(cur->name);
+ free(cur->value);
+ while (next->next != cur)
+ next = next->next;
+ next->next = cur->next;
+ }
+ free(cur);
+ }
+ }
+}
+
+static int is_assignment(const char *s)
+{
+ if (s==NULL || !isalpha(*s)) return 0;
+ ++s;
+ while(isalnum(*s) || *s=='_') ++s;
+ return *s=='=';
+}
+
+/* the src parameter allows us to peek forward to a possible &n syntax
+ * for file descriptor duplication, e.g., "2>&1".
+ * Return code is 0 normally, 1 if a syntax error is detected in src.
+ * Resource errors (in xmalloc) cause the process to exit */
+static int setup_redirect(struct p_context *ctx, int fd, redir_type style,
+ struct in_str *input)
+{
+ struct child_prog *child=ctx->child;
+ struct redir_struct *redir = child->redirects;
+ struct redir_struct *last_redir=NULL;
+
+ /* Create a new redir_struct and drop it onto the end of the linked list */
+ while(redir) {
+ last_redir=redir;
+ redir=redir->next;
+ }
+ redir = xmalloc(sizeof(struct redir_struct));
+ redir->next=NULL;
+ redir->word.gl_pathv=NULL;
+ if (last_redir) {
+ last_redir->next=redir;
+ } else {
+ child->redirects=redir;
+ }
+
+ redir->type=style;
+ redir->fd= (fd==-1) ? redir_table[style].default_fd : fd ;
+
+ debug_printf("Redirect type %d%s\n", redir->fd, redir_table[style].descrip);
+
+ /* Check for a '2>&1' type redirect */
+ redir->dup = redirect_dup_num(input);
+ if (redir->dup == -2) return 1; /* syntax error */
+ if (redir->dup != -1) {
+ /* Erik had a check here that the file descriptor in question
+ * is legit; I postpone that to "run time"
+ * A "-" representation of "close me" shows up as a -3 here */
+ debug_printf("Duplicating redirect '%d>&%d'\n", redir->fd, redir->dup);
+ } else {
+ /* We do _not_ try to open the file that src points to,
+ * since we need to return and let src be expanded first.
+ * Set ctx->pending_redirect, so we know what to do at the
+ * end of the next parsed word.
+ */
+ ctx->pending_redirect = redir;
+ }
+ return 0;
+}
+
+struct pipe *new_pipe(void) {
+ struct pipe *pi;
+ pi = xmalloc(sizeof(struct pipe));
+ pi->num_progs = 0;
+ pi->progs = NULL;
+ pi->next = NULL;
+ pi->followup = 0; /* invalid */
+ return pi;
+}
+
+static void initialize_context(struct p_context *ctx)
+{
+ ctx->pipe=NULL;
+ ctx->pending_redirect=NULL;
+ ctx->child=NULL;
+ ctx->list_head=new_pipe();
+ ctx->pipe=ctx->list_head;
+ ctx->w=RES_NONE;
+ ctx->stack=NULL;
+ ctx->old_flag=0;
+ done_command(ctx); /* creates the memory for working child */
+}
+
+/* normal return is 0
+ * if a reserved word is found, and processed, return 1
+ * should handle if, then, elif, else, fi, for, while, until, do, done.
+ * case, function, and select are obnoxious, save those for later.
+ */
+int reserved_word(o_string *dest, struct p_context *ctx)
+{
+ struct reserved_combo {
+ char *literal;
+ int code;
+ long flag;
+ };
+ /* Mostly a list of accepted follow-up reserved words.
+ * FLAG_END means we are done with the sequence, and are ready
+ * to turn the compound list into a command.
+ * FLAG_START means the word must start a new compound list.
+ */
+ static struct reserved_combo reserved_list[] = {
+ { "if", RES_IF, FLAG_THEN | FLAG_START },
+ { "then", RES_THEN, FLAG_ELIF | FLAG_ELSE | FLAG_FI },
+ { "elif", RES_ELIF, FLAG_THEN },
+ { "else", RES_ELSE, FLAG_FI },
+ { "fi", RES_FI, FLAG_END },
+ { "for", RES_FOR, FLAG_IN | FLAG_START },
+ { "while", RES_WHILE, FLAG_DO | FLAG_START },
+ { "until", RES_UNTIL, FLAG_DO | FLAG_START },
+ { "in", RES_IN, FLAG_DO },
+ { "do", RES_DO, FLAG_DONE },
+ { "done", RES_DONE, FLAG_END }
+ };
+ struct reserved_combo *r;
+ for (r=reserved_list;
+#define NRES sizeof(reserved_list)/sizeof(struct reserved_combo)
+ r<reserved_list+NRES; r++) {
+ if (strcmp(dest->data, r->literal) == 0) {
+ debug_printf("found reserved word %s, code %d\n",r->literal,r->code);
+ if (r->flag & FLAG_START) {
+ struct p_context *new = xmalloc(sizeof(struct p_context));
+ debug_printf("push stack\n");
+ if (ctx->w == RES_IN || ctx->w == RES_FOR) {
+ syntax();
+ free(new);
+ ctx->w = RES_SNTX;
+ b_reset(dest);
+ return 1;
+ }
+ *new = *ctx; /* physical copy */
+ initialize_context(ctx);
+ ctx->stack=new;
+ } else if ( ctx->w == RES_NONE || ! (ctx->old_flag & (1<<r->code))) {
+ syntax();
+ ctx->w = RES_SNTX;
+ b_reset(dest);
+ return 1;
+ }
+ ctx->w=r->code;
+ ctx->old_flag = r->flag;
+ if (ctx->old_flag & FLAG_END) {
+ struct p_context *old;
+ debug_printf("pop stack\n");
+ done_pipe(ctx,PIPE_SEQ);
+ old = ctx->stack;
+ old->child->group = ctx->list_head;
+ old->child->subshell = 0;
+ *ctx = *old; /* physical copy */
+ free(old);
+ }
+ b_reset (dest);
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/* normal return is 0.
+ * Syntax or xglob errors return 1. */
+static int done_word(o_string *dest, struct p_context *ctx)
+{
+ struct child_prog *child=ctx->child;
+ glob_t *glob_target;
+ int gr, flags = 0;
+
+ debug_printf("done_word: %s %p\n", dest->data, child);
+ if (dest->length == 0 && !dest->nonnull) {
+ debug_printf(" true null, ignored\n");
+ return 0;
+ }
+ if (ctx->pending_redirect) {
+ glob_target = &ctx->pending_redirect->word;
+ } else {
+ if (child->group) {
+ syntax();
+ return 1; /* syntax error, groups and arglists don't mix */
+ }
+ if (!child->argv && (ctx->type & FLAG_PARSE_SEMICOLON)) {
+ debug_printf("checking %s for reserved-ness\n",dest->data);
+ if (reserved_word(dest,ctx)) return ctx->w==RES_SNTX;
+ }
+ glob_target = &child->glob_result;
+ if (child->argv) flags |= GLOB_APPEND;
+ }
+ gr = xglob(dest, flags, glob_target);
+ if (gr != 0) return 1;
+
+ b_reset(dest);
+ if (ctx->pending_redirect) {
+ ctx->pending_redirect=NULL;
+ if (glob_target->gl_pathc != 1) {
+ bb_error_msg("ambiguous redirect");
+ return 1;
+ }
+ } else {
+ child->argv = glob_target->gl_pathv;
+ }
+ if (ctx->w == RES_FOR) {
+ done_word(dest,ctx);
+ done_pipe(ctx,PIPE_SEQ);
+ }
+ return 0;
+}
+
+/* The only possible error here is out of memory, in which case
+ * xmalloc exits. */
+static int done_command(struct p_context *ctx)
+{
+ /* The child is really already in the pipe structure, so
+ * advance the pipe counter and make a new, null child.
+ * Only real trickiness here is that the uncommitted
+ * child structure, to which ctx->child points, is not
+ * counted in pi->num_progs. */
+ struct pipe *pi=ctx->pipe;
+ struct child_prog *prog=ctx->child;
+
+ if (prog && prog->group == NULL
+ && prog->argv == NULL
+ && prog->redirects == NULL) {
+ debug_printf("done_command: skipping null command\n");
+ return 0;
+ } else if (prog) {
+ pi->num_progs++;
+ debug_printf("done_command: num_progs incremented to %d\n",pi->num_progs);
+ } else {
+ debug_printf("done_command: initializing\n");
+ }
+ pi->progs = xrealloc(pi->progs, sizeof(*pi->progs) * (pi->num_progs+1));
+
+ prog = pi->progs + pi->num_progs;
+ prog->redirects = NULL;
+ prog->argv = NULL;
+ prog->is_stopped = 0;
+ prog->group = NULL;
+ prog->glob_result.gl_pathv = NULL;
+ prog->family = pi;
+ prog->sp = 0;
+ ctx->child = prog;
+ prog->type = ctx->type;
+
+ /* but ctx->pipe and ctx->list_head remain unchanged */
+ return 0;
+}
+
+static int done_pipe(struct p_context *ctx, pipe_style type)
+{
+ struct pipe *new_p;
+ done_command(ctx); /* implicit closure of previous command */
+ debug_printf("done_pipe, type %d\n", type);
+ ctx->pipe->followup = type;
+ ctx->pipe->r_mode = ctx->w;
+ new_p=new_pipe();
+ ctx->pipe->next = new_p;
+ ctx->pipe = new_p;
+ ctx->child = NULL;
+ done_command(ctx); /* set up new pipe to accept commands */
+ return 0;
+}
+
+/* peek ahead in the in_str to find out if we have a "&n" construct,
+ * as in "2>&1", that represents duplicating a file descriptor.
+ * returns either -2 (syntax error), -1 (no &), or the number found.
+ */
+static int redirect_dup_num(struct in_str *input)
+{
+ int ch, d=0, ok=0;
+ ch = b_peek(input);
+ if (ch != '&') return -1;
+
+ b_getch(input); /* get the & */
+ ch=b_peek(input);
+ if (ch == '-') {
+ b_getch(input);
+ return -3; /* "-" represents "close me" */
+ }
+ while (isdigit(ch)) {
+ d = d*10+(ch-'0');
+ ok=1;
+ b_getch(input);
+ ch = b_peek(input);
+ }
+ if (ok) return d;
+
+ bb_error_msg("ambiguous redirect");
+ return -2;
+}
+
+/* If a redirect is immediately preceded by a number, that number is
+ * supposed to tell which file descriptor to redirect. This routine
+ * looks for such preceding numbers. In an ideal world this routine
+ * needs to handle all the following classes of redirects...
+ * echo 2>foo # redirects fd 2 to file "foo", nothing passed to echo
+ * echo 49>foo # redirects fd 49 to file "foo", nothing passed to echo
+ * echo -2>foo # redirects fd 1 to file "foo", "-2" passed to echo
+ * echo 49x>foo # redirects fd 1 to file "foo", "49x" passed to echo
+ * A -1 output from this program means no valid number was found, so the
+ * caller should use the appropriate default for this redirection.
+ */
+static int redirect_opt_num(o_string *o)
+{
+ int num;
+
+ if (o->length==0) return -1;
+ for(num=0; num<o->length; num++) {
+ if (!isdigit(*(o->data+num))) {
+ return -1;
+ }
+ }
+ /* reuse num (and save an int) */
+ num=atoi(o->data);
+ b_reset(o);
+ return num;
+}
+
+FILE *generate_stream_from_list(struct pipe *head)
+{
+ FILE *pf;
+#if 1
+ int pid, channel[2];
+ if (pipe(channel)<0) bb_perror_msg_and_die("pipe");
+#if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__)
+ pid=fork();
+#else
+ pid=vfork();
+#endif
+ if (pid<0) {
+ bb_perror_msg_and_die("fork");
+ } else if (pid==0) {
+ close(channel[0]);
+ if (channel[1] != 1) {
+ dup2(channel[1],1);
+ close(channel[1]);
+ }
+#if 0
+#define SURROGATE "surrogate response"
+ write(1,SURROGATE,sizeof(SURROGATE));
+ _exit(run_list(head));
+#else
+ _exit(run_list_real(head)); /* leaks memory */
+#endif
+ }
+ debug_printf("forked child %d\n",pid);
+ close(channel[1]);
+ pf = fdopen(channel[0],"r");
+ debug_printf("pipe on FILE *%p\n",pf);
+#else
+ free_pipe_list(head,0);
+ pf=popen("echo surrogate response","r");
+ debug_printf("started fake pipe on FILE *%p\n",pf);
+#endif
+ return pf;
+}
+
+/* this version hacked for testing purposes */
+/* return code is exit status of the process that is run. */
+static int process_command_subs(o_string *dest, struct p_context *ctx, struct in_str *input, int subst_end)
+{
+ int retcode;
+ o_string result=NULL_O_STRING;
+ struct p_context inner;
+ FILE *p;
+ struct in_str pipe_str;
+ initialize_context(&inner);
+
+ /* recursion to generate command */
+ retcode = parse_stream(&result, &inner, input, subst_end);
+ if (retcode != 0) return retcode; /* syntax error or EOF */
+ done_word(&result, &inner);
+ done_pipe(&inner, PIPE_SEQ);
+ b_free(&result);
+
+ p=generate_stream_from_list(inner.list_head);
+ if (p==NULL) return 1;
+ mark_open(fileno(p));
+ setup_file_in_str(&pipe_str, p);
+
+ /* now send results of command back into original context */
+ retcode = parse_stream(dest, ctx, &pipe_str, '\0');
+ /* XXX In case of a syntax error, should we try to kill the child?
+ * That would be tough to do right, so just read until EOF. */
+ if (retcode == 1) {
+ while (b_getch(&pipe_str)!=EOF) { /* discard */ };
+ }
+
+ debug_printf("done reading from pipe, pclose()ing\n");
+ /* This is the step that wait()s for the child. Should be pretty
+ * safe, since we just read an EOF from its stdout. We could try
+ * to better, by using wait(), and keeping track of background jobs
+ * at the same time. That would be a lot of work, and contrary
+ * to the KISS philosophy of this program. */
+ mark_closed(fileno(p));
+ retcode=pclose(p);
+ free_pipe_list(inner.list_head,0);
+ debug_printf("pclosed, retcode=%d\n",retcode);
+ /* XXX this process fails to trim a single trailing newline */
+ return retcode;
+}
+
+static int parse_group(o_string *dest, struct p_context *ctx,
+ struct in_str *input, int ch)
+{
+ int rcode, endch=0;
+ struct p_context sub;
+ struct child_prog *child = ctx->child;
+ if (child->argv) {
+ syntax();
+ return 1; /* syntax error, groups and arglists don't mix */
+ }
+ initialize_context(&sub);
+ switch(ch) {
+ case '(': endch=')'; child->subshell=1; break;
+ case '{': endch='}'; break;
+ default: syntax(); /* really logic error */
+ }
+ rcode=parse_stream(dest,&sub,input,endch);
+ done_word(dest,&sub); /* finish off the final word in the subcontext */
+ done_pipe(&sub, PIPE_SEQ); /* and the final command there, too */
+ child->group = sub.list_head;
+ return rcode;
+ /* child remains "open", available for possible redirects */
+}
+
+/* basically useful version until someone wants to get fancier,
+ * see the bash man page under "Parameter Expansion" */
+static char *lookup_param(char *src)
+{
+ char *p=NULL;
+ if (src) {
+ p = getenv(src);
+ if (!p)
+ p = get_local_var(src);
+ }
+ return p;
+}
+
+/* return code: 0 for OK, 1 for syntax error */
+static int handle_dollar(o_string *dest, struct p_context *ctx, struct in_str *input)
+{
+ int i, advance=0;
+ char sep[]=" ";
+ int ch = input->peek(input); /* first character after the $ */
+ debug_printf("handle_dollar: ch=%c\n",ch);
+ if (isalpha(ch)) {
+ b_addchr(dest, SPECIAL_VAR_SYMBOL);
+ ctx->child->sp++;
+ while(ch=b_peek(input),isalnum(ch) || ch=='_') {
+ b_getch(input);
+ b_addchr(dest,ch);
+ }
+ b_addchr(dest, SPECIAL_VAR_SYMBOL);
+ } else if (isdigit(ch)) {
+ i = ch-'0'; /* XXX is $0 special? */
+ if (i<global_argc) {
+ parse_string(dest, ctx, global_argv[i]); /* recursion */
+ }
+ advance = 1;
+ } else switch (ch) {
+ case '$':
+ b_adduint(dest,getpid());
+ advance = 1;
+ break;
+ case '!':
+ if (last_bg_pid > 0) b_adduint(dest, last_bg_pid);
+ advance = 1;
+ break;
+ case '?':
+ b_adduint(dest,last_return_code);
+ advance = 1;
+ break;
+ case '#':
+ b_adduint(dest,global_argc ? global_argc-1 : 0);
+ advance = 1;
+ break;
+ case '{':
+ b_addchr(dest, SPECIAL_VAR_SYMBOL);
+ ctx->child->sp++;
+ b_getch(input);
+ /* XXX maybe someone will try to escape the '}' */
+ while(ch=b_getch(input),ch!=EOF && ch!='}') {
+ b_addchr(dest,ch);
+ }
+ if (ch != '}') {
+ syntax();
+ return 1;
+ }
+ b_addchr(dest, SPECIAL_VAR_SYMBOL);
+ break;
+ case '(':
+ b_getch(input);
+ process_command_subs(dest, ctx, input, ')');
+ break;
+ case '*':
+ sep[0]=ifs[0];
+ for (i=1; i<global_argc; i++) {
+ parse_string(dest, ctx, global_argv[i]);
+ if (i+1 < global_argc) parse_string(dest, ctx, sep);
+ }
+ break;
+ case '@':
+ case '-':
+ case '_':
+ /* still unhandled, but should be eventually */
+ bb_error_msg("unhandled syntax: $%c",ch);
+ return 1;
+ break;
+ default:
+ b_addqchr(dest,'$',dest->quote);
+ }
+ /* Eat the character if the flag was set. If the compiler
+ * is smart enough, we could substitute "b_getch(input);"
+ * for all the "advance = 1;" above, and also end up with
+ * a nice size-optimized program. Hah! That'll be the day.
+ */
+ if (advance) b_getch(input);
+ return 0;
+}
+
+int parse_string(o_string *dest, struct p_context *ctx, const char *src)
+{
+ struct in_str foo;
+ setup_string_in_str(&foo, src);
+ return parse_stream(dest, ctx, &foo, '\0');
+}
+
+/* return code is 0 for normal exit, 1 for syntax error */
+int parse_stream(o_string *dest, struct p_context *ctx,
+ struct in_str *input, int end_trigger)
+{
+ unsigned int ch, m;
+ int redir_fd;
+ redir_type redir_style;
+ int next;
+
+ /* Only double-quote state is handled in the state variable dest->quote.
+ * A single-quote triggers a bypass of the main loop until its mate is
+ * found. When recursing, quote state is passed in via dest->quote. */
+
+ debug_printf("parse_stream, end_trigger=%d\n",end_trigger);
+ while ((ch=b_getch(input))!=EOF) {
+ m = map[ch];
+ next = (ch == '\n') ? 0 : b_peek(input);
+ debug_printf("parse_stream: ch=%c (%d) m=%d quote=%d\n",
+ ch,ch,m,dest->quote);
+ if (m==0 || ((m==1 || m==2) && dest->quote)) {
+ b_addqchr(dest, ch, dest->quote);
+ } else {
+ if (m==2) { /* unquoted IFS */
+ if (done_word(dest, ctx)) {
+ return 1;
+ }
+ /* If we aren't performing a substitution, treat a newline as a
+ * command separator. */
+ if (end_trigger != '\0' && ch=='\n')
+ done_pipe(ctx,PIPE_SEQ);
+ }
+ if (ch == end_trigger && !dest->quote && ctx->w==RES_NONE) {
+ debug_printf("leaving parse_stream (triggered)\n");
+ return 0;
+ }
+#if 0
+ if (ch=='\n') {
+ /* Yahoo! Time to run with it! */
+ done_pipe(ctx,PIPE_SEQ);
+ run_list(ctx->list_head);
+ initialize_context(ctx);
+ }
+#endif
+ if (m!=2) switch (ch) {
+ case '#':
+ if (dest->length == 0 && !dest->quote) {
+ while(ch=b_peek(input),ch!=EOF && ch!='\n') { b_getch(input); }
+ } else {
+ b_addqchr(dest, ch, dest->quote);
+ }
+ break;
+ case '\\':
+ if (next == EOF) {
+ syntax();
+ return 1;
+ }
+ b_addqchr(dest, '\\', dest->quote);
+ b_addqchr(dest, b_getch(input), dest->quote);
+ break;
+ case '$':
+ if (handle_dollar(dest, ctx, input)!=0) return 1;
+ break;
+ case '\'':
+ dest->nonnull = 1;
+ while(ch=b_getch(input),ch!=EOF && ch!='\'') {
+ b_addchr(dest,ch);
+ }
+ if (ch==EOF) {
+ syntax();
+ return 1;
+ }
+ break;
+ case '"':
+ dest->nonnull = 1;
+ dest->quote = !dest->quote;
+ break;
+ case '`':
+ process_command_subs(dest, ctx, input, '`');
+ break;
+ case '>':
+ redir_fd = redirect_opt_num(dest);
+ done_word(dest, ctx);
+ redir_style=REDIRECT_OVERWRITE;
+ if (next == '>') {
+ redir_style=REDIRECT_APPEND;
+ b_getch(input);
+ } else if (next == '(') {
+ syntax(); /* until we support >(list) Process Substitution */
+ return 1;
+ }
+ setup_redirect(ctx, redir_fd, redir_style, input);
+ break;
+ case '<':
+ redir_fd = redirect_opt_num(dest);
+ done_word(dest, ctx);
+ redir_style=REDIRECT_INPUT;
+ if (next == '<') {
+ redir_style=REDIRECT_HEREIS;
+ b_getch(input);
+ } else if (next == '>') {
+ redir_style=REDIRECT_IO;
+ b_getch(input);
+ } else if (next == '(') {
+ syntax(); /* until we support <(list) Process Substitution */
+ return 1;
+ }
+ setup_redirect(ctx, redir_fd, redir_style, input);
+ break;
+ case ';':
+ done_word(dest, ctx);
+ done_pipe(ctx,PIPE_SEQ);
+ break;
+ case '&':
+ done_word(dest, ctx);
+ if (next=='&') {
+ b_getch(input);
+ done_pipe(ctx,PIPE_AND);
+ } else {
+ done_pipe(ctx,PIPE_BG);
+ }
+ break;
+ case '|':
+ done_word(dest, ctx);
+ if (next=='|') {
+ b_getch(input);
+ done_pipe(ctx,PIPE_OR);
+ } else {
+ /* we could pick up a file descriptor choice here
+ * with redirect_opt_num(), but bash doesn't do it.
+ * "echo foo 2| cat" yields "foo 2". */
+ done_command(ctx);
+ }
+ break;
+ case '(':
+ case '{':
+ if (parse_group(dest, ctx, input, ch)!=0) return 1;
+ break;
+ case ')':
+ case '}':
+ syntax(); /* Proper use of this character caught by end_trigger */
+ return 1;
+ break;
+ default:
+ syntax(); /* this is really an internal logic error */
+ return 1;
+ }
+ }
+ }
+ /* complain if quote? No, maybe we just finished a command substitution
+ * that was quoted. Example:
+ * $ echo "`cat foo` plus more"
+ * and we just got the EOF generated by the subshell that ran "cat foo"
+ * The only real complaint is if we got an EOF when end_trigger != '\0',
+ * that is, we were really supposed to get end_trigger, and never got
+ * one before the EOF. Can't use the standard "syntax error" return code,
+ * so that parse_stream_outer can distinguish the EOF and exit smoothly. */
+ debug_printf("leaving parse_stream (EOF)\n");
+ if (end_trigger != '\0') return -1;
+ return 0;
+}
+
+void mapset(const unsigned char *set, int code)
+{
+ const unsigned char *s;
+ for (s=set; *s; s++) map[*s] = code;
+}
+
+void update_ifs_map(void)
+{
+ /* char *ifs and char map[256] are both globals. */
+ ifs = getenv("IFS");
+ if (ifs == NULL) ifs=" \t\n";
+ /* Precompute a list of 'flow through' behavior so it can be treated
+ * quickly up front. Computation is necessary because of IFS.
+ * Special case handling of IFS == " \t\n" is not implemented.
+ * The map[] array only really needs two bits each, and on most machines
+ * that would be faster because of the reduced L1 cache footprint.
+ */
+ memset(map,0,sizeof(map)); /* most characters flow through always */
+ mapset("\\$'\"`", 3); /* never flow through */
+ mapset("<>;&|(){}#", 1); /* flow through if quoted */
+ mapset(ifs, 2); /* also flow through if quoted */
+}
+
+/* most recursion does not come through here, the exeception is
+ * from builtin_source() */
+int parse_stream_outer(struct in_str *inp, int flag)
+{
+
+ struct p_context ctx;
+ o_string temp=NULL_O_STRING;
+ int rcode;
+ do {
+ ctx.type = flag;
+ initialize_context(&ctx);
+ update_ifs_map();
+ if (!(flag & FLAG_PARSE_SEMICOLON) || (flag & FLAG_REPARSING)) mapset(";$&|", 0);
+ inp->promptmode=1;
+ rcode = parse_stream(&temp, &ctx, inp, '\n');
+ if (rcode != 1 && ctx.old_flag != 0) {
+ syntax();
+ }
+ if (rcode != 1 && ctx.old_flag == 0) {
+ done_word(&temp, &ctx);
+ done_pipe(&ctx,PIPE_SEQ);
+ run_list(ctx.list_head);
+ } else {
+ if (ctx.old_flag != 0) {
+ free(ctx.stack);
+ b_reset(&temp);
+ }
+ temp.nonnull = 0;
+ temp.quote = 0;
+ inp->p = NULL;
+ free_pipe_list(ctx.list_head,0);
+ }
+ b_free(&temp);
+ } while (rcode != -1 && !(flag & FLAG_EXIT_FROM_LOOP)); /* loop on syntax errors, return on EOF */
+ return 0;
+}
+
+static int parse_string_outer(const char *s, int flag)
+{
+ struct in_str input;
+ setup_string_in_str(&input, s);
+ return parse_stream_outer(&input, flag);
+}
+
+static int parse_file_outer(FILE *f)
+{
+ int rcode;
+ struct in_str input;
+ setup_file_in_str(&input, f);
+ rcode = parse_stream_outer(&input, FLAG_PARSE_SEMICOLON);
+ return rcode;
+}
+
+/* Make sure we have a controlling tty. If we get started under a job
+ * aware app (like bash for example), make sure we are now in charge so
+ * we don't fight over who gets the foreground */
+static void setup_job_control(void)
+{
+ static pid_t shell_pgrp;
+ /* Loop until we are in the foreground. */
+ while (tcgetpgrp (shell_terminal) != (shell_pgrp = getpgrp ()))
+ kill (- shell_pgrp, SIGTTIN);
+
+ /* Ignore interactive and job-control signals. */
+ signal(SIGINT, SIG_IGN);
+ signal(SIGQUIT, SIG_IGN);
+ signal(SIGTERM, SIG_IGN);
+ signal(SIGTSTP, SIG_IGN);
+ signal(SIGTTIN, SIG_IGN);
+ signal(SIGTTOU, SIG_IGN);
+ signal(SIGCHLD, SIG_IGN);
+
+ /* Put ourselves in our own process group. */
+ setsid();
+ shell_pgrp = getpid ();
+ setpgid (shell_pgrp, shell_pgrp);
+
+ /* Grab control of the terminal. */
+ tcsetpgrp(shell_terminal, shell_pgrp);
+}
+
+int hush_main(int argc, char **argv)
+{
+ int opt;
+ FILE *input;
+ char **e = environ;
+
+ /* XXX what should these be while sourcing /etc/profile? */
+ global_argc = argc;
+ global_argv = argv;
+
+ /* (re?) initialize globals. Sometimes hush_main() ends up calling
+ * hush_main(), therefore we cannot rely on the BSS to zero out this
+ * stuff. Reset these to 0 every time. */
+ ifs = NULL;
+ /* map[] is taken care of with call to update_ifs_map() */
+ fake_mode = 0;
+ interactive = 0;
+ close_me_head = NULL;
+ last_bg_pid = 0;
+ job_list = NULL;
+ last_jobid = 0;
+
+ /* Initialize some more globals to non-zero values */
+ set_cwd();
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+ cmdedit_set_initial_prompt();
+#else
+ PS1 = NULL;
+#endif
+ PS2 = "> ";
+
+ /* initialize our shell local variables with the values
+ * currently living in the environment */
+ if (e) {
+ for (; *e; e++)
+ set_local_var(*e, 2); /* without call putenv() */
+ }
+
+ last_return_code=EXIT_SUCCESS;
+
+
+ if (argv[0] && argv[0][0] == '-') {
+ debug_printf("\nsourcing /etc/profile\n");
+ if ((input = fopen("/etc/profile", "r")) != NULL) {
+ mark_open(fileno(input));
+ parse_file_outer(input);
+ mark_closed(fileno(input));
+ fclose(input);
+ }
+ }
+ input=stdin;
+
+ while ((opt = getopt(argc, argv, "c:xif")) > 0) {
+ switch (opt) {
+ case 'c':
+ {
+ global_argv = argv+optind;
+ global_argc = argc-optind;
+ opt = parse_string_outer(optarg, FLAG_PARSE_SEMICOLON);
+ goto final_return;
+ }
+ break;
+ case 'i':
+ interactive++;
+ break;
+ case 'f':
+ fake_mode++;
+ break;
+ default:
+#ifndef BB_VER
+ fprintf(stderr, "Usage: sh [FILE]...\n"
+ " or: sh -c command [args]...\n\n");
+ exit(EXIT_FAILURE);
+#else
+ bb_show_usage();
+#endif
+ }
+ }
+ /* A shell is interactive if the `-i' flag was given, or if all of
+ * the following conditions are met:
+ * no -c command
+ * no arguments remaining or the -s flag given
+ * standard input is a terminal
+ * standard output is a terminal
+ * Refer to Posix.2, the description of the `sh' utility. */
+ if (argv[optind]==NULL && input==stdin &&
+ isatty(fileno(stdin)) && isatty(fileno(stdout))) {
+ interactive++;
+ }
+
+ debug_printf("\ninteractive=%d\n", interactive);
+ if (interactive) {
+ /* Looks like they want an interactive shell */
+#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
+ printf( "\n\n" BB_BANNER " hush - the humble shell v0.01 (testing)\n");
+ printf( "Enter 'help' for a list of built-in commands.\n\n");
+#endif
+ setup_job_control();
+ }
+
+ if (argv[optind]==NULL) {
+ opt=parse_file_outer(stdin);
+ goto final_return;
+ }
+
+ debug_printf("\nrunning script '%s'\n", argv[optind]);
+ global_argv = argv+optind;
+ global_argc = argc-optind;
+ input = bb_xfopen(argv[optind], "r");
+ opt = parse_file_outer(input);
+
+#ifdef CONFIG_FEATURE_CLEAN_UP
+ fclose(input);
+ if (cwd && cwd != bb_msg_unknown)
+ free((char*)cwd);
+ {
+ struct variables *cur, *tmp;
+ for(cur = top_vars; cur; cur = tmp) {
+ tmp = cur->next;
+ if (!cur->flg_read_only) {
+ free(cur->name);
+ free(cur->value);
+ free(cur);
+ }
+ }
+ }
+#endif
+
+final_return:
+ return(opt?opt:last_return_code);
+}
+
+static char *insert_var_value(char *inp)
+{
+ int res_str_len = 0;
+ int len;
+ int done = 0;
+ char *p, *p1, *res_str = NULL;
+
+ while ((p = strchr(inp, SPECIAL_VAR_SYMBOL))) {
+ if (p != inp) {
+ len = p - inp;
+ res_str = xrealloc(res_str, (res_str_len + len));
+ strncpy((res_str + res_str_len), inp, len);
+ res_str_len += len;
+ }
+ inp = ++p;
+ p = strchr(inp, SPECIAL_VAR_SYMBOL);
+ *p = '\0';
+ if ((p1 = lookup_param(inp))) {
+ len = res_str_len + strlen(p1);
+ res_str = xrealloc(res_str, (1 + len));
+ strcpy((res_str + res_str_len), p1);
+ res_str_len = len;
+ }
+ *p = SPECIAL_VAR_SYMBOL;
+ inp = ++p;
+ done = 1;
+ }
+ if (done) {
+ res_str = xrealloc(res_str, (1 + res_str_len + strlen(inp)));
+ strcpy((res_str + res_str_len), inp);
+ while ((p = strchr(res_str, '\n'))) {
+ *p = ' ';
+ }
+ }
+ return (res_str == NULL) ? inp : res_str;
+}
+
+static char **make_list_in(char **inp, char *name)
+{
+ int len, i;
+ int name_len = strlen(name);
+ int n = 0;
+ char **list;
+ char *p1, *p2, *p3;
+
+ /* create list of variable values */
+ list = xmalloc(sizeof(*list));
+ for (i = 0; inp[i]; i++) {
+ p3 = insert_var_value(inp[i]);
+ p1 = p3;
+ while (*p1) {
+ if ((*p1 == ' ')) {
+ p1++;
+ continue;
+ }
+ if ((p2 = strchr(p1, ' '))) {
+ len = p2 - p1;
+ } else {
+ len = strlen(p1);
+ p2 = p1 + len;
+ }
+ /* we use n + 2 in realloc for list,because we add
+ * new element and then we will add NULL element */
+ list = xrealloc(list, sizeof(*list) * (n + 2));
+ list[n] = xmalloc(2 + name_len + len);
+ strcpy(list[n], name);
+ strcat(list[n], "=");
+ strncat(list[n], p1, len);
+ list[n++][name_len + len + 1] = '\0';
+ p1 = p2;
+ }
+ if (p3 != inp[i]) free(p3);
+ }
+ list[n] = NULL;
+ return list;
+}
+
+/* Make new string for parser */
+static char * make_string(char ** inp)
+{
+ char *p;
+ char *str = NULL;
+ int n;
+ int len = 2;
+
+ for (n = 0; inp[n]; n++) {
+ p = insert_var_value(inp[n]);
+ str = xrealloc(str, (len + strlen(p)));
+ if (n) {
+ strcat(str, " ");
+ } else {
+ *str = '\0';
+ }
+ strcat(str, p);
+ len = strlen(str) + 3;
+ if (p != inp[n]) free(p);
+ }
+ len = strlen(str);
+ *(str + len) = '\n';
+ *(str + len + 1) = '\0';
+ return str;
+}
diff --git a/release/src/router/busybox/shell/lash.c b/release/src/router/busybox/shell/lash.c
new file mode 100644
index 00000000..1fcd63bd
--- /dev/null
+++ b/release/src/router/busybox/shell/lash.c
@@ -0,0 +1,1649 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * lash -- the BusyBox Lame-Ass SHell
+ *
+ * Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
+ *
+ * Based in part on ladsh.c by Michael K. Johnson and Erik W. Troan, which is
+ * under the following liberal license: "We have placed this source code in the
+ * public domain. Use it in any project, free or commercial."
+ *
+ * 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
+ *
+ */
+
+/* This shell's parsing engine is officially at a dead-end. Future
+ * work shell work should be done using hush, msh, or ash. This is
+ * still a very useful, small shell -- it just don't need any more
+ * features beyond what it already has...
+ */
+
+//For debugging/development on the shell only...
+//#define DEBUG_SHELL
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <termios.h>
+#include "busybox.h"
+#include "cmdedit.h"
+
+#ifdef CONFIG_LOCALE_SUPPORT
+#include <locale.h>
+#endif
+
+#include <glob.h>
+#define expand_t glob_t
+
+
+static const int MAX_READ = 128; /* size of input buffer for `read' builtin */
+#define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
+
+
+enum redir_type { REDIRECT_INPUT, REDIRECT_OVERWRITE,
+ REDIRECT_APPEND
+};
+
+static const unsigned int DEFAULT_CONTEXT=0x1;
+static const unsigned int IF_TRUE_CONTEXT=0x2;
+static const unsigned int IF_FALSE_CONTEXT=0x4;
+static const unsigned int THEN_EXP_CONTEXT=0x8;
+static const unsigned int ELSE_EXP_CONTEXT=0x10;
+
+
+struct jobset {
+ struct job *head; /* head of list of running jobs */
+ struct job *fg; /* current foreground job */
+};
+
+struct redir_struct {
+ enum redir_type type; /* type of redirection */
+ int fd; /* file descriptor being redirected */
+ char *filename; /* file to redirect fd to */
+};
+
+struct child_prog {
+ pid_t pid; /* 0 if exited */
+ char **argv; /* program name and arguments */
+ int num_redirects; /* elements in redirection array */
+ struct redir_struct *redirects; /* I/O redirects */
+ int is_stopped; /* is the program currently running? */
+ struct job *family; /* pointer back to the child's parent job */
+};
+
+struct job {
+ int jobid; /* job number */
+ int num_progs; /* total number of programs in job */
+ int running_progs; /* number of programs running */
+ char *text; /* name of job */
+ char *cmdbuf; /* buffer various argv's point into */
+ pid_t pgrp; /* process group ID for the job */
+ struct child_prog *progs; /* array of programs in job */
+ struct job *next; /* to track background commands */
+ int stopped_progs; /* number of programs alive, but stopped */
+ unsigned int job_context; /* bitmask defining current context */
+ struct jobset *job_list;
+};
+
+struct built_in_command {
+ char *cmd; /* name */
+ char *descr; /* description */
+ int (*function) (struct child_prog *); /* function ptr */
+};
+
+struct close_me {
+ int fd;
+ struct close_me *next;
+};
+
+/* function prototypes for builtins */
+static int builtin_cd(struct child_prog *cmd);
+static int builtin_exec(struct child_prog *cmd);
+static int builtin_exit(struct child_prog *cmd);
+static int builtin_fg_bg(struct child_prog *cmd);
+static int builtin_help(struct child_prog *cmd);
+static int builtin_jobs(struct child_prog *dummy);
+static int builtin_pwd(struct child_prog *dummy);
+static int builtin_export(struct child_prog *cmd);
+static int builtin_source(struct child_prog *cmd);
+static int builtin_unset(struct child_prog *cmd);
+static int builtin_read(struct child_prog *cmd);
+
+
+/* function prototypes for shell stuff */
+static void mark_open(int fd);
+static void mark_closed(int fd);
+static void close_all(void);
+static void checkjobs(struct jobset *job_list);
+static void remove_job(struct jobset *j_list, struct job *job);
+static int get_command(FILE * source, char *command);
+static int parse_command(char **command_ptr, struct job *job, int *inbg);
+static int run_command(struct job *newjob, int inbg, int outpipe[2]);
+static int pseudo_exec(struct child_prog *cmd) __attribute__ ((noreturn));
+static int busy_loop(FILE * input);
+
+
+/* Table of built-in functions (these are non-forking builtins, meaning they
+ * can change global variables in the parent shell process but they will not
+ * work with pipes and redirects; 'unset foo | whatever' will not work) */
+static struct built_in_command bltins[] = {
+ {"bg", "Resume a job in the background", builtin_fg_bg},
+ {"cd", "Change working directory", builtin_cd},
+ {"exec", "Exec command, replacing this shell with the exec'd process", builtin_exec},
+ {"exit", "Exit from shell()", builtin_exit},
+ {"fg", "Bring job into the foreground", builtin_fg_bg},
+ {"jobs", "Lists the active jobs", builtin_jobs},
+ {"export", "Set environment variable", builtin_export},
+ {"unset", "Unset environment variable", builtin_unset},
+ {"read", "Input environment variable", builtin_read},
+ {".", "Source-in and run commands in a file", builtin_source},
+ /* to do: add ulimit */
+ {NULL, NULL, NULL}
+};
+
+/* Table of forking built-in functions (things that fork cannot change global
+ * variables in the parent process, such as the current working directory) */
+static struct built_in_command bltins_forking[] = {
+ {"pwd", "Print current directory", builtin_pwd},
+ {"help", "List shell built-in commands", builtin_help},
+ {NULL, NULL, NULL}
+};
+
+
+static int shell_context; /* Type prompt trigger (PS1 or PS2) */
+
+
+/* Globals that are static to this file */
+static const char *cwd;
+static char *local_pending_command = NULL;
+static struct jobset job_list = { NULL, NULL };
+static int argc;
+static char **argv;
+static struct close_me *close_me_head;
+static int last_return_code;
+static int last_bg_pid;
+static unsigned int last_jobid;
+static int shell_terminal;
+static pid_t shell_pgrp;
+static char *PS1;
+static char *PS2 = "> ";
+
+
+#ifdef DEBUG_SHELL
+static inline void debug_printf(const char *format, ...)
+{
+ va_list args;
+ va_start(args, format);
+ vfprintf(stderr, format, args);
+ va_end(args);
+}
+#else
+static inline void debug_printf(const char *format, ...) { }
+#endif
+
+/*
+ Most builtins need access to the struct child_prog that has
+ their arguments, previously coded as cmd->progs[0]. That coding
+ can exhibit a bug, if the builtin is not the first command in
+ a pipeline: "echo foo | exec sort" will attempt to exec foo.
+
+builtin previous use notes
+------ ----------------- ---------
+cd cmd->progs[0]
+exec cmd->progs[0] squashed bug: didn't look for applets or forking builtins
+exit cmd->progs[0]
+fg_bg cmd->progs[0], job_list->head, job_list->fg
+help 0
+jobs job_list->head
+pwd 0
+export cmd->progs[0]
+source cmd->progs[0]
+unset cmd->progs[0]
+read cmd->progs[0]
+
+I added "struct job *family;" to struct child_prog,
+and switched API to builtin_foo(struct child_prog *child);
+So cmd->text becomes child->family->text
+ cmd->job_context becomes child->family->job_context
+ cmd->progs[0] becomes *child
+ job_list becomes child->family->job_list
+ */
+
+/* built-in 'cd <path>' handler */
+static int builtin_cd(struct child_prog *child)
+{
+ char *newdir;
+
+ if (child->argv[1] == NULL)
+ newdir = getenv("HOME");
+ else
+ newdir = child->argv[1];
+ if (chdir(newdir)) {
+ printf("cd: %s: %m\n", newdir);
+ return EXIT_FAILURE;
+ }
+ cwd = xgetcwd((char *)cwd);
+ if (!cwd)
+ cwd = bb_msg_unknown;
+ return EXIT_SUCCESS;
+}
+
+/* built-in 'exec' handler */
+static int builtin_exec(struct child_prog *child)
+{
+ if (child->argv[1] == NULL)
+ return EXIT_SUCCESS; /* Really? */
+ child->argv++;
+ close_all();
+ pseudo_exec(child);
+ /* never returns */
+}
+
+/* built-in 'exit' handler */
+static int builtin_exit(struct child_prog *child)
+{
+ if (child->argv[1] == NULL)
+ exit(EXIT_SUCCESS);
+
+ exit (atoi(child->argv[1]));
+}
+
+/* built-in 'fg' and 'bg' handler */
+static int builtin_fg_bg(struct child_prog *child)
+{
+ int i, jobnum;
+ struct job *job=NULL;
+
+ /* If they gave us no args, assume they want the last backgrounded task */
+ if (!child->argv[1]) {
+ for (job = child->family->job_list->head; job; job = job->next) {
+ if (job->jobid == last_jobid) {
+ break;
+ }
+ }
+ if (!job) {
+ bb_error_msg("%s: no current job", child->argv[0]);
+ return EXIT_FAILURE;
+ }
+ } else {
+ if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) {
+ bb_error_msg("%s: bad argument '%s'", child->argv[0], child->argv[1]);
+ return EXIT_FAILURE;
+ }
+ for (job = child->family->job_list->head; job; job = job->next) {
+ if (job->jobid == jobnum) {
+ break;
+ }
+ }
+ if (!job) {
+ bb_error_msg("%s: %d: no such job", child->argv[0], jobnum);
+ return EXIT_FAILURE;
+ }
+ }
+
+ if (*child->argv[0] == 'f') {
+ /* Put the job into the foreground. */
+ tcsetpgrp(shell_terminal, job->pgrp);
+
+ child->family->job_list->fg = job;
+ }
+
+ /* Restart the processes in the job */
+ for (i = 0; i < job->num_progs; i++)
+ job->progs[i].is_stopped = 0;
+
+ job->stopped_progs = 0;
+
+ if ( (i=kill(- job->pgrp, SIGCONT)) < 0) {
+ if (i == ESRCH) {
+ remove_job(&job_list, job);
+ } else {
+ bb_perror_msg("kill (SIGCONT)");
+ }
+ }
+
+ return EXIT_SUCCESS;
+}
+
+/* built-in 'help' handler */
+static int builtin_help(struct child_prog *dummy)
+{
+ struct built_in_command *x;
+
+ printf("\nBuilt-in commands:\n");
+ printf("-------------------\n");
+ for (x = bltins; x->cmd; x++) {
+ if (x->descr==NULL)
+ continue;
+ printf("%s\t%s\n", x->cmd, x->descr);
+ }
+ for (x = bltins_forking; x->cmd; x++) {
+ if (x->descr==NULL)
+ continue;
+ printf("%s\t%s\n", x->cmd, x->descr);
+ }
+ printf("\n\n");
+ return EXIT_SUCCESS;
+}
+
+/* built-in 'jobs' handler */
+static int builtin_jobs(struct child_prog *child)
+{
+ struct job *job;
+ char *status_string;
+
+ for (job = child->family->job_list->head; job; job = job->next) {
+ if (job->running_progs == job->stopped_progs)
+ status_string = "Stopped";
+ else
+ status_string = "Running";
+
+ printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
+ }
+ return EXIT_SUCCESS;
+}
+
+
+/* built-in 'pwd' handler */
+static int builtin_pwd(struct child_prog *dummy)
+{
+ cwd = xgetcwd((char *)cwd);
+ if (!cwd)
+ cwd = bb_msg_unknown;
+ puts(cwd);
+ return EXIT_SUCCESS;
+}
+
+/* built-in 'export VAR=value' handler */
+static int builtin_export(struct child_prog *child)
+{
+ int res;
+ char *v = child->argv[1];
+
+ if (v == NULL) {
+ char **e;
+ for (e = environ; *e; e++) {
+ puts(*e);
+ }
+ return 0;
+ }
+ res = putenv(v);
+ if (res)
+ fprintf(stderr, "export: %m\n");
+#ifdef CONFIG_FEATURE_SH_FANCY_PROMPT
+ if (strncmp(v, "PS1=", 4)==0)
+ PS1 = getenv("PS1");
+#endif
+
+#ifdef CONFIG_LOCALE_SUPPORT
+ if(strncmp(v, "LC_ALL=", 7)==0)
+ setlocale(LC_ALL, getenv("LC_ALL"));
+ if(strncmp(v, "LC_CTYPE=", 9)==0)
+ setlocale(LC_CTYPE, getenv("LC_CTYPE"));
+#endif
+
+ return (res);
+}
+
+/* built-in 'read VAR' handler */
+static int builtin_read(struct child_prog *child)
+{
+ int res = 0, len, newlen;
+ char *s;
+ char string[MAX_READ];
+
+ if (child->argv[1]) {
+ /* argument (VAR) given: put "VAR=" into buffer */
+ safe_strncpy(string, child->argv[1], MAX_READ-1);
+ len = strlen(string);
+ string[len++] = '=';
+ string[len] = '\0';
+ fgets(&string[len], sizeof(string) - len, stdin); /* read string */
+ newlen = strlen(string);
+ if(newlen > len)
+ string[--newlen] = '\0'; /* chomp trailing newline */
+ /*
+ ** string should now contain "VAR=<value>"
+ ** copy it (putenv() won't do that, so we must make sure
+ ** the string resides in a static buffer!)
+ */
+ res = -1;
+ if((s = strdup(string)))
+ res = putenv(s);
+ if (res)
+ fprintf(stderr, "read: %m\n");
+ }
+ else
+ fgets(string, sizeof(string), stdin);
+
+ return (res);
+}
+
+/* Built-in '.' handler (read-in and execute commands from file) */
+static int builtin_source(struct child_prog *child)
+{
+ FILE *input;
+ int status;
+ int fd;
+
+ if (child->argv[1] == NULL)
+ return EXIT_FAILURE;
+
+ input = fopen(child->argv[1], "r");
+ if (!input) {
+ printf( "Couldn't open file '%s'\n", child->argv[1]);
+ return EXIT_FAILURE;
+ }
+
+ fd=fileno(input);
+ mark_open(fd);
+ /* Now run the file */
+ status = busy_loop(input);
+ fclose(input);
+ mark_closed(fd);
+ return (status);
+}
+
+/* built-in 'unset VAR' handler */
+static int builtin_unset(struct child_prog *child)
+{
+ if (child->argv[1] == NULL) {
+ printf( "unset: parameter required.\n");
+ return EXIT_FAILURE;
+ }
+ unsetenv(child->argv[1]);
+ return EXIT_SUCCESS;
+}
+
+static void mark_open(int fd)
+{
+ struct close_me *new = xmalloc(sizeof(struct close_me));
+ new->fd = fd;
+ new->next = close_me_head;
+ close_me_head = new;
+}
+
+static void mark_closed(int fd)
+{
+ struct close_me *tmp;
+ if (close_me_head == NULL || close_me_head->fd != fd)
+ bb_error_msg_and_die("corrupt close_me");
+ tmp = close_me_head;
+ close_me_head = close_me_head->next;
+ free(tmp);
+}
+
+static void close_all()
+{
+ struct close_me *c, *tmp;
+ for (c=close_me_head; c; c=tmp) {
+ close(c->fd);
+ tmp=c->next;
+ free(c);
+ }
+ close_me_head = NULL;
+}
+
+
+/* free up all memory from a job */
+static void free_job(struct job *cmd)
+{
+ int i;
+ struct jobset *keep;
+
+ for (i = 0; i < cmd->num_progs; i++) {
+ free(cmd->progs[i].argv);
+ if (cmd->progs[i].redirects)
+ free(cmd->progs[i].redirects);
+ }
+ free(cmd->progs);
+ free(cmd->text);
+ free(cmd->cmdbuf);
+ keep = cmd->job_list;
+ memset(cmd, 0, sizeof(struct job));
+ cmd->job_list = keep;
+}
+
+/* remove a job from a jobset */
+static void remove_job(struct jobset *j_list, struct job *job)
+{
+ struct job *prevjob;
+
+ free_job(job);
+ if (job == j_list->head) {
+ j_list->head = job->next;
+ } else {
+ prevjob = j_list->head;
+ while (prevjob->next != job)
+ prevjob = prevjob->next;
+ prevjob->next = job->next;
+ }
+
+ if (j_list->head)
+ last_jobid = j_list->head->jobid;
+ else
+ last_jobid = 0;
+
+ free(job);
+}
+
+/* Checks to see if any background processes have exited -- if they
+ have, figure out why and see if a job has completed */
+static void checkjobs(struct jobset *j_list)
+{
+ struct job *job;
+ pid_t childpid;
+ int status;
+ int prognum = 0;
+
+ while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
+ for (job = j_list->head; job; job = job->next) {
+ prognum = 0;
+ while (prognum < job->num_progs &&
+ job->progs[prognum].pid != childpid) prognum++;
+ if (prognum < job->num_progs)
+ break;
+ }
+
+ /* This happens on backticked commands */
+ if(job==NULL)
+ return;
+
+ if (WIFEXITED(status) || WIFSIGNALED(status)) {
+ /* child exited */
+ job->running_progs--;
+ job->progs[prognum].pid = 0;
+
+ if (!job->running_progs) {
+ printf(JOB_STATUS_FORMAT, job->jobid, "Done", job->text);
+ last_jobid=0;
+ remove_job(j_list, job);
+ }
+ } else {
+ /* child stopped */
+ job->stopped_progs++;
+ job->progs[prognum].is_stopped = 1;
+
+#if 0
+ /* Printing this stuff is a pain, since it tends to
+ * overwrite the prompt an inconveinient moments. So
+ * don't do that. */
+ if (job->stopped_progs == job->num_progs) {
+ printf(JOB_STATUS_FORMAT, job->jobid, "Stopped",
+ job->text);
+ }
+#endif
+ }
+ }
+
+ if (childpid == -1 && errno != ECHILD)
+ bb_perror_msg("waitpid");
+}
+
+/* squirrel != NULL means we squirrel away copies of stdin, stdout,
+ * and stderr if they are redirected. */
+static int setup_redirects(struct child_prog *prog, int squirrel[])
+{
+ int i;
+ int openfd;
+ int mode = O_RDONLY;
+ struct redir_struct *redir = prog->redirects;
+
+ for (i = 0; i < prog->num_redirects; i++, redir++) {
+ switch (redir->type) {
+ case REDIRECT_INPUT:
+ mode = O_RDONLY;
+ break;
+ case REDIRECT_OVERWRITE:
+ mode = O_WRONLY | O_CREAT | O_TRUNC;
+ break;
+ case REDIRECT_APPEND:
+ mode = O_WRONLY | O_CREAT | O_APPEND;
+ break;
+ }
+
+ openfd = open(redir->filename, mode, 0666);
+ if (openfd < 0) {
+ /* this could get lost if stderr has been redirected, but
+ bash and ash both lose it as well (though zsh doesn't!) */
+ bb_perror_msg("error opening %s", redir->filename);
+ return 1;
+ }
+
+ if (openfd != redir->fd) {
+ if (squirrel && redir->fd < 3) {
+ squirrel[redir->fd] = dup(redir->fd);
+ }
+ dup2(openfd, redir->fd);
+ close(openfd);
+ }
+ }
+
+ return 0;
+}
+
+static void restore_redirects(int squirrel[])
+{
+ int i, fd;
+ for (i=0; i<3; i++) {
+ fd = squirrel[i];
+ if (fd != -1) {
+ /* No error checking. I sure wouldn't know what
+ * to do with an error if I found one! */
+ dup2(fd, i);
+ close(fd);
+ }
+ }
+}
+
+static inline void cmdedit_set_initial_prompt(void)
+{
+#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
+ PS1 = NULL;
+#else
+ PS1 = getenv("PS1");
+ if(PS1==0)
+ PS1 = "\\w \\$ ";
+#endif
+}
+
+static inline void setup_prompt_string(char **prompt_str)
+{
+#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
+ /* Set up the prompt */
+ if (shell_context == 0) {
+ free(PS1);
+ PS1=xmalloc(strlen(cwd)+4);
+ sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# ");
+ *prompt_str = PS1;
+ } else {
+ *prompt_str = PS2;
+ }
+#else
+ *prompt_str = (shell_context==0)? PS1 : PS2;
+#endif
+}
+
+static int get_command(FILE * source, char *command)
+{
+ char *prompt_str;
+
+ if (source == NULL) {
+ if (local_pending_command) {
+ /* a command specified (-c option): return it & mark it done */
+ strcpy(command, local_pending_command);
+ free(local_pending_command);
+ local_pending_command = NULL;
+ return 0;
+ }
+ return 1;
+ }
+
+ if (source == stdin) {
+ setup_prompt_string(&prompt_str);
+
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+ /*
+ ** enable command line editing only while a command line
+ ** is actually being read; otherwise, we'll end up bequeathing
+ ** atexit() handlers and other unwanted stuff to our
+ ** child processes (rob@sysgo.de)
+ */
+ cmdedit_read_input(prompt_str, command);
+ return 0;
+#else
+ fputs(prompt_str, stdout);
+#endif
+ }
+
+ if (!fgets(command, BUFSIZ - 2, source)) {
+ if (source == stdin)
+ printf("\n");
+ return 1;
+ }
+
+ return 0;
+}
+
+static char* itoa(register int i)
+{
+ static char a[7]; /* Max 7 ints */
+ register char *b = a + sizeof(a) - 1;
+ int sign = (i < 0);
+
+ if (sign)
+ i = -i;
+ *b = 0;
+ do
+ {
+ *--b = '0' + (i % 10);
+ i /= 10;
+ }
+ while (i);
+ if (sign)
+ *--b = '-';
+ return b;
+}
+
+char * strsep_space( char *string, int * ix)
+{
+ char *token, *begin;
+
+ begin = string;
+
+ /* Short circuit the trivial case */
+ if ( !string || ! string[*ix])
+ return NULL;
+
+ /* Find the end of the token. */
+ while( string && string[*ix] && !isspace(string[*ix]) ) {
+ (*ix)++;
+ }
+
+ /* Find the end of any whitespace trailing behind
+ * the token and let that be part of the token */
+ while( string && string[*ix] && isspace(string[*ix]) ) {
+ (*ix)++;
+ }
+
+ if (! string && *ix==0) {
+ /* Nothing useful was found */
+ return NULL;
+ }
+
+ token = xmalloc(*ix+1);
+ token[*ix] = '\0';
+ strncpy(token, string, *ix);
+
+ return token;
+}
+
+static int expand_arguments(char *command)
+{
+ int total_length=0, length, i, retval, ix = 0;
+ expand_t expand_result;
+ char *tmpcmd, *cmd, *cmd_copy;
+ char *src, *dst, *var;
+ const char *out_of_space = "out of space during expansion";
+ int flags = GLOB_NOCHECK
+#ifdef GLOB_BRACE
+ | GLOB_BRACE
+#endif
+#ifdef GLOB_TILDE
+ | GLOB_TILDE
+#endif
+ ;
+
+ /* get rid of the terminating \n */
+ chomp(command);
+
+ /* Fix up escape sequences to be the Real Thing(tm) */
+ while( command && command[ix]) {
+ if (command[ix] == '\\') {
+ const char *tmp = command+ix+1;
+ command[ix] = bb_process_escape_sequence( &tmp );
+ memmove(command+ix + 1, tmp, strlen(tmp)+1);
+ }
+ ix++;
+ }
+ /* Use glob and then fixup environment variables and such */
+
+ /* It turns out that glob is very stupid. We have to feed it one word at a
+ * time since it can't cope with a full string. Here we convert command
+ * (char*) into cmd (char**, one word per string) */
+
+ /* We need a clean copy, so strsep can mess up the copy while
+ * we write stuff into the original (in a minute) */
+ cmd = cmd_copy = bb_xstrdup(command);
+ *command = '\0';
+ for (ix = 0, tmpcmd = cmd;
+ (tmpcmd = strsep_space(cmd, &ix)) != NULL; cmd += ix, ix=0) {
+ if (*tmpcmd == '\0')
+ break;
+ /* we need to trim() the result for glob! */
+ trim(tmpcmd);
+ retval = glob(tmpcmd, flags, NULL, &expand_result);
+ free(tmpcmd); /* Free mem allocated by strsep_space */
+ if (retval == GLOB_NOSPACE) {
+ /* Mem may have been allocated... */
+ globfree (&expand_result);
+ bb_error_msg(out_of_space);
+ return FALSE;
+ } else if (retval != 0) {
+ /* Some other error. GLOB_NOMATCH shouldn't
+ * happen because of the GLOB_NOCHECK flag in
+ * the glob call. */
+ bb_error_msg("syntax error");
+ return FALSE;
+ } else {
+ /* Convert from char** (one word per string) to a simple char*,
+ * but don't overflow command which is BUFSIZ in length */
+ for (i=0; i < expand_result.gl_pathc; i++) {
+ length=strlen(expand_result.gl_pathv[i]);
+ if (total_length+length+1 >= BUFSIZ) {
+ bb_error_msg(out_of_space);
+ return FALSE;
+ }
+ strcat(command+total_length, " ");
+ total_length+=1;
+ strcat(command+total_length, expand_result.gl_pathv[i]);
+ total_length+=length;
+ }
+ globfree (&expand_result);
+ }
+ }
+ free(cmd_copy);
+ trim(command);
+
+ /* Now do the shell variable substitutions which
+ * wordexp can't do for us, namely $? and $! */
+ src = command;
+ while((dst = strchr(src,'$')) != NULL){
+ var = NULL;
+ switch(*(dst+1)) {
+ case '?':
+ var = itoa(last_return_code);
+ break;
+ case '!':
+ if (last_bg_pid==-1)
+ *(var)='\0';
+ else
+ var = itoa(last_bg_pid);
+ break;
+ /* Everything else like $$, $#, $[0-9], etc. should all be
+ * expanded by wordexp(), so we can in theory skip that stuff
+ * here, but just to be on the safe side (i.e., since uClibc
+ * wordexp doesn't do this stuff yet), lets leave it in for
+ * now. */
+ case '$':
+ var = itoa(getpid());
+ break;
+ case '#':
+ var = itoa(argc-1);
+ break;
+ case '0':case '1':case '2':case '3':case '4':
+ case '5':case '6':case '7':case '8':case '9':
+ {
+ int ixx=*(dst+1)-48+1;
+ if (ixx >= argc) {
+ var='\0';
+ } else {
+ var = argv[ixx];
+ }
+ }
+ break;
+
+ }
+ if (var) {
+ /* a single character construction was found, and
+ * already handled in the case statement */
+ src=dst+2;
+ } else {
+ /* Looks like an environment variable */
+ char delim_hold;
+ int num_skip_chars=0;
+ int dstlen = strlen(dst);
+ /* Is this a ${foo} type variable? */
+ if (dstlen >=2 && *(dst+1) == '{') {
+ src=strchr(dst+1, '}');
+ num_skip_chars=1;
+ } else {
+ src=dst+1;
+ while(isalnum(*src) || *src=='_') src++;
+ }
+ if (src == NULL) {
+ src = dst+dstlen;
+ }
+ delim_hold=*src;
+ *src='\0'; /* temporary */
+ var = getenv(dst + 1 + num_skip_chars);
+ *src=delim_hold;
+ src += num_skip_chars;
+ }
+ if (var == NULL) {
+ /* Seems we got an un-expandable variable. So delete it. */
+ var = "";
+ }
+ {
+ int subst_len = strlen(var);
+ int trail_len = strlen(src);
+ if (dst+subst_len+trail_len >= command+BUFSIZ) {
+ bb_error_msg(out_of_space);
+ return FALSE;
+ }
+ /* Move stuff to the end of the string to accommodate
+ * filling the created gap with the new stuff */
+ memmove(dst+subst_len, src, trail_len+1);
+ /* Now copy in the new stuff */
+ memcpy(dst, var, subst_len);
+ src = dst+subst_len;
+ }
+ }
+
+ return TRUE;
+}
+
+/* Return cmd->num_progs as 0 if no command is present (e.g. an empty
+ line). If a valid command is found, command_ptr is set to point to
+ the beginning of the next command (if the original command had more
+ then one job associated with it) or NULL if no more commands are
+ present. */
+static int parse_command(char **command_ptr, struct job *job, int *inbg)
+{
+ char *command;
+ char *return_command = NULL;
+ char *src, *buf, *chptr;
+ int argc_l = 0;
+ int done = 0;
+ int argv_alloced;
+ int i, saw_quote = 0;
+ char quote = '\0';
+ int count;
+ struct child_prog *prog;
+
+ /* skip leading white space */
+ while (**command_ptr && isspace(**command_ptr))
+ (*command_ptr)++;
+
+ /* this handles empty lines or leading '#' characters */
+ if (!**command_ptr || (**command_ptr == '#')) {
+ job->num_progs=0;
+ return 0;
+ }
+
+ *inbg = 0;
+ job->num_progs = 1;
+ job->progs = xmalloc(sizeof(*job->progs));
+
+ /* We set the argv elements to point inside of this string. The
+ memory is freed by free_job(). Allocate twice the original
+ length in case we need to quote every single character.
+
+ Getting clean memory relieves us of the task of NULL
+ terminating things and makes the rest of this look a bit
+ cleaner (though it is, admittedly, a tad less efficient) */
+ job->cmdbuf = command = xcalloc(2*strlen(*command_ptr) + 1, sizeof(char));
+ job->text = NULL;
+
+ prog = job->progs;
+ prog->num_redirects = 0;
+ prog->redirects = NULL;
+ prog->is_stopped = 0;
+ prog->family = job;
+
+ argv_alloced = 5;
+ prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
+ prog->argv[0] = job->cmdbuf;
+
+ buf = command;
+ src = *command_ptr;
+ while (*src && !done) {
+ if (quote == *src) {
+ quote = '\0';
+ } else if (quote) {
+ if (*src == '\\') {
+ src++;
+ if (!*src) {
+ bb_error_msg("character expected after \\");
+ free_job(job);
+ return 1;
+ }
+
+ /* in shell, "\'" should yield \' */
+ if (*src != quote) {
+ *buf++ = '\\';
+ *buf++ = '\\';
+ }
+ } else if (*src == '*' || *src == '?' || *src == '[' ||
+ *src == ']') *buf++ = '\\';
+ *buf++ = *src;
+ } else if (isspace(*src)) {
+ if (*prog->argv[argc_l] || saw_quote) {
+ buf++, argc_l++;
+ /* +1 here leaves room for the NULL which ends argv */
+ if ((argc_l + 1) == argv_alloced) {
+ argv_alloced += 5;
+ prog->argv = xrealloc(prog->argv,
+ sizeof(*prog->argv) *
+ argv_alloced);
+ }
+ prog->argv[argc_l] = buf;
+ saw_quote = 0;
+ }
+ } else
+ switch (*src) {
+ case '"':
+ case '\'':
+ quote = *src;
+ saw_quote = 1;
+ break;
+
+ case '#': /* comment */
+ if (*(src-1)== '$')
+ *buf++ = *src;
+ else
+ done = 1;
+ break;
+
+ case '>': /* redirects */
+ case '<':
+ i = prog->num_redirects++;
+ prog->redirects = xrealloc(prog->redirects,
+ sizeof(*prog->redirects) *
+ (i + 1));
+
+ prog->redirects[i].fd = -1;
+ if (buf != prog->argv[argc_l]) {
+ /* the stuff before this character may be the file number
+ being redirected */
+ prog->redirects[i].fd =
+ strtol(prog->argv[argc_l], &chptr, 10);
+
+ if (*chptr && *prog->argv[argc_l]) {
+ buf++, argc_l++;
+ prog->argv[argc_l] = buf;
+ }
+ }
+
+ if (prog->redirects[i].fd == -1) {
+ if (*src == '>')
+ prog->redirects[i].fd = 1;
+ else
+ prog->redirects[i].fd = 0;
+ }
+
+ if (*src++ == '>') {
+ if (*src == '>')
+ prog->redirects[i].type =
+ REDIRECT_APPEND, src++;
+ else
+ prog->redirects[i].type = REDIRECT_OVERWRITE;
+ } else {
+ prog->redirects[i].type = REDIRECT_INPUT;
+ }
+
+ /* This isn't POSIX sh compliant. Oh well. */
+ chptr = src;
+ while (isspace(*chptr))
+ chptr++;
+
+ if (!*chptr) {
+ bb_error_msg("file name expected after %c", *(src-1));
+ free_job(job);
+ job->num_progs=0;
+ return 1;
+ }
+
+ prog->redirects[i].filename = buf;
+ while (*chptr && !isspace(*chptr))
+ *buf++ = *chptr++;
+
+ src = chptr - 1; /* we src++ later */
+ prog->argv[argc_l] = ++buf;
+ break;
+
+ case '|': /* pipe */
+ /* finish this command */
+ if (*prog->argv[argc_l] || saw_quote)
+ argc_l++;
+ if (!argc_l) {
+ bb_error_msg("empty command in pipe");
+ free_job(job);
+ job->num_progs=0;
+ return 1;
+ }
+ prog->argv[argc_l] = NULL;
+
+ /* and start the next */
+ job->num_progs++;
+ job->progs = xrealloc(job->progs,
+ sizeof(*job->progs) * job->num_progs);
+ prog = job->progs + (job->num_progs - 1);
+ prog->num_redirects = 0;
+ prog->redirects = NULL;
+ prog->is_stopped = 0;
+ prog->family = job;
+ argc_l = 0;
+
+ argv_alloced = 5;
+ prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
+ prog->argv[0] = ++buf;
+
+ src++;
+ while (*src && isspace(*src))
+ src++;
+
+ if (!*src) {
+ bb_error_msg("empty command in pipe");
+ free_job(job);
+ job->num_progs=0;
+ return 1;
+ }
+ src--; /* we'll ++ it at the end of the loop */
+
+ break;
+
+ case '&': /* background */
+ *inbg = 1;
+ case ';': /* multiple commands */
+ done = 1;
+ return_command = *command_ptr + (src - *command_ptr) + 1;
+ break;
+
+ case '\\':
+ src++;
+ if (!*src) {
+ bb_error_msg("character expected after \\");
+ free_job(job);
+ return 1;
+ }
+ if (*src == '*' || *src == '[' || *src == ']'
+ || *src == '?') *buf++ = '\\';
+ /* fallthrough */
+ default:
+ *buf++ = *src;
+ }
+
+ src++;
+ }
+
+ if (*prog->argv[argc_l] || saw_quote) {
+ argc_l++;
+ }
+ if (!argc_l) {
+ free_job(job);
+ return 0;
+ }
+ prog->argv[argc_l] = NULL;
+
+ if (!return_command) {
+ job->text = xmalloc(strlen(*command_ptr) + 1);
+ strcpy(job->text, *command_ptr);
+ } else {
+ /* This leaves any trailing spaces, which is a bit sloppy */
+ count = return_command - *command_ptr;
+ job->text = xmalloc(count + 1);
+ strncpy(job->text, *command_ptr, count);
+ job->text[count] = '\0';
+ }
+
+ *command_ptr = return_command;
+
+ return 0;
+}
+
+/* Run the child_prog, no matter what kind of command it uses.
+ */
+static int pseudo_exec(struct child_prog *child)
+{
+ struct built_in_command *x;
+#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
+ char *name;
+#endif
+
+ /* Check if the command matches any of the non-forking builtins.
+ * Depending on context, this might be redundant. But it's
+ * easier to waste a few CPU cycles than it is to figure out
+ * if this is one of those cases.
+ */
+ for (x = bltins; x->cmd; x++) {
+ if (strcmp(child->argv[0], x->cmd) == 0 ) {
+ _exit(x->function(child));
+ }
+ }
+
+ /* Check if the command matches any of the forking builtins. */
+ for (x = bltins_forking; x->cmd; x++) {
+ if (strcmp(child->argv[0], x->cmd) == 0) {
+ bb_applet_name=x->cmd;
+ _exit (x->function(child));
+ }
+ }
+#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
+ /* Check if the command matches any busybox internal
+ * commands ("applets") here. Following discussions from
+ * November 2000 on busybox@busybox.net, don't use
+ * bb_get_last_path_component(). This way explicit (with
+ * slashes) filenames will never be interpreted as an
+ * applet, just like with builtins. This way the user can
+ * override an applet with an explicit filename reference.
+ * The only downside to this change is that an explicit
+ * /bin/foo invocation will fork and exec /bin/foo, even if
+ * /bin/foo is a symlink to busybox.
+ */
+ name = child->argv[0];
+
+#ifdef CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN
+ /* If you enable CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN, then
+ * if you run /bin/cat, it will use BusyBox cat even if
+ * /bin/cat exists on the filesystem and is _not_ busybox.
+ * Some systems want this, others do not. Choose wisely. :-)
+ */
+ name = bb_get_last_path_component(name);
+#endif
+
+ {
+ char** argv_l=child->argv;
+ int argc_l;
+ for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++);
+ optind = 1;
+ run_applet_by_name(name, argc_l, child->argv);
+ }
+#endif
+
+ execvp(child->argv[0], child->argv);
+
+ /* Do not use bb_perror_msg_and_die() here, since we must not
+ * call exit() but should call _exit() instead */
+ fprintf(stderr, "%s: %m\n", child->argv[0]);
+ _exit(EXIT_FAILURE);
+}
+
+static void insert_job(struct job *newjob, int inbg)
+{
+ struct job *thejob;
+ struct jobset *j_list=newjob->job_list;
+
+ /* find the ID for thejob to use */
+ newjob->jobid = 1;
+ for (thejob = j_list->head; thejob; thejob = thejob->next)
+ if (thejob->jobid >= newjob->jobid)
+ newjob->jobid = thejob->jobid + 1;
+
+ /* add thejob to the list of running jobs */
+ if (!j_list->head) {
+ thejob = j_list->head = xmalloc(sizeof(*thejob));
+ } else {
+ for (thejob = j_list->head; thejob->next; thejob = thejob->next) /* nothing */;
+ thejob->next = xmalloc(sizeof(*thejob));
+ thejob = thejob->next;
+ }
+
+ *thejob = *newjob; /* physically copy the struct job */
+ thejob->next = NULL;
+ thejob->running_progs = thejob->num_progs;
+ thejob->stopped_progs = 0;
+
+ if (inbg) {
+ /* we don't wait for background thejobs to return -- append it
+ to the list of backgrounded thejobs and leave it alone */
+ printf("[%d] %d\n", thejob->jobid,
+ newjob->progs[newjob->num_progs - 1].pid);
+ last_jobid = newjob->jobid;
+ last_bg_pid=newjob->progs[newjob->num_progs - 1].pid;
+ } else {
+ newjob->job_list->fg = thejob;
+
+ /* move the new process group into the foreground */
+ /* suppress messages when run from /linuxrc mag@sysgo.de */
+ if (tcsetpgrp(shell_terminal, newjob->pgrp) && errno != ENOTTY)
+ bb_perror_msg("tcsetpgrp");
+ }
+}
+
+static int run_command(struct job *newjob, int inbg, int outpipe[2])
+{
+ /* struct job *thejob; */
+ int i;
+ int nextin, nextout;
+ int pipefds[2]; /* pipefd[0] is for reading */
+ struct built_in_command *x;
+ struct child_prog *child;
+
+ nextin = 0, nextout = 1;
+ for (i = 0; i < newjob->num_progs; i++) {
+ child = & (newjob->progs[i]);
+
+ if ((i + 1) < newjob->num_progs) {
+ if (pipe(pipefds)<0) bb_perror_msg_and_die("pipe");
+ nextout = pipefds[1];
+ } else {
+ if (outpipe[1]!=-1) {
+ nextout = outpipe[1];
+ } else {
+ nextout = 1;
+ }
+ }
+
+
+ /* Check if the command matches any non-forking builtins,
+ * but only if this is a simple command.
+ * Non-forking builtins within pipes have to fork anyway,
+ * and are handled in pseudo_exec. "echo foo | read bar"
+ * is doomed to failure, and doesn't work on bash, either.
+ */
+ if (newjob->num_progs == 1) {
+ for (x = bltins; x->cmd; x++) {
+ if (strcmp(child->argv[0], x->cmd) == 0 ) {
+ int squirrel[] = {-1, -1, -1};
+ int rcode;
+ setup_redirects(child, squirrel);
+ rcode = x->function(child);
+ restore_redirects(squirrel);
+ return rcode;
+ }
+ }
+ }
+
+#if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__)
+ if (!(child->pid = fork()))
+#else
+ if (!(child->pid = vfork()))
+#endif
+ {
+ /* Set the handling for job control signals back to the default. */
+ signal(SIGINT, SIG_DFL);
+ signal(SIGQUIT, SIG_DFL);
+ signal(SIGTSTP, SIG_DFL);
+ signal(SIGTTIN, SIG_DFL);
+ signal(SIGTTOU, SIG_DFL);
+ signal(SIGCHLD, SIG_DFL);
+
+ close_all();
+
+ if (outpipe[1]!=-1) {
+ close(outpipe[0]);
+ }
+ if (nextin != 0) {
+ dup2(nextin, 0);
+ close(nextin);
+ }
+
+ if (nextout != 1) {
+ dup2(nextout, 1);
+ dup2(nextout, 2); /* Really? */
+ close(nextout);
+ close(pipefds[0]);
+ }
+
+ /* explicit redirects override pipes */
+ setup_redirects(child,NULL);
+
+ pseudo_exec(child);
+ }
+ if (outpipe[1]!=-1) {
+ close(outpipe[1]);
+ }
+
+ /* put our child in the process group whose leader is the
+ first process in this pipe */
+ setpgid(child->pid, newjob->progs[0].pid);
+ if (nextin != 0)
+ close(nextin);
+ if (nextout != 1)
+ close(nextout);
+
+ /* If there isn't another process, nextin is garbage
+ but it doesn't matter */
+ nextin = pipefds[0];
+ }
+
+ newjob->pgrp = newjob->progs[0].pid;
+
+ insert_job(newjob, inbg);
+
+ return 0;
+}
+
+static int busy_loop(FILE * input)
+{
+ char *command;
+ char *next_command = NULL;
+ struct job newjob;
+ pid_t parent_pgrp;
+ int i;
+ int inbg;
+ int status;
+ newjob.job_list = &job_list;
+ newjob.job_context = DEFAULT_CONTEXT;
+
+ /* save current owner of TTY so we can restore it on exit */
+ parent_pgrp = tcgetpgrp(shell_terminal);
+
+ command = (char *) xcalloc(BUFSIZ, sizeof(char));
+
+ while (1) {
+ if (!job_list.fg) {
+ /* no job is in the foreground */
+
+ /* see if any background processes have exited */
+ checkjobs(&job_list);
+
+ if (!next_command) {
+ if (get_command(input, command))
+ break;
+ next_command = command;
+ }
+
+ if (! expand_arguments(next_command)) {
+ free(command);
+ command = (char *) xcalloc(BUFSIZ, sizeof(char));
+ next_command = NULL;
+ continue;
+ }
+
+ if (!parse_command(&next_command, &newjob, &inbg) &&
+ newjob.num_progs) {
+ int pipefds[2] = {-1,-1};
+ debug_printf( "job=%p fed to run_command by busy_loop()'\n",
+ &newjob);
+ run_command(&newjob, inbg, pipefds);
+ }
+ else {
+ free(command);
+ command = (char *) xcalloc(BUFSIZ, sizeof(char));
+ next_command = NULL;
+ }
+ } else {
+ /* a job is running in the foreground; wait for it */
+ i = 0;
+ while (!job_list.fg->progs[i].pid ||
+ job_list.fg->progs[i].is_stopped == 1) i++;
+
+ if (waitpid(job_list.fg->progs[i].pid, &status, WUNTRACED)<0) {
+ if (errno != ECHILD) {
+ bb_perror_msg_and_die("waitpid(%d)",job_list.fg->progs[i].pid);
+ }
+ }
+
+ if (WIFEXITED(status) || WIFSIGNALED(status)) {
+ /* the child exited */
+ job_list.fg->running_progs--;
+ job_list.fg->progs[i].pid = 0;
+
+ last_return_code=WEXITSTATUS(status);
+
+ if (!job_list.fg->running_progs) {
+ /* child exited */
+ remove_job(&job_list, job_list.fg);
+ job_list.fg = NULL;
+ }
+ } else {
+ /* the child was stopped */
+ job_list.fg->stopped_progs++;
+ job_list.fg->progs[i].is_stopped = 1;
+
+ if (job_list.fg->stopped_progs == job_list.fg->running_progs) {
+ printf("\n" JOB_STATUS_FORMAT, job_list.fg->jobid,
+ "Stopped", job_list.fg->text);
+ job_list.fg = NULL;
+ }
+ }
+
+ if (!job_list.fg) {
+ /* move the shell to the foreground */
+ /* suppress messages when run from /linuxrc mag@sysgo.de */
+ if (tcsetpgrp(shell_terminal, getpgrp()) && errno != ENOTTY)
+ bb_perror_msg("tcsetpgrp");
+ }
+ }
+ }
+ free(command);
+
+ /* return controlling TTY back to parent process group before exiting */
+ if (tcsetpgrp(shell_terminal, parent_pgrp) && errno != ENOTTY)
+ bb_perror_msg("tcsetpgrp");
+
+ /* return exit status if called with "-c" */
+ if (input == NULL && WIFEXITED(status))
+ return WEXITSTATUS(status);
+
+ return 0;
+}
+
+
+#ifdef CONFIG_FEATURE_CLEAN_UP
+void free_memory(void)
+{
+ if (cwd && cwd!=bb_msg_unknown) {
+ free((char*)cwd);
+ }
+ if (local_pending_command)
+ free(local_pending_command);
+
+ if (job_list.fg && !job_list.fg->running_progs) {
+ remove_job(&job_list, job_list.fg);
+ }
+}
+#endif
+
+/* Make sure we have a controlling tty. If we get started under a job
+ * aware app (like bash for example), make sure we are now in charge so
+ * we don't fight over who gets the foreground */
+static void setup_job_control(void)
+{
+ int status;
+
+ /* Loop until we are in the foreground. */
+ while ((status = tcgetpgrp (shell_terminal)) >= 0) {
+ if (status == (shell_pgrp = getpgrp ())) {
+ break;
+ }
+ kill (- shell_pgrp, SIGTTIN);
+ }
+
+ /* Ignore interactive and job-control signals. */
+ signal(SIGINT, SIG_IGN);
+ signal(SIGQUIT, SIG_IGN);
+ signal(SIGTSTP, SIG_IGN);
+ signal(SIGTTIN, SIG_IGN);
+ signal(SIGTTOU, SIG_IGN);
+ signal(SIGCHLD, SIG_IGN);
+
+ /* Put ourselves in our own process group. */
+ setsid();
+ shell_pgrp = getpid ();
+ setpgid (shell_pgrp, shell_pgrp);
+
+ /* Grab control of the terminal. */
+ tcsetpgrp(shell_terminal, shell_pgrp);
+}
+
+int lash_main(int argc_l, char **argv_l)
+{
+ int opt, interactive=FALSE;
+ FILE *input = stdin;
+ argc = argc_l;
+ argv = argv_l;
+
+ /* These variables need re-initializing when recursing */
+ last_jobid = 0;
+ local_pending_command = NULL;
+ close_me_head = NULL;
+ job_list.head = NULL;
+ job_list.fg = NULL;
+ last_return_code=1;
+
+ if (argv[0] && argv[0][0] == '-') {
+ FILE *prof_input;
+ prof_input = fopen("/etc/profile", "r");
+ if (prof_input) {
+ int tmp_fd = fileno(prof_input);
+ mark_open(tmp_fd);
+ /* Now run the file */
+ busy_loop(prof_input);
+ fclose(prof_input);
+ mark_closed(tmp_fd);
+ }
+ }
+
+ while ((opt = getopt(argc_l, argv_l, "cxi")) > 0) {
+ switch (opt) {
+ case 'c':
+ input = NULL;
+ if (local_pending_command != 0)
+ bb_error_msg_and_die("multiple -c arguments");
+ local_pending_command = bb_xstrdup(argv[optind]);
+ optind++;
+ argv = argv+optind;
+ break;
+ case 'i':
+ interactive = TRUE;
+ break;
+ default:
+ bb_show_usage();
+ }
+ }
+ /* A shell is interactive if the `-i' flag was given, or if all of
+ * the following conditions are met:
+ * no -c command
+ * no arguments remaining or the -s flag given
+ * standard input is a terminal
+ * standard output is a terminal
+ * Refer to Posix.2, the description of the `sh' utility. */
+ if (argv[optind]==NULL && input==stdin &&
+ isatty(fileno(stdin)) && isatty(fileno(stdout))) {
+ interactive=TRUE;
+ }
+ setup_job_control();
+ if (interactive==TRUE) {
+ //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
+ /* Looks like they want an interactive shell */
+#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
+ printf( "\n\n" BB_BANNER " Built-in shell (lash)\n");
+ printf( "Enter 'help' for a list of built-in commands.\n\n");
+#endif
+ } else if (local_pending_command==NULL) {
+ //printf( "optind=%d argv[optind]='%s'\n", optind, argv[optind]);
+ input = bb_xfopen(argv[optind], "r");
+ mark_open(fileno(input)); /* be lazy, never mark this closed */
+ }
+
+ /* initialize the cwd -- this is never freed...*/
+ cwd = xgetcwd(0);
+ if (!cwd)
+ cwd = bb_msg_unknown;
+
+#ifdef CONFIG_FEATURE_CLEAN_UP
+ atexit(free_memory);
+#endif
+
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+ cmdedit_set_initial_prompt();
+#else
+ PS1 = NULL;
+#endif
+
+ return (busy_loop(input));
+}
diff --git a/release/src/router/busybox/shell/msh.c b/release/src/router/busybox/shell/msh.c
new file mode 100644
index 00000000..a142c451
--- /dev/null
+++ b/release/src/router/busybox/shell/msh.c
@@ -0,0 +1,4953 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Minix shell port for busybox
+ *
+ * This version of the Minix shell was adapted for use in busybox
+ * by Erik Andersen <andersen@codepoet.org>
+ *
+ * - backtick expansion did not work properly
+ * Jonas Holmberg <jonas.holmberg@axis.com>
+ * Robert Schwebel <r.schwebel@pengutronix.de>
+ * Erik Andersen <andersen@codepoet.org>
+ *
+ * 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
+ *
+ * Original copyright notice is retained at the end of this file.
+ */
+
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/times.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include "cmdedit.h"
+#include "busybox.h"
+
+
+/* -------- sh.h -------- */
+/*
+ * shell
+ */
+
+#define LINELIM 2100
+#define NPUSH 8 /* limit to input nesting */
+
+#undef NOFILE
+#define NOFILE 20 /* Number of open files */
+#define NUFILE 10 /* Number of user-accessible files */
+#define FDBASE 10 /* First file usable by Shell */
+
+/*
+ * values returned by wait
+ */
+#define WAITSIG(s) ((s)&0177)
+#define WAITVAL(s) (((s)>>8)&0377)
+#define WAITCORE(s) (((s)&0200)!=0)
+
+/*
+ * library and system defintions
+ */
+typedef void xint; /* base type of jmp_buf, for not broken compilers */
+
+/*
+ * shell components
+ */
+
+#define QUOTE 0200
+
+#define NOBLOCK ((struct op *)NULL)
+#define NOWORD ((char *)NULL)
+#define NOWORDS ((char **)NULL)
+#define NOPIPE ((int *)NULL)
+
+/*
+ * Description of a command or an operation on commands.
+ * Might eventually use a union.
+ */
+struct op {
+ int type; /* operation type, see below */
+ char **words; /* arguments to a command */
+ struct ioword **ioact; /* IO actions (eg, < > >>) */
+ struct op *left;
+ struct op *right;
+ char *str; /* identifier for case and for */
+};
+
+#define TCOM 1 /* command */
+#define TPAREN 2 /* (c-list) */
+#define TPIPE 3 /* a | b */
+#define TLIST 4 /* a [&;] b */
+#define TOR 5 /* || */
+#define TAND 6 /* && */
+#define TFOR 7
+#define TDO 8
+#define TCASE 9
+#define TIF 10
+#define TWHILE 11
+#define TUNTIL 12
+#define TELIF 13
+#define TPAT 14 /* pattern in case */
+#define TBRACE 15 /* {c-list} */
+#define TASYNC 16 /* c & */
+
+/*
+ * actions determining the environment of a process
+ */
+#define BIT(i) (1<<(i))
+#define FEXEC BIT(0) /* execute without forking */
+
+/*
+ * flags to control evaluation of words
+ */
+#define DOSUB 1 /* interpret $, `, and quotes */
+#define DOBLANK 2 /* perform blank interpretation */
+#define DOGLOB 4 /* interpret [?* */
+#define DOKEY 8 /* move words with `=' to 2nd arg. list */
+#define DOTRIM 16 /* trim resulting string */
+
+#define DOALL (DOSUB|DOBLANK|DOGLOB|DOKEY|DOTRIM)
+
+static char **dolv;
+static int dolc;
+static int exstat;
+static char gflg;
+static int interactive; /* Is this an interactive shell */
+static int execflg;
+static int multiline; /* \n changed to ; */
+static struct op *outtree; /* result from parser */
+
+static xint *failpt;
+static xint *errpt;
+static struct brkcon *brklist;
+static int isbreak;
+static int newfile(char *s);
+static char *findeq(char *cp);
+static char *cclass(char *p, int sub);
+static void initarea(void);
+extern int msh_main(int argc, char **argv);
+
+
+struct brkcon {
+ jmp_buf brkpt;
+ struct brkcon *nextlev;
+} ;
+
+/*
+ * redirection
+ */
+struct ioword {
+ short io_unit; /* unit affected */
+ short io_flag; /* action (below) */
+ char *io_name; /* file name */
+};
+#define IOREAD 1 /* < */
+#define IOHERE 2 /* << (here file) */
+#define IOWRITE 4 /* > */
+#define IOCAT 8 /* >> */
+#define IOXHERE 16 /* ${}, ` in << */
+#define IODUP 32 /* >&digit */
+#define IOCLOSE 64 /* >&- */
+
+#define IODEFAULT (-1) /* token for default IO unit */
+
+static struct wdblock *wdlist;
+static struct wdblock *iolist;
+
+/*
+ * parsing & execution environment
+ */
+static struct env {
+ char *linep;
+ struct io *iobase;
+ struct io *iop;
+ xint *errpt;
+ int iofd;
+ struct env *oenv;
+} e;
+
+/*
+ * flags:
+ * -e: quit on error
+ * -k: look for name=value everywhere on command line
+ * -n: no execution
+ * -t: exit after reading and executing one command
+ * -v: echo as read
+ * -x: trace
+ * -u: unset variables net diagnostic
+ */
+static char *flag;
+
+static char *null; /* null value for variable */
+static int intr; /* interrupt pending */
+
+static char *trap[_NSIG+1];
+static char ourtrap[_NSIG+1];
+static int trapset; /* trap pending */
+
+static int heedint; /* heed interrupt signals */
+
+static int yynerrs; /* yacc */
+
+static char line[LINELIM];
+static char *elinep;
+
+/*
+ * other functions
+ */
+static int(*inbuilt(char *s))(struct op *);
+
+
+static char *rexecve (char *c , char **v, char **envp );
+static char *space (int n );
+static char *strsave (char *s, int a );
+static char *evalstr (char *cp, int f );
+static char *putn (int n );
+static char *itoa (int n );
+static char *unquote (char *as );
+static struct var *lookup (char *n );
+static int rlookup (char *n );
+static struct wdblock *glob (char *cp, struct wdblock *wb );
+static int my_getc( int ec);
+static int subgetc (int ec, int quoted );
+static char **makenv (void);
+static char **eval (char **ap, int f );
+static int setstatus (int s );
+static int waitfor (int lastpid, int canintr );
+
+static void onintr (int s ); /* SIGINT handler */
+
+static int newenv (int f );
+static void quitenv (void);
+static void err (char *s );
+static int anys (char *s1, char *s2 );
+static int any (int c, char *s );
+static void next (int f );
+static void setdash (void);
+static void onecommand (void);
+static void runtrap (int i );
+static int gmatch (char *s, char *p );
+
+/*
+ * error handling
+ */
+static void leave (void); /* abort shell (or fail in subshell) */
+static void fail (void); /* fail but return to process next command */
+static void warn (char *s );
+static void sig (int i ); /* default signal handler */
+
+
+
+/* -------- area stuff -------- */
+
+#define REGSIZE sizeof(struct region)
+#define GROWBY 256
+//#define SHRINKBY 64
+#undef SHRINKBY
+#define FREE 32767
+#define BUSY 0
+#define ALIGN (sizeof(int)-1)
+
+
+struct region {
+ struct region *next;
+ int area;
+};
+
+
+
+/* -------- grammar stuff -------- */
+typedef union {
+ char *cp;
+ char **wp;
+ int i;
+ struct op *o;
+} YYSTYPE;
+#define WORD 256
+#define LOGAND 257
+#define LOGOR 258
+#define BREAK 259
+#define IF 260
+#define THEN 261
+#define ELSE 262
+#define ELIF 263
+#define FI 264
+#define CASE 265
+#define ESAC 266
+#define FOR 267
+#define WHILE 268
+#define UNTIL 269
+#define DO 270
+#define DONE 271
+#define IN 272
+#define YYERRCODE 300
+
+/* flags to yylex */
+#define CONTIN 01 /* skip new lines to complete command */
+
+#define SYNTAXERR zzerr()
+static struct op *pipeline(int cf );
+static struct op *andor(void);
+static struct op *c_list(void);
+static int synio(int cf );
+static void musthave (int c, int cf );
+static struct op *simple(void);
+static struct op *nested(int type, int mark );
+static struct op *command(int cf );
+static struct op *dogroup(int onlydone );
+static struct op *thenpart(void);
+static struct op *elsepart(void);
+static struct op *caselist(void);
+static struct op *casepart(void);
+static char **pattern(void);
+static char **wordlist(void);
+static struct op *list(struct op *t1, struct op *t2 );
+static struct op *block(int type, struct op *t1, struct op *t2, char **wp );
+static struct op *newtp(void);
+static struct op *namelist(struct op *t );
+static char **copyw(void);
+static void word(char *cp );
+static struct ioword **copyio(void);
+static struct ioword *io (int u, int f, char *cp );
+static void zzerr(void);
+static void yyerror(char *s );
+static int yylex(int cf );
+static int collect(int c, int c1 );
+static int dual(int c );
+static void diag(int ec );
+static char *tree(unsigned size );
+
+/* -------- var.h -------- */
+
+struct var {
+ char *value;
+ char *name;
+ struct var *next;
+ char status;
+};
+#define COPYV 1 /* flag to setval, suggesting copy */
+#define RONLY 01 /* variable is read-only */
+#define EXPORT 02 /* variable is to be exported */
+#define GETCELL 04 /* name & value space was got with getcell */
+
+static struct var *vlist; /* dictionary */
+
+static struct var *homedir; /* home directory */
+static struct var *prompt; /* main prompt */
+static struct var *cprompt; /* continuation prompt */
+static struct var *path; /* search path for commands */
+static struct var *shell; /* shell to interpret command files */
+static struct var *ifs; /* field separators */
+
+static int yyparse (void);
+static struct var *lookup (char *n );
+static void setval (struct var *vp, char *val );
+static void nameval (struct var *vp, char *val, char *name );
+static void export (struct var *vp );
+static void ronly (struct var *vp );
+static int isassign (char *s );
+static int checkname (char *cp );
+static int assign (char *s, int cf );
+static void putvlist (int f, int out );
+static int eqname (char *n1, char *n2 );
+
+static int execute (struct op *t, int *pin, int *pout, int act );
+
+/* -------- io.h -------- */
+/* io buffer */
+struct iobuf {
+ unsigned id; /* buffer id */
+ char buf[512]; /* buffer */
+ char *bufp; /* pointer into buffer */
+ char *ebufp; /* pointer to end of buffer */
+};
+
+/* possible arguments to an IO function */
+struct ioarg {
+ char *aword;
+ char **awordlist;
+ int afile; /* file descriptor */
+ unsigned afid; /* buffer id */
+ long afpos; /* file position */
+ struct iobuf *afbuf; /* buffer for this file */
+};
+//static struct ioarg ioargstack[NPUSH];
+#define AFID_NOBUF (~0)
+#define AFID_ID 0
+
+/* an input generator's state */
+struct io {
+ int (*iofn)(struct ioarg *, struct io *);
+ struct ioarg *argp;
+ int peekc;
+ char prev; /* previous character read by readc() */
+ char nlcount; /* for `'s */
+ char xchar; /* for `'s */
+ char task; /* reason for pushed IO */
+};
+//static struct io iostack[NPUSH];
+#define XOTHER 0 /* none of the below */
+#define XDOLL 1 /* expanding ${} */
+#define XGRAVE 2 /* expanding `'s */
+#define XIO 3 /* file IO */
+
+/* in substitution */
+#define INSUB() (e.iop->task == XGRAVE || e.iop->task == XDOLL)
+
+/*
+ * input generators for IO structure
+ */
+static int nlchar (struct ioarg *ap );
+static int strchar (struct ioarg *ap );
+static int qstrchar (struct ioarg *ap );
+static int filechar (struct ioarg *ap );
+static int herechar (struct ioarg *ap );
+static int linechar (struct ioarg *ap );
+static int gravechar (struct ioarg *ap, struct io *iop );
+static int qgravechar (struct ioarg *ap, struct io *iop );
+static int dolchar (struct ioarg *ap );
+static int wdchar (struct ioarg *ap );
+static void scraphere (void);
+static void freehere (int area );
+static void gethere (void);
+static void markhere (char *s, struct ioword *iop );
+static int herein (char *hname, int xdoll );
+static int run (struct ioarg *argp, int (*f)(struct ioarg *));
+
+/*
+ * IO functions
+ */
+static int eofc (void);
+static int readc (void);
+static void unget (int c );
+static void ioecho (int c );
+static void prs (char *s );
+static void prn (unsigned u );
+static void closef (int i );
+static void closeall (void);
+
+/*
+ * IO control
+ */
+static void pushio (struct ioarg *argp, int (*f)(struct ioarg *));
+static int remap (int fd );
+static int openpipe (int *pv );
+static void closepipe (int *pv );
+static struct io *setbase (struct io *ip );
+
+static struct ioarg temparg; /* temporary for PUSHIO */
+#define PUSHIO(what,arg,gen) ((temparg.what = (arg)),pushio(&temparg,(gen)))
+#define RUN(what,arg,gen) ((temparg.what = (arg)), run(&temparg,(gen)))
+
+/* -------- word.h -------- */
+
+#define NSTART 16 /* default number of words to allow for initially */
+
+struct wdblock {
+ short w_bsize;
+ short w_nword;
+ /* bounds are arbitrary */
+ char *w_words[1];
+};
+
+static struct wdblock *addword (char *wd, struct wdblock *wb );
+static struct wdblock *newword (int nw );
+static char **getwords (struct wdblock *wb );
+
+/* -------- area.h -------- */
+
+/*
+ * storage allocation
+ */
+static char *getcell (unsigned nbytes );
+static void garbage (void);
+static void setarea (char *cp, int a );
+static int getarea (char *cp );
+static void freearea (int a );
+static void freecell (char *cp );
+static int areanum; /* current allocation area */
+
+#define NEW(type) (type *)getcell(sizeof(type))
+#define DELETE(obj) freecell((char *)obj)
+
+
+/* -------- misc stuff -------- */
+
+static int forkexec (struct op *t, int *pin, int *pout, int act, char **wp, int *pforked );
+static int iosetup (struct ioword *iop, int pipein, int pipeout );
+static void echo(char **wp );
+static struct op **find1case (struct op *t, char *w );
+static struct op *findcase (struct op *t, char *w );
+static void brkset(struct brkcon *bc );
+static int dolabel(struct op *t );
+static int dohelp(struct op *t );
+static int dochdir(struct op *t );
+static int doshift(struct op *t );
+static int dologin(struct op *t );
+static int doumask(struct op *t );
+static int doexec(struct op *t );
+static int dodot(struct op *t );
+static int dowait(struct op *t );
+static int doread(struct op *t );
+static int doeval(struct op *t );
+static int dotrap(struct op *t );
+static int getsig(char *s );
+static void setsig (int n, sighandler_t f);
+static int getn(char *as );
+static int dobreak(struct op *t );
+static int docontinue(struct op *t );
+static int brkcontin (char *cp, int val );
+static int doexit(struct op *t );
+static int doexport(struct op *t );
+static int doreadonly(struct op *t );
+static void rdexp (char **wp, void (*f)(struct var *), int key);
+static void badid(char *s );
+static int doset(struct op *t );
+static void varput (char *s, int out );
+static int dotimes(struct op *t );
+static int expand (char *cp, struct wdblock **wbp, int f );
+static char *blank(int f );
+static int dollar(int quoted );
+static int grave(int quoted );
+static void globname (char *we, char *pp );
+static char *generate (char *start1, char *end1, char *middle, char *end );
+static int anyspcl(struct wdblock *wb );
+static int xstrcmp (char *p1, char *p2 );
+static void glob0 (char *a0, unsigned int a1, int a2, int (*a3)(char *, char *));
+static void glob1 (char *base, char *lim );
+static void glob2 (char *i, char *j );
+static void glob3 (char *i, char *j, char *k );
+static void readhere (char **name, char *s, int ec );
+static void pushio (struct ioarg *argp, int (*f)(struct ioarg *));
+static int xxchar(struct ioarg *ap );
+
+struct here {
+ char *h_tag;
+ int h_dosub;
+ struct ioword *h_iop;
+ struct here *h_next;
+};
+
+static char *signame[] = {
+ "Signal 0",
+ "Hangup",
+ (char *)NULL, /* interrupt */
+ "Quit",
+ "Illegal instruction",
+ "Trace/BPT trap",
+ "Abort",
+ "Bus error",
+ "Floating Point Exception",
+ "Killed",
+ "SIGUSR1",
+ "SIGSEGV",
+ "SIGUSR2",
+ (char *)NULL, /* broken pipe */
+ "Alarm clock",
+ "Terminated",
+};
+#define NSIGNAL (sizeof(signame)/sizeof(signame[0]))
+
+struct res {
+ char *r_name;
+ int r_val;
+};
+static struct res restab[] = {
+ {"for", FOR},
+ {"case", CASE},
+ {"esac", ESAC},
+ {"while", WHILE},
+ {"do", DO},
+ {"done", DONE},
+ {"if", IF},
+ {"in", IN},
+ {"then", THEN},
+ {"else", ELSE},
+ {"elif", ELIF},
+ {"until", UNTIL},
+ {"fi", FI},
+
+ {";;", BREAK},
+ {"||", LOGOR},
+ {"&&", LOGAND},
+ {"{", '{'},
+ {"}", '}'},
+ {0, 0},
+};
+
+
+struct builtincmd {
+ const char *name;
+ int (*builtinfunc)(struct op *t);
+};
+static const struct builtincmd builtincmds[] = {
+ {".", dodot},
+ {":", dolabel},
+ {"break", dobreak},
+ {"cd", dochdir},
+ {"continue",docontinue},
+ {"eval", doeval},
+ {"exec", doexec},
+ {"exit", doexit},
+ {"export", doexport},
+ {"help", dohelp},
+ {"login", dologin},
+ {"newgrp", dologin},
+ {"read", doread},
+ {"readonly",doreadonly},
+ {"set", doset},
+ {"shift", doshift},
+ {"times", dotimes},
+ {"trap", dotrap},
+ {"umask", doumask},
+ {"wait", dowait},
+ {0,0}
+};
+
+/* Globals */
+extern char **environ; /* environment pointer */
+static char **dolv;
+static int dolc;
+static int exstat;
+static char gflg;
+static int interactive; /* Is this an interactive shell */
+static int execflg;
+static int multiline; /* \n changed to ; */
+static struct op *outtree; /* result from parser */
+static xint *failpt;
+static xint *errpt;
+static struct brkcon *brklist;
+static int isbreak;
+static struct wdblock *wdlist;
+static struct wdblock *iolist;
+static char *trap[_NSIG+1];
+static char ourtrap[_NSIG+1];
+static int trapset; /* trap pending */
+static int yynerrs; /* yacc */
+static char line[LINELIM];
+static struct var *vlist; /* dictionary */
+static struct var *homedir; /* home directory */
+static struct var *prompt; /* main prompt */
+static struct var *cprompt; /* continuation prompt */
+static struct var *path; /* search path for commands */
+static struct var *shell; /* shell to interpret command files */
+static struct var *ifs; /* field separators */
+static struct ioarg ioargstack[NPUSH];
+static struct io iostack[NPUSH];
+static int areanum; /* current allocation area */
+static int intr;
+static int inparse;
+static char flags['z'-'a'+1];
+static char *flag = flags-'a';
+static char *elinep = line+sizeof(line)-5;
+static char *null = "";
+static int heedint =1;
+static struct env e ={line, iostack, iostack-1, (xint *)NULL, FDBASE, (struct env *)NULL};
+static void (*qflag)(int) = SIG_IGN;
+static char shellname[] = "/bin/sh";
+static int startl;
+static int peeksym;
+static int nlseen;
+static int iounit = IODEFAULT;
+static YYSTYPE yylval;
+static struct iobuf sharedbuf = {AFID_NOBUF};
+static struct iobuf mainbuf = {AFID_NOBUF};
+static unsigned bufid = AFID_ID; /* buffer id counter */
+static struct ioarg temparg = {0, 0, 0, AFID_NOBUF, 0};
+static struct here *inhere; /* list of hear docs while parsing */
+static struct here *acthere; /* list of active here documents */
+static struct region *areabot; /* bottom of area */
+static struct region *areatop; /* top of area */
+static struct region *areanxt; /* starting point of scan */
+static void * brktop;
+static void * brkaddr;
+
+
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+static char * current_prompt;
+#endif
+
+/* -------- sh.c -------- */
+/*
+ * shell
+ */
+
+
+extern int msh_main(int argc, char **argv)
+{
+ register int f;
+ register char *s;
+ int cflag;
+ char *name, **ap;
+ int (*iof)(struct ioarg *);
+
+ initarea();
+ if ((ap = environ) != NULL) {
+ while (*ap)
+ assign(*ap++, !COPYV);
+ for (ap = environ; *ap;)
+ export(lookup(*ap++));
+ }
+ closeall();
+ areanum = 1;
+
+ shell = lookup("SHELL");
+ if (shell->value == null)
+ setval(shell, shellname);
+ export(shell);
+
+ homedir = lookup("HOME");
+ if (homedir->value == null)
+ setval(homedir, "/");
+ export(homedir);
+
+ setval(lookup("$"), putn(getpid()));
+
+ path = lookup("PATH");
+ if (path->value == null) {
+ if (geteuid() == 0)
+ setval(path, "/sbin:/bin:/usr/sbin:/usr/bin");
+ else
+ setval(path, "/bin:/usr/bin");
+ }
+ export(path);
+
+ ifs = lookup("IFS");
+ if (ifs->value == null)
+ setval(ifs, " \t\n");
+
+ prompt = lookup("PS1");
+#ifdef CONFIG_FEATURE_SH_FANCY_PROMPT
+ if (prompt->value == null)
+#endif
+ setval(prompt, "$ ");
+ if (geteuid() == 0) {
+ setval(prompt, "# ");
+ prompt->status &= ~EXPORT;
+ }
+ cprompt = lookup("PS2");
+#ifdef CONFIG_FEATURE_SH_FANCY_PROMPT
+ if (cprompt->value == null)
+#endif
+ setval(cprompt, "> ");
+
+ iof = filechar;
+ cflag = 0;
+ name = *argv++;
+ if (--argc >= 1) {
+ if(argv[0][0] == '-' && argv[0][1] != '\0') {
+ for (s = argv[0]+1; *s; s++)
+ switch (*s) {
+ case 'c':
+ prompt->status &= ~EXPORT;
+ cprompt->status &= ~EXPORT;
+ setval(prompt, "");
+ setval(cprompt, "");
+ cflag = 1;
+ if (--argc > 0)
+ PUSHIO(aword, *++argv, iof = nlchar);
+ break;
+
+ case 'q':
+ qflag = SIG_DFL;
+ break;
+
+ case 's':
+ /* standard input */
+ break;
+
+ case 't':
+ prompt->status &= ~EXPORT;
+ setval(prompt, "");
+ iof = linechar;
+ break;
+
+ case 'i':
+ interactive++;
+ default:
+ if (*s>='a' && *s<='z')
+ flag[(int)*s]++;
+ }
+ } else {
+ argv--;
+ argc++;
+ }
+ if (iof == filechar && --argc > 0) {
+ setval(prompt, "");
+ setval(cprompt, "");
+ prompt->status &= ~EXPORT;
+ cprompt->status &= ~EXPORT;
+ if (newfile(name = *++argv))
+ exit(1);
+ }
+ }
+ setdash();
+ if (e.iop < iostack) {
+ PUSHIO(afile, 0, iof);
+ if (isatty(0) && isatty(1) && !cflag) {
+ interactive++;
+#ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
+ printf( "\n\n" BB_BANNER " Built-in shell (msh)\n");
+ printf( "Enter 'help' for a list of built-in commands.\n\n");
+#endif
+ }
+ }
+ signal(SIGQUIT, qflag);
+ if (name && name[0] == '-') {
+ interactive++;
+ if ((f = open(".profile", 0)) >= 0)
+ next(remap(f));
+ if ((f = open("/etc/profile", 0)) >= 0)
+ next(remap(f));
+ }
+ if (interactive)
+ signal(SIGTERM, sig);
+ if (signal(SIGINT, SIG_IGN) != SIG_IGN)
+ signal(SIGINT, onintr);
+ dolv = argv;
+ dolc = argc;
+ dolv[0] = name;
+ if (dolc > 1) {
+ for (ap = ++argv; --argc > 0;) {
+ if (assign(*ap = *argv++, !COPYV)) {
+ dolc--; /* keyword */
+ } else {
+ ap++;
+ }
+ }
+ }
+ setval(lookup("#"), putn((--dolc < 0) ? (dolc = 0) : dolc));
+
+ for (;;) {
+ if (interactive && e.iop <= iostack) {
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+ current_prompt=prompt->value;
+#else
+ prs(prompt->value);
+#endif
+ }
+ onecommand();
+ /* Ensure that getenv("PATH") stays current */
+ setenv("PATH", path->value, 1);
+ }
+}
+
+static void
+setdash()
+{
+ register char *cp;
+ register int c;
+ char m['z'-'a'+1];
+
+ cp = m;
+ for (c='a'; c<='z'; c++)
+ if (flag[(int)c])
+ *cp++ = c;
+ *cp = 0;
+ setval(lookup("-"), m);
+}
+
+static int
+newfile(s)
+register char *s;
+{
+ register int f;
+
+ if (strcmp(s, "-") != 0) {
+ f = open(s, 0);
+ if (f < 0) {
+ prs(s);
+ err(": cannot open");
+ return(1);
+ }
+ } else
+ f = 0;
+ next(remap(f));
+ return(0);
+}
+
+static void
+onecommand()
+{
+ register int i;
+ jmp_buf m1;
+
+ while (e.oenv)
+ quitenv();
+ areanum = 1;
+ freehere(areanum);
+ freearea(areanum);
+ garbage();
+ wdlist = 0;
+ iolist = 0;
+ e.errpt = 0;
+ e.linep = line;
+ yynerrs = 0;
+ multiline = 0;
+ inparse = 1;
+ intr = 0;
+ execflg = 0;
+ setjmp(failpt = m1); /* Bruce Evans' fix */
+ if (setjmp(failpt = m1) || yyparse() || intr) {
+ while (e.oenv)
+ quitenv();
+ scraphere();
+ if (!interactive && intr)
+ leave();
+ inparse = 0;
+ intr = 0;
+ return;
+ }
+ inparse = 0;
+ brklist = 0;
+ intr = 0;
+ execflg = 0;
+ if (!flag['n'])
+ execute(outtree, NOPIPE, NOPIPE, 0);
+ if (!interactive && intr) {
+ execflg = 0;
+ leave();
+ }
+ if ((i = trapset) != 0) {
+ trapset = 0;
+ runtrap(i);
+ }
+}
+
+static void
+fail()
+{
+ longjmp(failpt, 1);
+ /* NOTREACHED */
+}
+
+static void
+leave()
+{
+ if (execflg)
+ fail();
+ scraphere();
+ freehere(1);
+ runtrap(0);
+ exit(exstat);
+ /* NOTREACHED */
+}
+
+static void
+warn(s)
+register char *s;
+{
+ if(*s) {
+ prs(s);
+ exstat = -1;
+ }
+ prs("\n");
+ if (flag['e'])
+ leave();
+}
+
+static void
+err(s)
+char *s;
+{
+ warn(s);
+ if (flag['n'])
+ return;
+ if (!interactive)
+ leave();
+ if (e.errpt)
+ longjmp(e.errpt, 1);
+ closeall();
+ e.iop = e.iobase = iostack;
+}
+
+static int
+newenv(f)
+int f;
+{
+ register struct env *ep;
+
+ if (f) {
+ quitenv();
+ return(1);
+ }
+ ep = (struct env *) space(sizeof(*ep));
+ if (ep == NULL) {
+ while (e.oenv)
+ quitenv();
+ fail();
+ }
+ *ep = e;
+ e.oenv = ep;
+ e.errpt = errpt;
+ return(0);
+}
+
+static void
+quitenv()
+{
+ register struct env *ep;
+ register int fd;
+
+ if ((ep = e.oenv) != NULL) {
+ fd = e.iofd;
+ e = *ep;
+ /* should close `'d files */
+ DELETE(ep);
+ while (--fd >= e.iofd)
+ close(fd);
+ }
+}
+
+/*
+ * Is any character from s1 in s2?
+ */
+static int
+anys(s1, s2)
+register char *s1, *s2;
+{
+ while (*s1)
+ if (any(*s1++, s2))
+ return(1);
+ return(0);
+}
+
+/*
+ * Is character c in s?
+ */
+static int
+any(c, s)
+register int c;
+register char *s;
+{
+ while (*s)
+ if (*s++ == c)
+ return(1);
+ return(0);
+}
+
+static char *
+putn(n)
+register int n;
+{
+ return(itoa(n));
+}
+
+static char *
+itoa(n)
+register int n;
+{
+ static char s[20];
+ snprintf(s, sizeof(s), "%u", n);
+ return(s);
+}
+
+static void
+next(int f)
+{
+ PUSHIO(afile, f, filechar);
+}
+
+static void
+onintr(s)
+int s; /* ANSI C requires a parameter */
+{
+ signal(SIGINT, onintr);
+ intr = 1;
+ if (interactive) {
+ if (inparse) {
+ prs("\n");
+ fail();
+ }
+ }
+ else if (heedint) {
+ execflg = 0;
+ leave();
+ }
+}
+
+static char *
+space(n)
+int n;
+{
+ register char *cp;
+
+ if ((cp = getcell(n)) == 0)
+ err("out of string space");
+ return(cp);
+}
+
+static char *
+strsave(s, a)
+register char *s;
+int a;
+{
+ register char *cp, *xp;
+
+ if ((cp = space(strlen(s)+1)) != NULL) {
+ setarea((char *)cp, a);
+ for (xp = cp; (*xp++ = *s++) != '\0';)
+ ;
+ return(cp);
+ }
+ return("");
+}
+
+/*
+ * trap handling
+ */
+static void
+sig(i)
+register int i;
+{
+ trapset = i;
+ signal(i, sig);
+}
+
+static void runtrap(i)
+int i;
+{
+ char *trapstr;
+
+ if ((trapstr = trap[i]) == NULL)
+ return;
+ if (i == 0)
+ trap[i] = 0;
+ RUN(aword, trapstr, nlchar);
+}
+
+/* -------- var.c -------- */
+
+/*
+ * Find the given name in the dictionary
+ * and return its value. If the name was
+ * not previously there, enter it now and
+ * return a null value.
+ */
+static struct var *
+lookup(n)
+register char *n;
+{
+ register struct var *vp;
+ register char *cp;
+ register int c;
+ static struct var dummy;
+
+ if (isdigit(*n)) {
+ dummy.name = n;
+ for (c = 0; isdigit(*n) && c < 1000; n++)
+ c = c*10 + *n-'0';
+ dummy.status = RONLY;
+ dummy.value = c <= dolc? dolv[c]: null;
+ return(&dummy);
+ }
+ for (vp = vlist; vp; vp = vp->next)
+ if (eqname(vp->name, n))
+ return(vp);
+ cp = findeq(n);
+ vp = (struct var *)space(sizeof(*vp));
+ if (vp == 0 || (vp->name = space((int)(cp-n)+2)) == 0) {
+ dummy.name = dummy.value = "";
+ return(&dummy);
+ }
+ for (cp = vp->name; (*cp = *n++) && *cp != '='; cp++)
+ ;
+ if (*cp == 0)
+ *cp = '=';
+ *++cp = 0;
+ setarea((char *)vp, 0);
+ setarea((char *)vp->name, 0);
+ vp->value = null;
+ vp->next = vlist;
+ vp->status = GETCELL;
+ vlist = vp;
+ return(vp);
+}
+
+/*
+ * give variable at `vp' the value `val'.
+ */
+static void
+setval(vp, val)
+struct var *vp;
+char *val;
+{
+ nameval(vp, val, (char *)NULL);
+}
+
+/*
+ * if name is not NULL, it must be
+ * a prefix of the space `val',
+ * and end with `='.
+ * this is all so that exporting
+ * values is reasonably painless.
+ */
+static void
+nameval(vp, val, name)
+register struct var *vp;
+char *val, *name;
+{
+ register char *cp, *xp;
+ char *nv;
+ int fl;
+
+ if (vp->status & RONLY) {
+ for (xp = vp->name; *xp && *xp != '=';)
+ putc(*xp++, stderr);
+ err(" is read-only");
+ return;
+ }
+ fl = 0;
+ if (name == NULL) {
+ xp = space(strlen(vp->name)+strlen(val)+2);
+ if (xp == 0)
+ return;
+ /* make string: name=value */
+ setarea((char *)xp, 0);
+ name = xp;
+ for (cp = vp->name; (*xp = *cp++) && *xp!='='; xp++)
+ ;
+ if (*xp++ == 0)
+ xp[-1] = '=';
+ nv = xp;
+ for (cp = val; (*xp++ = *cp++) != '\0';)
+ ;
+ val = nv;
+ fl = GETCELL;
+ }
+ if (vp->status & GETCELL)
+ freecell(vp->name); /* form new string `name=value' */
+ vp->name = name;
+ vp->value = val;
+ vp->status |= fl;
+}
+
+static void
+export(vp)
+struct var *vp;
+{
+ vp->status |= EXPORT;
+}
+
+static void
+ronly(vp)
+struct var *vp;
+{
+ if (isalpha(vp->name[0]) || vp->name[0] == '_') /* not an internal symbol */
+ vp->status |= RONLY;
+}
+
+static int
+isassign(s)
+register char *s;
+{
+ if (!isalpha((int)*s) && *s != '_')
+ return(0);
+ for (; *s != '='; s++)
+ if (*s == 0 || (!isalnum(*s) && *s != '_'))
+ return(0);
+ return(1);
+}
+
+static int
+assign(s, cf)
+register char *s;
+int cf;
+{
+ register char *cp;
+ struct var *vp;
+
+ if (!isalpha(*s) && *s != '_')
+ return(0);
+ for (cp = s; *cp != '='; cp++)
+ if (*cp == 0 || (!isalnum(*cp) && *cp != '_'))
+ return(0);
+ vp = lookup(s);
+ nameval(vp, ++cp, cf == COPYV? (char *)NULL: s);
+ if (cf != COPYV)
+ vp->status &= ~GETCELL;
+ return(1);
+}
+
+static int
+checkname(cp)
+register char *cp;
+{
+ if (!isalpha(*cp++) && *(cp-1) != '_')
+ return(0);
+ while (*cp)
+ if (!isalnum(*cp++) && *(cp-1) != '_')
+ return(0);
+ return(1);
+}
+
+static void
+putvlist(f, out)
+register int f, out;
+{
+ register struct var *vp;
+
+ for (vp = vlist; vp; vp = vp->next)
+ if (vp->status & f && (isalpha(*vp->name) || *vp->name == '_')) {
+ if (vp->status & EXPORT)
+ write(out, "export ", 7);
+ if (vp->status & RONLY)
+ write(out, "readonly ", 9);
+ write(out, vp->name, (int)(findeq(vp->name) - vp->name));
+ write(out, "\n", 1);
+ }
+}
+
+static int
+eqname(n1, n2)
+register char *n1, *n2;
+{
+ for (; *n1 != '=' && *n1 != 0; n1++)
+ if (*n2++ != *n1)
+ return(0);
+ return(*n2 == 0 || *n2 == '=');
+}
+
+static char *
+findeq(cp)
+register char *cp;
+{
+ while (*cp != '\0' && *cp != '=')
+ cp++;
+ return(cp);
+}
+
+/* -------- gmatch.c -------- */
+/*
+ * int gmatch(string, pattern)
+ * char *string, *pattern;
+ *
+ * Match a pattern as in sh(1).
+ */
+
+#define CMASK 0377
+#define QUOTE 0200
+#define QMASK (CMASK&~QUOTE)
+#define NOT '!' /* might use ^ */
+
+static int
+gmatch(s, p)
+register char *s, *p;
+{
+ register int sc, pc;
+
+ if (s == NULL || p == NULL)
+ return(0);
+ while ((pc = *p++ & CMASK) != '\0') {
+ sc = *s++ & QMASK;
+ switch (pc) {
+ case '[':
+ if ((p = cclass(p, sc)) == NULL)
+ return(0);
+ break;
+
+ case '?':
+ if (sc == 0)
+ return(0);
+ break;
+
+ case '*':
+ s--;
+ do {
+ if (*p == '\0' || gmatch(s, p))
+ return(1);
+ } while (*s++ != '\0');
+ return(0);
+
+ default:
+ if (sc != (pc&~QUOTE))
+ return(0);
+ }
+ }
+ return(*s == 0);
+}
+
+static char *
+cclass(p, sub)
+register char *p;
+register int sub;
+{
+ register int c, d, not, found;
+
+ if ((not = *p == NOT) != 0)
+ p++;
+ found = not;
+ do {
+ if (*p == '\0')
+ return((char *)NULL);
+ c = *p & CMASK;
+ if (p[1] == '-' && p[2] != ']') {
+ d = p[2] & CMASK;
+ p++;
+ } else
+ d = c;
+ if (c == sub || (c <= sub && sub <= d))
+ found = !not;
+ } while (*++p != ']');
+ return(found? p+1: (char *)NULL);
+}
+
+
+/* -------- area.c -------- */
+
+/*
+ * All memory between (char *)areabot and (char *)(areatop+1) is
+ * exclusively administered by the area management routines.
+ * It is assumed that sbrk() and brk() manipulate the high end.
+ */
+
+#define sbrk(X) ({ void * __q = (void *)-1; if (brkaddr + (int)(X) < brktop) { __q = brkaddr; brkaddr+=(int)(X); } __q;})
+
+static void
+initarea()
+{
+ brkaddr = malloc(65000);
+ brktop = brkaddr + 65000;
+
+ while ((int)sbrk(0) & ALIGN)
+ sbrk(1);
+ areabot = (struct region *)sbrk(REGSIZE);
+
+ areabot->next = areabot;
+ areabot->area = BUSY;
+ areatop = areabot;
+ areanxt = areabot;
+}
+
+char *
+getcell(nbytes)
+unsigned nbytes;
+{
+ register int nregio;
+ register struct region *p, *q;
+ register int i;
+
+ if (nbytes == 0) {
+ puts("getcell(0)");
+ abort();
+ } /* silly and defeats the algorithm */
+ /*
+ * round upwards and add administration area
+ */
+ nregio = (nbytes+(REGSIZE-1))/REGSIZE + 1;
+ for (p = areanxt;;) {
+ if (p->area > areanum) {
+ /*
+ * merge free cells
+ */
+ while ((q = p->next)->area > areanum && q != areanxt)
+ p->next = q->next;
+ /*
+ * exit loop if cell big enough
+ */
+ if (q >= p + nregio)
+ goto found;
+ }
+ p = p->next;
+ if (p == areanxt)
+ break;
+ }
+ i = nregio >= GROWBY ? nregio : GROWBY;
+ p = (struct region *)sbrk(i * REGSIZE);
+ if (p == (struct region *)-1)
+ return((char *)NULL);
+ p--;
+ if (p != areatop) {
+ puts("not contig");
+ abort(); /* allocated areas are contiguous */
+ }
+ q = p + i;
+ p->next = q;
+ p->area = FREE;
+ q->next = areabot;
+ q->area = BUSY;
+ areatop = q;
+found:
+ /*
+ * we found a FREE area big enough, pointed to by 'p', and up to 'q'
+ */
+ areanxt = p + nregio;
+ if (areanxt < q) {
+ /*
+ * split into requested area and rest
+ */
+ if (areanxt+1 > q) {
+ puts("OOM");
+ abort(); /* insufficient space left for admin */
+ }
+ areanxt->next = q;
+ areanxt->area = FREE;
+ p->next = areanxt;
+ }
+ p->area = areanum;
+ return((char *)(p+1));
+}
+
+static void
+freecell(cp)
+char *cp;
+{
+ register struct region *p;
+
+ if ((p = (struct region *)cp) != NULL) {
+ p--;
+ if (p < areanxt)
+ areanxt = p;
+ p->area = FREE;
+ }
+}
+
+static void
+freearea(a)
+register int a;
+{
+ register struct region *p, *top;
+
+ top = areatop;
+ for (p = areabot; p != top; p = p->next)
+ if (p->area >= a)
+ p->area = FREE;
+}
+
+static void
+setarea(cp,a)
+char *cp;
+int a;
+{
+ register struct region *p;
+
+ if ((p = (struct region *)cp) != NULL)
+ (p-1)->area = a;
+}
+
+int
+getarea(cp)
+char *cp;
+{
+ return ((struct region*)cp-1)->area;
+}
+
+static void
+garbage()
+{
+ register struct region *p, *q, *top;
+
+ top = areatop;
+ for (p = areabot; p != top; p = p->next) {
+ if (p->area > areanum) {
+ while ((q = p->next)->area > areanum)
+ p->next = q->next;
+ areanxt = p;
+ }
+ }
+#ifdef SHRINKBY
+ if (areatop >= q + SHRINKBY && q->area > areanum) {
+ brk((char *)(q+1));
+ q->next = areabot;
+ q->area = BUSY;
+ areatop = q;
+ }
+#endif
+}
+
+/* -------- csyn.c -------- */
+/*
+ * shell: syntax (C version)
+ */
+
+
+int
+yyparse()
+{
+ startl = 1;
+ peeksym = 0;
+ yynerrs = 0;
+ outtree = c_list();
+ musthave('\n', 0);
+ return(yynerrs!=0);
+}
+
+static struct op *
+pipeline(cf)
+int cf;
+{
+ register struct op *t, *p;
+ register int c;
+
+ t = command(cf);
+ if (t != NULL) {
+ while ((c = yylex(0)) == '|') {
+ if ((p = command(CONTIN)) == NULL)
+ SYNTAXERR;
+ if (t->type != TPAREN && t->type != TCOM) {
+ /* shell statement */
+ t = block(TPAREN, t, NOBLOCK, NOWORDS);
+ }
+ t = block(TPIPE, t, p, NOWORDS);
+ }
+ peeksym = c;
+ }
+ return(t);
+}
+
+static struct op *
+andor()
+{
+ register struct op *t, *p;
+ register int c;
+
+ t = pipeline(0);
+ if (t != NULL) {
+ while ((c = yylex(0)) == LOGAND || c == LOGOR) {
+ if ((p = pipeline(CONTIN)) == NULL)
+ SYNTAXERR;
+ t = block(c == LOGAND? TAND: TOR, t, p, NOWORDS);
+ }
+ peeksym = c;
+ }
+ return(t);
+}
+
+static struct op *
+c_list()
+{
+ register struct op *t, *p;
+ register int c;
+
+ t = andor();
+ if (t != NULL) {
+ if((peeksym = yylex(0)) == '&')
+ t = block(TASYNC, t, NOBLOCK, NOWORDS);
+ while ((c = yylex(0)) == ';' || c == '&' || (multiline && c == '\n')) {
+ if ((p = andor()) == NULL)
+ return(t);
+ if((peeksym = yylex(0)) == '&')
+ p = block(TASYNC, p, NOBLOCK, NOWORDS);
+ t = list(t, p);
+ }
+ peeksym = c;
+ }
+ return(t);
+}
+
+
+static int
+synio(cf)
+int cf;
+{
+ register struct ioword *iop;
+ register int i;
+ register int c;
+
+ if ((c = yylex(cf)) != '<' && c != '>') {
+ peeksym = c;
+ return(0);
+ }
+ i = yylval.i;
+ musthave(WORD, 0);
+ iop = io(iounit, i, yylval.cp);
+ iounit = IODEFAULT;
+ if (i & IOHERE)
+ markhere(yylval.cp, iop);
+ return(1);
+}
+
+static void
+musthave(c, cf)
+int c, cf;
+{
+ if ((peeksym = yylex(cf)) != c)
+ SYNTAXERR;
+ peeksym = 0;
+}
+
+static struct op *
+simple()
+{
+ register struct op *t;
+
+ t = NULL;
+ for (;;) {
+ switch (peeksym = yylex(0)) {
+ case '<':
+ case '>':
+ (void) synio(0);
+ break;
+
+ case WORD:
+ if (t == NULL) {
+ t = newtp();
+ t->type = TCOM;
+ }
+ peeksym = 0;
+ word(yylval.cp);
+ break;
+
+ default:
+ return(t);
+ }
+ }
+}
+
+static struct op *
+nested(type, mark)
+int type, mark;
+{
+ register struct op *t;
+
+ multiline++;
+ t = c_list();
+ musthave(mark, 0);
+ multiline--;
+ return(block(type, t, NOBLOCK, NOWORDS));
+}
+
+static struct op *
+command(cf)
+int cf;
+{
+ register struct op *t;
+ struct wdblock *iosave;
+ register int c;
+
+ iosave = iolist;
+ iolist = NULL;
+ if (multiline)
+ cf |= CONTIN;
+ while (synio(cf))
+ cf = 0;
+ switch (c = yylex(cf)) {
+ default:
+ peeksym = c;
+ if ((t = simple()) == NULL) {
+ if (iolist == NULL)
+ return((struct op *)NULL);
+ t = newtp();
+ t->type = TCOM;
+ }
+ break;
+
+ case '(':
+ t = nested(TPAREN, ')');
+ break;
+
+ case '{':
+ t = nested(TBRACE, '}');
+ break;
+
+ case FOR:
+ t = newtp();
+ t->type = TFOR;
+ musthave(WORD, 0);
+ startl = 1;
+ t->str = yylval.cp;
+ multiline++;
+ t->words = wordlist();
+ if ((c = yylex(0)) != '\n' && c != ';')
+ peeksym = c;
+ t->left = dogroup(0);
+ multiline--;
+ break;
+
+ case WHILE:
+ case UNTIL:
+ multiline++;
+ t = newtp();
+ t->type = c == WHILE? TWHILE: TUNTIL;
+ t->left = c_list();
+ t->right = dogroup(1);
+ t->words = NULL;
+ multiline--;
+ break;
+
+ case CASE:
+ t = newtp();
+ t->type = TCASE;
+ musthave(WORD, 0);
+ t->str = yylval.cp;
+ startl++;
+ multiline++;
+ musthave(IN, CONTIN);
+ startl++;
+ t->left = caselist();
+ musthave(ESAC, 0);
+ multiline--;
+ break;
+
+ case IF:
+ multiline++;
+ t = newtp();
+ t->type = TIF;
+ t->left = c_list();
+ t->right = thenpart();
+ musthave(FI, 0);
+ multiline--;
+ break;
+ }
+ while (synio(0))
+ ;
+ t = namelist(t);
+ iolist = iosave;
+ return(t);
+}
+
+static struct op *
+dogroup(onlydone)
+int onlydone;
+{
+ register int c;
+ register struct op *mylist;
+
+ c = yylex(CONTIN);
+ if (c == DONE && onlydone)
+ return((struct op *)NULL);
+ if (c != DO)
+ SYNTAXERR;
+ mylist = c_list();
+ musthave(DONE, 0);
+ return(mylist);
+}
+
+static struct op *
+thenpart()
+{
+ register int c;
+ register struct op *t;
+
+ if ((c = yylex(0)) != THEN) {
+ peeksym = c;
+ return((struct op *)NULL);
+ }
+ t = newtp();
+ t->type = 0;
+ t->left = c_list();
+ if (t->left == NULL)
+ SYNTAXERR;
+ t->right = elsepart();
+ return(t);
+}
+
+static struct op *
+elsepart()
+{
+ register int c;
+ register struct op *t;
+
+ switch (c = yylex(0)) {
+ case ELSE:
+ if ((t = c_list()) == NULL)
+ SYNTAXERR;
+ return(t);
+
+ case ELIF:
+ t = newtp();
+ t->type = TELIF;
+ t->left = c_list();
+ t->right = thenpart();
+ return(t);
+
+ default:
+ peeksym = c;
+ return((struct op *)NULL);
+ }
+}
+
+static struct op *
+caselist()
+{
+ register struct op *t;
+
+ t = NULL;
+ while ((peeksym = yylex(CONTIN)) != ESAC)
+ t = list(t, casepart());
+ return(t);
+}
+
+static struct op *
+casepart()
+{
+ register struct op *t;
+
+ t = newtp();
+ t->type = TPAT;
+ t->words = pattern();
+ musthave(')', 0);
+ t->left = c_list();
+ if ((peeksym = yylex(CONTIN)) != ESAC)
+ musthave(BREAK, CONTIN);
+ return(t);
+}
+
+static char **
+pattern()
+{
+ register int c, cf;
+
+ cf = CONTIN;
+ do {
+ musthave(WORD, cf);
+ word(yylval.cp);
+ cf = 0;
+ } while ((c = yylex(0)) == '|');
+ peeksym = c;
+ word(NOWORD);
+ return(copyw());
+}
+
+static char **
+wordlist()
+{
+ register int c;
+
+ if ((c = yylex(0)) != IN) {
+ peeksym = c;
+ return((char **)NULL);
+ }
+ startl = 0;
+ while ((c = yylex(0)) == WORD)
+ word(yylval.cp);
+ word(NOWORD);
+ peeksym = c;
+ return(copyw());
+}
+
+/*
+ * supporting functions
+ */
+static struct op *
+list(t1, t2)
+register struct op *t1, *t2;
+{
+ if (t1 == NULL)
+ return(t2);
+ if (t2 == NULL)
+ return(t1);
+ return(block(TLIST, t1, t2, NOWORDS));
+}
+
+static struct op *
+block(type, t1, t2, wp)
+int type;
+struct op *t1, *t2;
+char **wp;
+{
+ register struct op *t;
+
+ t = newtp();
+ t->type = type;
+ t->left = t1;
+ t->right = t2;
+ t->words = wp;
+ return(t);
+}
+
+static int
+rlookup(n)
+register char *n;
+{
+ register struct res *rp;
+
+ for (rp = restab; rp->r_name; rp++)
+ if (strcmp(rp->r_name, n) == 0)
+ return(rp->r_val);
+ return(0);
+}
+
+static struct op *
+newtp()
+{
+ register struct op *t;
+
+ t = (struct op *)tree(sizeof(*t));
+ t->type = 0;
+ t->words = NULL;
+ t->ioact = NULL;
+ t->left = NULL;
+ t->right = NULL;
+ t->str = NULL;
+ return(t);
+}
+
+static struct op *
+namelist(t)
+register struct op *t;
+{
+ if (iolist) {
+ iolist = addword((char *)NULL, iolist);
+ t->ioact = copyio();
+ } else
+ t->ioact = NULL;
+ if (t->type != TCOM) {
+ if (t->type != TPAREN && t->ioact != NULL) {
+ t = block(TPAREN, t, NOBLOCK, NOWORDS);
+ t->ioact = t->left->ioact;
+ t->left->ioact = NULL;
+ }
+ return(t);
+ }
+ word(NOWORD);
+ t->words = copyw();
+ return(t);
+}
+
+static char **
+copyw()
+{
+ register char **wd;
+
+ wd = getwords(wdlist);
+ wdlist = 0;
+ return(wd);
+}
+
+static void
+word(cp)
+char *cp;
+{
+ wdlist = addword(cp, wdlist);
+}
+
+static struct ioword **
+copyio()
+{
+ register struct ioword **iop;
+
+ iop = (struct ioword **) getwords(iolist);
+ iolist = 0;
+ return(iop);
+}
+
+static struct ioword *
+io(u, f, cp)
+int u;
+int f;
+char *cp;
+{
+ register struct ioword *iop;
+
+ iop = (struct ioword *) tree(sizeof(*iop));
+ iop->io_unit = u;
+ iop->io_flag = f;
+ iop->io_name = cp;
+ iolist = addword((char *)iop, iolist);
+ return(iop);
+}
+
+static void
+zzerr()
+{
+ yyerror("syntax error");
+}
+
+static void
+yyerror(s)
+char *s;
+{
+ yynerrs++;
+ if (interactive && e.iop <= iostack) {
+ multiline = 0;
+ while (eofc() == 0 && yylex(0) != '\n')
+ ;
+ }
+ err(s);
+ fail();
+}
+
+static int
+yylex(cf)
+int cf;
+{
+ register int c, c1;
+ int atstart;
+
+ if ((c = peeksym) > 0) {
+ peeksym = 0;
+ if (c == '\n')
+ startl = 1;
+ return(c);
+ }
+ nlseen = 0;
+ e.linep = line;
+ atstart = startl;
+ startl = 0;
+ yylval.i = 0;
+
+loop:
+ while ((c = my_getc(0)) == ' ' || c == '\t')
+ ;
+ switch (c) {
+ default:
+ if (any(c, "0123456789")) {
+ unget(c1 = my_getc(0));
+ if (c1 == '<' || c1 == '>') {
+ iounit = c - '0';
+ goto loop;
+ }
+ *e.linep++ = c;
+ c = c1;
+ }
+ break;
+
+ case '#':
+ while ((c = my_getc(0)) != 0 && c != '\n')
+ ;
+ unget(c);
+ goto loop;
+
+ case 0:
+ return(c);
+
+ case '$':
+ *e.linep++ = c;
+ if ((c = my_getc(0)) == '{') {
+ if ((c = collect(c, '}')) != '\0')
+ return(c);
+ goto pack;
+ }
+ break;
+
+ case '`':
+ case '\'':
+ case '"':
+ if ((c = collect(c, c)) != '\0')
+ return(c);
+ goto pack;
+
+ case '|':
+ case '&':
+ case ';':
+ if ((c1 = dual(c)) != '\0') {
+ startl = 1;
+ return(c1);
+ }
+ startl = 1;
+ return(c);
+ case '^':
+ startl = 1;
+ return('|');
+ case '>':
+ case '<':
+ diag(c);
+ return(c);
+
+ case '\n':
+ nlseen++;
+ gethere();
+ startl = 1;
+ if (multiline || cf & CONTIN) {
+ if (interactive && e.iop <= iostack) {
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+ current_prompt=cprompt->value;
+#else
+ prs(cprompt->value);
+#endif
+ }
+ if (cf & CONTIN)
+ goto loop;
+ }
+ return(c);
+
+ case '(':
+ case ')':
+ startl = 1;
+ return(c);
+ }
+
+ unget(c);
+
+pack:
+ while ((c = my_getc(0)) != 0 && !any(c, "`$ '\"\t;&<>()|^\n"))
+ if (e.linep >= elinep)
+ err("word too long");
+ else
+ *e.linep++ = c;
+ unget(c);
+ if(any(c, "\"'`$"))
+ goto loop;
+ *e.linep++ = '\0';
+ if (atstart && (c = rlookup(line))!=0) {
+ startl = 1;
+ return(c);
+ }
+ yylval.cp = strsave(line, areanum);
+ return(WORD);
+}
+
+static int
+collect(c, c1)
+register int c, c1;
+{
+ char s[2];
+
+ *e.linep++ = c;
+ while ((c = my_getc(c1)) != c1) {
+ if (c == 0) {
+ unget(c);
+ s[0] = c1;
+ s[1] = 0;
+ prs("no closing "); yyerror(s);
+ return(YYERRCODE);
+ }
+ if (interactive && c == '\n' && e.iop <= iostack) {
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+ current_prompt=cprompt->value;
+#else
+ prs(cprompt->value);
+#endif
+ }
+ *e.linep++ = c;
+ }
+ *e.linep++ = c;
+ return(0);
+}
+
+static int
+dual(c)
+register int c;
+{
+ char s[3];
+ register char *cp = s;
+
+ *cp++ = c;
+ *cp++ = my_getc(0);
+ *cp = 0;
+ if ((c = rlookup(s)) == 0)
+ unget(*--cp);
+ return(c);
+}
+
+static void
+diag(ec)
+register int ec;
+{
+ register int c;
+
+ c = my_getc(0);
+ if (c == '>' || c == '<') {
+ if (c != ec)
+ zzerr();
+ yylval.i = ec == '>'? IOWRITE|IOCAT: IOHERE;
+ c = my_getc(0);
+ } else
+ yylval.i = ec == '>'? IOWRITE: IOREAD;
+ if (c != '&' || yylval.i == IOHERE)
+ unget(c);
+ else
+ yylval.i |= IODUP;
+}
+
+static char *
+tree(size)
+unsigned size;
+{
+ register char *t;
+
+ if ((t = getcell(size)) == NULL) {
+ prs("command line too complicated\n");
+ fail();
+ /* NOTREACHED */
+ }
+ return(t);
+}
+
+/* VARARGS1 */
+/* ARGSUSED */
+
+/* -------- exec.c -------- */
+
+/*
+ * execute tree
+ */
+
+
+static int
+execute(t, pin, pout, act)
+register struct op *t;
+int *pin, *pout;
+int act;
+{
+ register struct op *t1;
+ volatile int i, rv, a;
+ char *cp, **wp, **wp2;
+ struct var *vp;
+ struct brkcon bc;
+
+#if __GNUC__
+ /* Avoid longjmp clobbering */
+ (void) &wp;
+#endif
+
+
+ if (t == NULL)
+ return(0);
+ rv = 0;
+ a = areanum++;
+ wp = (wp2 = t->words) != NULL
+ ? eval(wp2, t->type == TCOM ? DOALL : DOALL & ~DOKEY)
+ : NULL;
+
+ switch(t->type) {
+ case TPAREN:
+ rv = execute(t->left, pin, pout, 0);
+ break;
+
+ case TCOM:
+ {
+ int child;
+ rv = forkexec(t, pin, pout, act, wp, &child);
+ if (child) {
+ exstat = rv;
+ leave();
+ }
+ }
+ break;
+
+ case TPIPE:
+ {
+ int pv[2];
+ if ((rv = openpipe(pv)) < 0)
+ break;
+ pv[0] = remap(pv[0]);
+ pv[1] = remap(pv[1]);
+ (void) execute(t->left, pin, pv, 0);
+ rv = execute(t->right, pv, pout, 0);
+ }
+ break;
+
+ case TLIST:
+ (void) execute(t->left, pin, pout, 0);
+ rv = execute(t->right, pin, pout, 0);
+ break;
+
+ case TASYNC:
+ {
+ int hinteractive = interactive;
+
+ i = vfork();
+ if (i != 0) {
+ interactive = hinteractive;
+ if (i != -1) {
+ setval(lookup("!"), putn(i));
+ if (pin != NULL)
+ closepipe(pin);
+ if (interactive) {
+ prs(putn(i));
+ prs("\n");
+ }
+ } else
+ rv = -1;
+ setstatus(rv);
+ } else {
+ signal(SIGINT, SIG_IGN);
+ signal(SIGQUIT, SIG_IGN);
+ if (interactive)
+ signal(SIGTERM, SIG_DFL);
+ interactive = 0;
+ if (pin == NULL) {
+ close(0);
+ open("/dev/null", 0);
+ }
+ exit(execute(t->left, pin, pout, FEXEC));
+ }
+ }
+ break;
+
+ case TOR:
+ case TAND:
+ rv = execute(t->left, pin, pout, 0);
+ if ((t1 = t->right)!=NULL && (rv == 0) == (t->type == TAND))
+ rv = execute(t1, pin, pout, 0);
+ break;
+
+ case TFOR:
+ if (wp == NULL) {
+ wp = dolv+1;
+ if ((i = dolc) < 0)
+ i = 0;
+ } else {
+ i = -1;
+ while (*wp++ != NULL)
+ ;
+ }
+ vp = lookup(t->str);
+ while (setjmp(bc.brkpt))
+ if (isbreak)
+ goto broken;
+ brkset(&bc);
+ for (t1 = t->left; i-- && *wp != NULL;) {
+ setval(vp, *wp++);
+ rv = execute(t1, pin, pout, 0);
+ }
+ brklist = brklist->nextlev;
+ break;
+
+ case TWHILE:
+ case TUNTIL:
+ while (setjmp(bc.brkpt))
+ if (isbreak)
+ goto broken;
+ brkset(&bc);
+ t1 = t->left;
+ while ((execute(t1, pin, pout, 0) == 0) == (t->type == TWHILE))
+ rv = execute(t->right, pin, pout, 0);
+ brklist = brklist->nextlev;
+ break;
+
+ case TIF:
+ case TELIF:
+ if (t->right != NULL) {
+ rv = !execute(t->left, pin, pout, 0) ?
+ execute(t->right->left, pin, pout, 0):
+ execute(t->right->right, pin, pout, 0);
+ }
+ break;
+
+ case TCASE:
+ if ((cp = evalstr(t->str, DOSUB|DOTRIM)) == 0)
+ cp = "";
+ if ((t1 = findcase(t->left, cp)) != NULL)
+ rv = execute(t1, pin, pout, 0);
+ break;
+
+ case TBRACE:
+/*
+ if (iopp = t->ioact)
+ while (*iopp)
+ if (iosetup(*iopp++, pin!=NULL, pout!=NULL)) {
+ rv = -1;
+ break;
+ }
+*/
+ if (rv >= 0 && (t1 = t->left))
+ rv = execute(t1, pin, pout, 0);
+ break;
+ }
+
+broken:
+ t->words = wp2;
+ isbreak = 0;
+ freehere(areanum);
+ freearea(areanum);
+ areanum = a;
+ if (interactive && intr) {
+ closeall();
+ fail();
+ }
+ if ((i = trapset) != 0) {
+ trapset = 0;
+ runtrap(i);
+ }
+ return(rv);
+}
+
+static int
+forkexec( register struct op *t, int *pin, int *pout, int act, char **wp, int *pforked)
+{
+ int i, rv;
+ int (*shcom)(struct op *) = NULL;
+ register int f;
+ char *cp = NULL;
+ struct ioword **iopp;
+ int resetsig;
+ char **owp;
+
+ int *hpin = pin;
+ int *hpout = pout;
+ int hforked;
+ char *hwp;
+ int hinteractive;
+ int hintr;
+ struct brkcon * hbrklist;
+ int hexecflg;
+
+#if __GNUC__
+ /* Avoid longjmp clobbering */
+ (void) &pin;
+ (void) &pout;
+ (void) &wp;
+ (void) &shcom;
+ (void) &cp;
+ (void) &resetsig;
+ (void) &owp;
+#endif
+
+ owp = wp;
+ resetsig = 0;
+ *pforked = 0;
+ rv = -1; /* system-detected error */
+ if (t->type == TCOM) {
+ while ((cp = *wp++) != NULL)
+ ;
+ cp = *wp;
+
+ /* strip all initial assignments */
+ /* not correct wrt PATH=yyy command etc */
+ if (flag['x'])
+ echo (cp ? wp: owp);
+ if (cp == NULL && t->ioact == NULL) {
+ while ((cp = *owp++) != NULL && assign(cp, COPYV))
+ ;
+ return(setstatus(0));
+ }
+ else if (cp != NULL)
+ shcom = inbuilt(cp);
+ }
+ t->words = wp;
+ f = act;
+ if (shcom == NULL && (f & FEXEC) == 0) {
+
+ hpin = pin;
+ hpout = pout;
+ hforked = *pforked;
+ hwp = *wp;
+ hinteractive = interactive;
+ hintr = intr;
+ hbrklist = brklist;
+ hexecflg = execflg;
+
+ i = vfork();
+ if (i != 0) {
+ /* who wrote this crappy non vfork safe shit? */
+ pin = hpin;
+ pout = hpout;
+ *pforked = hforked;
+ *wp = hwp;
+ interactive = hinteractive;
+ intr = hintr;
+ brklist = hbrklist;
+ execflg = hexecflg;
+
+ *pforked = 0;
+ if (i == -1)
+ return(rv);
+ if (pin != NULL)
+ closepipe(pin);
+ return(pout==NULL? setstatus(waitfor(i,0)): 0);
+ }
+
+ if (interactive) {
+ signal(SIGINT, SIG_IGN);
+ signal(SIGQUIT, SIG_IGN);
+ resetsig = 1;
+ }
+ interactive = 0;
+ intr = 0;
+ (*pforked)++;
+ brklist = 0;
+ execflg = 0;
+ }
+ if (owp != NULL)
+ while ((cp = *owp++) != NULL && assign(cp, COPYV))
+ if (shcom == NULL)
+ export(lookup(cp));
+#ifdef COMPIPE
+ if ((pin != NULL || pout != NULL) && shcom != NULL && shcom != doexec) {
+ err("piping to/from shell builtins not yet done");
+ return(-1);
+ }
+#endif
+ if (pin != NULL) {
+ dup2(pin[0], 0);
+ closepipe(pin);
+ }
+ if (pout != NULL) {
+ dup2(pout[1], 1);
+ closepipe(pout);
+ }
+ if ((iopp = t->ioact) != NULL) {
+ if (shcom != NULL && shcom != doexec) {
+ prs(cp);
+ err(": cannot redirect shell command");
+ return(-1);
+ }
+ while (*iopp)
+ if (iosetup(*iopp++, pin!=NULL, pout!=NULL))
+ return(rv);
+ }
+ if (shcom)
+ return(setstatus((*shcom)(t)));
+ /* should use FIOCEXCL */
+ for (i=FDBASE; i<NOFILE; i++)
+ close(i);
+ if (resetsig) {
+ signal(SIGINT, SIG_DFL);
+ signal(SIGQUIT, SIG_DFL);
+ }
+ if (t->type == TPAREN)
+ exit(execute(t->left, NOPIPE, NOPIPE, FEXEC));
+ if (wp[0] == NULL)
+ exit(0);
+
+ cp = rexecve(wp[0], wp, makenv());
+ prs(wp[0]); prs(": "); warn(cp);
+ if (!execflg)
+ trap[0] = NULL;
+ leave();
+ /* NOTREACHED */
+ exit(1);
+}
+
+/*
+ * 0< 1> are ignored as required
+ * within pipelines.
+ */
+static int
+iosetup(iop, pipein, pipeout)
+register struct ioword *iop;
+int pipein, pipeout;
+{
+ register int u = -1;
+ char *cp=NULL, *msg;
+
+ if (iop->io_unit == IODEFAULT) /* take default */
+ iop->io_unit = iop->io_flag&(IOREAD|IOHERE)? 0: 1;
+ if (pipein && iop->io_unit == 0)
+ return(0);
+ if (pipeout && iop->io_unit == 1)
+ return(0);
+ msg = iop->io_flag&(IOREAD|IOHERE)? "open": "create";
+ if ((iop->io_flag & IOHERE) == 0) {
+ cp = iop->io_name;
+ if ((cp = evalstr(cp, DOSUB|DOTRIM)) == NULL)
+ return(1);
+ }
+ if (iop->io_flag & IODUP) {
+ if (cp[1] || (!isdigit(*cp) && *cp != '-')) {
+ prs(cp);
+ err(": illegal >& argument");
+ return(1);
+ }
+ if (*cp == '-')
+ iop->io_flag = IOCLOSE;
+ iop->io_flag &= ~(IOREAD|IOWRITE);
+ }
+ switch (iop->io_flag) {
+ case IOREAD:
+ u = open(cp, 0);
+ break;
+
+ case IOHERE:
+ case IOHERE|IOXHERE:
+ u = herein(iop->io_name, iop->io_flag&IOXHERE);
+ cp = "here file";
+ break;
+
+ case IOWRITE|IOCAT:
+ if ((u = open(cp, 1)) >= 0) {
+ lseek(u, (long)0, 2);
+ break;
+ }
+ case IOWRITE:
+ u = creat(cp, 0666);
+ break;
+
+ case IODUP:
+ u = dup2(*cp-'0', iop->io_unit);
+ break;
+
+ case IOCLOSE:
+ close(iop->io_unit);
+ return(0);
+ }
+ if (u < 0) {
+ prs(cp);
+ prs(": cannot ");
+ warn(msg);
+ return(1);
+ } else {
+ if (u != iop->io_unit) {
+ dup2(u, iop->io_unit);
+ close(u);
+ }
+ }
+ return(0);
+}
+
+static void
+echo(wp)
+register char **wp;
+{
+ register int i;
+
+ prs("+");
+ for (i=0; wp[i]; i++) {
+ if (i)
+ prs(" ");
+ prs(wp[i]);
+ }
+ prs("\n");
+}
+
+static struct op **
+find1case(t, w)
+struct op *t;
+char *w;
+{
+ register struct op *t1;
+ struct op **tp;
+ register char **wp, *cp;
+
+ if (t == NULL)
+ return((struct op **)NULL);
+ if (t->type == TLIST) {
+ if ((tp = find1case(t->left, w)) != NULL)
+ return(tp);
+ t1 = t->right; /* TPAT */
+ } else
+ t1 = t;
+ for (wp = t1->words; *wp;)
+ if ((cp = evalstr(*wp++, DOSUB)) && gmatch(w, cp))
+ return(&t1->left);
+ return((struct op **)NULL);
+}
+
+static struct op *
+findcase(t, w)
+struct op *t;
+char *w;
+{
+ register struct op **tp;
+
+ return((tp = find1case(t, w)) != NULL? *tp: (struct op *)NULL);
+}
+
+/*
+ * Enter a new loop level (marked for break/continue).
+ */
+static void
+brkset(bc)
+struct brkcon *bc;
+{
+ bc->nextlev = brklist;
+ brklist = bc;
+}
+
+/*
+ * Wait for the last process created.
+ * Print a message for each process found
+ * that was killed by a signal.
+ * Ignore interrupt signals while waiting
+ * unless `canintr' is true.
+ */
+static int
+waitfor(lastpid, canintr)
+register int lastpid;
+int canintr;
+{
+ register int pid, rv;
+ int s;
+ int oheedint = heedint;
+
+ heedint = 0;
+ rv = 0;
+ do {
+ pid = wait(&s);
+ if (pid == -1) {
+ if (errno != EINTR || canintr)
+ break;
+ } else {
+ if ((rv = WAITSIG(s)) != 0) {
+ if (rv < NSIGNAL) {
+ if (signame[rv] != NULL) {
+ if (pid != lastpid) {
+ prn(pid);
+ prs(": ");
+ }
+ prs(signame[rv]);
+ }
+ } else {
+ if (pid != lastpid) {
+ prn(pid);
+ prs(": ");
+ }
+ prs("Signal "); prn(rv); prs(" ");
+ }
+ if (WAITCORE(s))
+ prs(" - core dumped");
+ if (rv >= NSIGNAL || signame[rv])
+ prs("\n");
+ rv = -1;
+ } else
+ rv = WAITVAL(s);
+ }
+ } while (pid != lastpid);
+ heedint = oheedint;
+ if (intr) {
+ if (interactive) {
+ if (canintr)
+ intr = 0;
+ } else {
+ if (exstat == 0) exstat = rv;
+ onintr(0);
+ }
+ }
+ return(rv);
+}
+
+static int
+setstatus(s)
+register int s;
+{
+ exstat = s;
+ setval(lookup("?"), putn(s));
+ return(s);
+}
+
+/*
+ * PATH-searching interface to execve.
+ * If getenv("PATH") were kept up-to-date,
+ * execvp might be used.
+ */
+static char *
+rexecve(c, v, envp)
+char *c, **v, **envp;
+{
+ register int i;
+ register char *sp, *tp;
+ int eacces = 0, asis = 0;
+
+#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
+ char *name = c;
+#ifdef CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN
+ name = bb_get_last_path_component(name);
+#endif
+ optind = 1;
+ if (find_applet_by_name(name)) {
+ /* We have to exec here since we vforked. Running
+ * run_applet_by_name() won't work and bad things
+ * will happen. */
+ execve("/proc/self/exe", v, envp);
+ execve("busybox", v, envp);
+ }
+#endif
+
+ sp = any('/', c)? "": path->value;
+ asis = *sp == '\0';
+ while (asis || *sp != '\0') {
+ asis = 0;
+ tp = e.linep;
+ for (; *sp != '\0'; tp++)
+ if ((*tp = *sp++) == ':') {
+ asis = *sp == '\0';
+ break;
+ }
+ if (tp != e.linep)
+ *tp++ = '/';
+ for (i = 0; (*tp++ = c[i++]) != '\0';)
+ ;
+
+ execve(e.linep, v, envp);
+ switch (errno) {
+ case ENOEXEC:
+ *v = e.linep;
+ tp = *--v;
+ *v = e.linep;
+ execve(shellname, v, envp);
+ *v = tp;
+ return("no Shell");
+
+ case ENOMEM:
+ return((char*)bb_msg_memory_exhausted);
+
+ case E2BIG:
+ return("argument list too long");
+
+ case EACCES:
+ eacces++;
+ break;
+ }
+ }
+ return(errno==ENOENT ? "not found" : "cannot execute");
+}
+
+/*
+ * Run the command produced by generator `f'
+ * applied to stream `arg'.
+ */
+static int
+run(struct ioarg *argp, int (*f)(struct ioarg *))
+{
+ struct op *otree;
+ struct wdblock *swdlist;
+ struct wdblock *siolist;
+ jmp_buf ev, rt;
+ xint *ofail;
+ int rv;
+
+#if __GNUC__
+ /* Avoid longjmp clobbering */
+ (void) &rv;
+#endif
+
+ areanum++;
+ swdlist = wdlist;
+ siolist = iolist;
+ otree = outtree;
+ ofail = failpt;
+ rv = -1;
+ if (newenv(setjmp(errpt = ev)) == 0) {
+ wdlist = 0;
+ iolist = 0;
+ pushio(argp, f);
+ e.iobase = e.iop;
+ yynerrs = 0;
+ if (setjmp(failpt = rt) == 0 && yyparse() == 0)
+ rv = execute(outtree, NOPIPE, NOPIPE, 0);
+ quitenv();
+ }
+ wdlist = swdlist;
+ iolist = siolist;
+ failpt = ofail;
+ outtree = otree;
+ freearea(areanum--);
+ return(rv);
+}
+
+/* -------- do.c -------- */
+
+/*
+ * built-in commands: doX
+ */
+
+static int dohelp(struct op *t )
+{
+ int col;
+ const struct builtincmd *x;
+
+ printf("\nBuilt-in commands:\n");
+ printf("-------------------\n");
+
+ for (col=0, x = builtincmds; x->builtinfunc != NULL; x++) {
+ if (!x->name)
+ continue;
+ col += printf("%s%s", ((col == 0) ? "\t" : " "), x->name);
+ if (col > 60) {
+ printf("\n");
+ col = 0;
+ }
+ }
+#ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
+ {
+ int i;
+ const struct BB_applet *applet;
+ extern const struct BB_applet applets[];
+ extern const size_t NUM_APPLETS;
+
+ for (i=0, applet = applets; i < NUM_APPLETS; applet++, i++) {
+ if (!applet->name)
+ continue;
+
+ col += printf("%s%s", ((col == 0) ? "\t" : " "),
+ applet->name);
+ if (col > 60) {
+ printf("\n");
+ col = 0;
+ }
+ }
+ }
+#endif
+ printf("\n\n");
+ return EXIT_SUCCESS;
+}
+
+
+
+static int dolabel(struct op *t )
+{
+ return(0);
+}
+
+static int
+dochdir(t)
+register struct op *t;
+{
+ register char *cp, *er;
+
+ if ((cp = t->words[1]) == NULL && (cp = homedir->value) == NULL)
+ er = ": no home directory";
+ else if(chdir(cp) < 0)
+ er = ": bad directory";
+ else
+ return(0);
+ prs(cp != NULL? cp: "cd");
+ err(er);
+ return(1);
+}
+
+static int
+doshift(t)
+register struct op *t;
+{
+ register int n;
+
+ n = t->words[1]? getn(t->words[1]): 1;
+ if(dolc < n) {
+ err("nothing to shift");
+ return(1);
+ }
+ dolv[n] = dolv[0];
+ dolv += n;
+ dolc -= n;
+ setval(lookup("#"), putn(dolc));
+ return(0);
+}
+
+/*
+ * execute login and newgrp directly
+ */
+static int
+dologin(t)
+struct op *t;
+{
+ register char *cp;
+
+ if (interactive) {
+ signal(SIGINT, SIG_DFL);
+ signal(SIGQUIT, SIG_DFL);
+ }
+ cp = rexecve(t->words[0], t->words, makenv());
+ prs(t->words[0]); prs(": "); err(cp);
+ return(1);
+}
+
+static int
+doumask(t)
+register struct op *t;
+{
+ register int i, n;
+ register char *cp;
+
+ if ((cp = t->words[1]) == NULL) {
+ i = umask(0);
+ umask(i);
+ for (n=3*4; (n-=3) >= 0;)
+ putc('0'+((i>>n)&07), stderr);
+ putc('\n', stderr);
+ } else {
+ for (n=0; *cp>='0' && *cp<='9'; cp++)
+ n = n*8 + (*cp-'0');
+ umask(n);
+ }
+ return(0);
+}
+
+static int
+doexec(t)
+register struct op *t;
+{
+ register int i;
+ jmp_buf ex;
+ xint *ofail;
+
+ t->ioact = NULL;
+ for(i = 0; (t->words[i]=t->words[i+1]) != NULL; i++)
+ ;
+ if (i == 0)
+ return(1);
+ execflg = 1;
+ ofail = failpt;
+ if (setjmp(failpt = ex) == 0)
+ execute(t, NOPIPE, NOPIPE, FEXEC);
+ failpt = ofail;
+ execflg = 0;
+ return(1);
+}
+
+static int
+dodot(t)
+struct op *t;
+{
+ register int i;
+ register char *sp, *tp;
+ char *cp;
+
+ if ((cp = t->words[1]) == NULL)
+ return(0);
+ sp = any('/', cp)? ":": path->value;
+ while (*sp) {
+ tp = e.linep;
+ while (*sp && (*tp = *sp++) != ':')
+ tp++;
+ if (tp != e.linep)
+ *tp++ = '/';
+ for (i = 0; (*tp++ = cp[i++]) != '\0';)
+ ;
+ if ((i = open(e.linep, 0)) >= 0) {
+ exstat = 0;
+ next(remap(i));
+ return(exstat);
+ }
+ }
+ prs(cp);
+ err(": not found");
+ return(-1);
+}
+
+static int
+dowait(t)
+struct op *t;
+{
+ register int i;
+ register char *cp;
+
+ if ((cp = t->words[1]) != NULL) {
+ i = getn(cp);
+ if (i == 0)
+ return(0);
+ } else
+ i = -1;
+ setstatus(waitfor(i, 1));
+ return(0);
+}
+
+static int
+doread(t)
+struct op *t;
+{
+ register char *cp, **wp;
+ register int nb = 0;
+ register int nl = 0;
+
+ if (t->words[1] == NULL) {
+ err("Usage: read name ...");
+ return(1);
+ }
+ for (wp = t->words+1; *wp; wp++) {
+ for (cp = e.linep; !nl && cp < elinep-1; cp++)
+ if ((nb = read(0, cp, sizeof(*cp))) != sizeof(*cp) ||
+ (nl = (*cp == '\n')) ||
+ (wp[1] && any(*cp, ifs->value)))
+ break;
+ *cp = 0;
+ if (nb <= 0)
+ break;
+ setval(lookup(*wp), e.linep);
+ }
+ return(nb <= 0);
+}
+
+static int
+doeval(t)
+register struct op *t;
+{
+ return(RUN(awordlist, t->words+1, wdchar));
+}
+
+static int
+dotrap(t)
+register struct op *t;
+{
+ register int n, i;
+ register int resetsig;
+
+ if (t->words[1] == NULL) {
+ for (i=0; i<=_NSIG; i++)
+ if (trap[i]) {
+ prn(i);
+ prs(": ");
+ prs(trap[i]);
+ prs("\n");
+ }
+ return(0);
+ }
+ resetsig = isdigit(*t->words[1]);
+ for (i = resetsig ? 1 : 2; t->words[i] != NULL; ++i) {
+ n = getsig(t->words[i]);
+ freecell(trap[n]);
+ trap[n] = 0;
+ if (!resetsig) {
+ if (*t->words[1] != '\0') {
+ trap[n] = strsave(t->words[1], 0);
+ setsig(n, sig);
+ } else
+ setsig(n, SIG_IGN);
+ } else {
+ if (interactive)
+ if (n == SIGINT)
+ setsig(n, onintr);
+ else
+ setsig(n, n == SIGQUIT ? SIG_IGN
+ : SIG_DFL);
+ else
+ setsig(n, SIG_DFL);
+ }
+ }
+ return(0);
+}
+
+static int
+getsig(s)
+char *s;
+{
+ register int n;
+
+ if ((n = getn(s)) < 0 || n > _NSIG) {
+ err("trap: bad signal number");
+ n = 0;
+ }
+ return(n);
+}
+
+static void
+setsig( register int n, sighandler_t f)
+{
+ if (n == 0)
+ return;
+ if (signal(n, SIG_IGN) != SIG_IGN || ourtrap[n]) {
+ ourtrap[n] = 1;
+ signal(n, f);
+ }
+}
+
+static int
+getn(as)
+char *as;
+{
+ register char *s;
+ register int n, m;
+
+ s = as;
+ m = 1;
+ if (*s == '-') {
+ m = -1;
+ s++;
+ }
+ for (n = 0; isdigit(*s); s++)
+ n = (n*10) + (*s-'0');
+ if (*s) {
+ prs(as);
+ err(": bad number");
+ }
+ return(n*m);
+}
+
+static int
+dobreak(t)
+struct op *t;
+{
+ return(brkcontin(t->words[1], 1));
+}
+
+static int
+docontinue(t)
+struct op *t;
+{
+ return(brkcontin(t->words[1], 0));
+}
+
+static int
+brkcontin(cp, val)
+register char *cp;
+int val;
+{
+ register struct brkcon *bc;
+ register int nl;
+
+ nl = cp == NULL? 1: getn(cp);
+ if (nl <= 0)
+ nl = 999;
+ do {
+ if ((bc = brklist) == NULL)
+ break;
+ brklist = bc->nextlev;
+ } while (--nl);
+ if (nl) {
+ err("bad break/continue level");
+ return(1);
+ }
+ isbreak = val;
+ longjmp(bc->brkpt, 1);
+ /* NOTREACHED */
+}
+
+static int
+doexit(t)
+struct op *t;
+{
+ register char *cp;
+
+ execflg = 0;
+ if ((cp = t->words[1]) != NULL)
+ setstatus(getn(cp));
+ leave();
+ /* NOTREACHED */
+ return(0);
+}
+
+static int
+doexport(t)
+struct op *t;
+{
+ rdexp(t->words+1, export, EXPORT);
+ return(0);
+}
+
+static int
+doreadonly(t)
+struct op *t;
+{
+ rdexp(t->words+1, ronly, RONLY);
+ return(0);
+}
+
+static void rdexp (char **wp, void (*f)(struct var *), int key)
+{
+ if (*wp != NULL) {
+ for (; *wp != NULL; wp++) {
+ if (isassign(*wp)) {
+ char *cp;
+ assign(*wp, COPYV);
+ for (cp = *wp; *cp != '='; cp++)
+ ;
+ *cp = '\0';
+ }
+ if (checkname(*wp))
+ (*f)(lookup(*wp));
+ else
+ badid(*wp);
+ }
+ } else
+ putvlist(key, 1);
+}
+
+static void
+badid(s)
+register char *s;
+{
+ prs(s);
+ err(": bad identifier");
+}
+
+static int
+doset(t)
+register struct op *t;
+{
+ register struct var *vp;
+ register char *cp;
+ register int n;
+
+ if ((cp = t->words[1]) == NULL) {
+ for (vp = vlist; vp; vp = vp->next)
+ varput(vp->name, 1);
+ return(0);
+ }
+ if (*cp == '-') {
+ /* bad: t->words++; */
+ for(n = 0; (t->words[n]=t->words[n+1]) != NULL; n++)
+ ;
+ if (*++cp == 0)
+ flag['x'] = flag['v'] = 0;
+ else
+ for (; *cp; cp++)
+ switch (*cp) {
+ case 'e':
+ if (!interactive)
+ flag['e']++;
+ break;
+
+ default:
+ if (*cp>='a' && *cp<='z')
+ flag[(int)*cp]++;
+ break;
+ }
+ setdash();
+ }
+ if (t->words[1]) {
+ t->words[0] = dolv[0];
+ for (n=1; t->words[n]; n++)
+ setarea((char *)t->words[n], 0);
+ dolc = n-1;
+ dolv = t->words;
+ setval(lookup("#"), putn(dolc));
+ setarea((char *)(dolv-1), 0);
+ }
+ return(0);
+}
+
+static void
+varput(s, out)
+register char *s;
+int out;
+{
+ if (isalnum(*s) || *s == '_') {
+ write(out, s, strlen(s));
+ write(out, "\n", 1);
+ }
+}
+
+
+/*
+ * Copyright (c) 1999 Herbert Xu <herbert@debian.org>
+ * This file contains code for the times builtin.
+ */
+static int dotimes(struct op *t )
+{
+ struct tms buf;
+ long int clk_tck = sysconf(_SC_CLK_TCK);
+
+ times(&buf);
+ printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n",
+ (int) (buf.tms_utime / clk_tck / 60),
+ ((double) buf.tms_utime) / clk_tck,
+ (int) (buf.tms_stime / clk_tck / 60),
+ ((double) buf.tms_stime) / clk_tck,
+ (int) (buf.tms_cutime / clk_tck / 60),
+ ((double) buf.tms_cutime) / clk_tck,
+ (int) (buf.tms_cstime / clk_tck / 60),
+ ((double) buf.tms_cstime) / clk_tck);
+ return 0;
+}
+
+
+static int(*inbuilt(char *s))(struct op *)
+{
+ const struct builtincmd *bp;
+
+ for (bp = builtincmds; bp->name != NULL; bp++)
+ if (strcmp(bp->name, s) == 0)
+ return(bp->builtinfunc);
+
+ return(NULL);
+}
+
+/* -------- eval.c -------- */
+
+/*
+ * ${}
+ * `command`
+ * blank interpretation
+ * quoting
+ * glob
+ */
+
+static char ** eval( char **ap, int f)
+{
+ struct wdblock *wb;
+ char **wp;
+ char **wf;
+ jmp_buf ev;
+
+#if __GNUC__
+ /* Avoid longjmp clobbering */
+ (void) &wp;
+ (void) &ap;
+#endif
+ wp = NULL;
+ wb = NULL;
+ wf = NULL;
+ if (newenv(setjmp(errpt = ev)) == 0) {
+ while (*ap && isassign(*ap))
+ expand(*ap++, &wb, f & ~DOGLOB);
+ if (flag['k']) {
+ for (wf = ap; *wf; wf++) {
+ if (isassign(*wf))
+ expand(*wf, &wb, f & ~DOGLOB);
+ }
+ }
+ for (wb = addword((char *)0, wb); *ap; ap++) {
+ if (!flag['k'] || !isassign(*ap))
+ expand(*ap, &wb, f & ~DOKEY);
+ }
+ wb = addword((char *)0, wb);
+ wp = getwords(wb);
+ quitenv();
+ } else
+ gflg = 1;
+ return(gflg? (char **)NULL: wp);
+}
+
+/*
+ * Make the exported environment from the exported
+ * names in the dictionary. Keyword assignments
+ * will already have been done.
+ */
+static char **
+makenv()
+
+{
+ register struct wdblock *wb;
+ register struct var *vp;
+
+ wb = NULL;
+ for (vp = vlist; vp; vp = vp->next)
+ if (vp->status & EXPORT)
+ wb = addword(vp->name, wb);
+ wb = addword((char *)0, wb);
+ return(getwords(wb));
+}
+
+static char *
+evalstr(cp, f)
+register char *cp;
+int f;
+{
+ struct wdblock *wb;
+
+ wb = NULL;
+ if (expand(cp, &wb, f)) {
+ if (wb == NULL || wb->w_nword == 0 || (cp = wb->w_words[0]) == NULL)
+ cp = "";
+ DELETE(wb);
+ } else
+ cp = NULL;
+ return(cp);
+}
+
+static int
+expand( char *cp, register struct wdblock **wbp, int f)
+{
+ jmp_buf ev;
+
+#if __GNUC__
+ /* Avoid longjmp clobbering */
+ (void) &cp;
+#endif
+ gflg = 0;
+ if (cp == NULL)
+ return(0);
+ if (!anys("$`'\"", cp) &&
+ !anys(ifs->value, cp) &&
+ ((f&DOGLOB)==0 || !anys("[*?", cp))) {
+ cp = strsave(cp, areanum);
+ if (f & DOTRIM)
+ unquote(cp);
+ *wbp = addword(cp, *wbp);
+ return(1);
+ }
+ if (newenv(setjmp(errpt = ev)) == 0) {
+ PUSHIO(aword, cp, strchar);
+ e.iobase = e.iop;
+ while ((cp = blank(f)) && gflg == 0) {
+ e.linep = cp;
+ cp = strsave(cp, areanum);
+ if ((f&DOGLOB) == 0) {
+ if (f & DOTRIM)
+ unquote(cp);
+ *wbp = addword(cp, *wbp);
+ } else
+ *wbp = glob(cp, *wbp);
+ }
+ quitenv();
+ } else
+ gflg = 1;
+ return(gflg == 0);
+}
+
+/*
+ * Blank interpretation and quoting
+ */
+static char *
+blank(f)
+int f;
+{
+ register int c, c1;
+ register char *sp;
+ int scanequals, foundequals;
+
+ sp = e.linep;
+ scanequals = f & DOKEY;
+ foundequals = 0;
+
+loop:
+ switch (c = subgetc('"', foundequals)) {
+ case 0:
+ if (sp == e.linep)
+ return(0);
+ *e.linep++ = 0;
+ return(sp);
+
+ default:
+ if (f & DOBLANK && any(c, ifs->value))
+ goto loop;
+ break;
+
+ case '"':
+ case '\'':
+ scanequals = 0;
+ if (INSUB())
+ break;
+ for (c1 = c; (c = subgetc(c1, 1)) != c1;) {
+ if (c == 0)
+ break;
+ if (c == '\'' || !any(c, "$`\""))
+ c |= QUOTE;
+ *e.linep++ = c;
+ }
+ c = 0;
+ }
+ unget(c);
+ if (!isalpha(c) && c != '_')
+ scanequals = 0;
+ for (;;) {
+ c = subgetc('"', foundequals);
+ if (c == 0 ||
+ f & (DOBLANK && any(c, ifs->value)) ||
+ (!INSUB() && any(c, "\"'"))) {
+ scanequals = 0;
+ unget(c);
+ if (any(c, "\"'"))
+ goto loop;
+ break;
+ }
+ if (scanequals) {
+ if (c == '=') {
+ foundequals = 1;
+ scanequals = 0;
+ }
+ else if (!isalnum(c) && c != '_')
+ scanequals = 0;
+ }
+ *e.linep++ = c;
+ }
+ *e.linep++ = 0;
+ return(sp);
+}
+
+/*
+ * Get characters, substituting for ` and $
+ */
+static int
+subgetc(ec, quoted)
+register char ec;
+int quoted;
+{
+ register char c;
+
+again:
+ c = my_getc(ec);
+ if (!INSUB() && ec != '\'') {
+ if (c == '`') {
+ if (grave(quoted) == 0)
+ return(0);
+ e.iop->task = XGRAVE;
+ goto again;
+ }
+ if (c == '$' && (c = dollar(quoted)) == 0) {
+ e.iop->task = XDOLL;
+ goto again;
+ }
+ }
+ return(c);
+}
+
+/*
+ * Prepare to generate the string returned by ${} substitution.
+ */
+static int
+dollar(quoted)
+int quoted;
+{
+ int otask;
+ struct io *oiop;
+ char *dolp;
+ register char *s, c, *cp=NULL;
+ struct var *vp;
+
+ c = readc();
+ s = e.linep;
+ if (c != '{') {
+ *e.linep++ = c;
+ if (isalpha(c) || c == '_') {
+ while ((c = readc())!=0 && (isalnum(c) || c == '_'))
+ if (e.linep < elinep)
+ *e.linep++ = c;
+ unget(c);
+ }
+ c = 0;
+ } else {
+ oiop = e.iop;
+ otask = e.iop->task;
+ e.iop->task = XOTHER;
+ while ((c = subgetc('"', 0))!=0 && c!='}' && c!='\n')
+ if (e.linep < elinep)
+ *e.linep++ = c;
+ if (oiop == e.iop)
+ e.iop->task = otask;
+ if (c != '}') {
+ err("unclosed ${");
+ gflg++;
+ return(c);
+ }
+ }
+ if (e.linep >= elinep) {
+ err("string in ${} too long");
+ gflg++;
+ e.linep -= 10;
+ }
+ *e.linep = 0;
+ if (*s)
+ for (cp = s+1; *cp; cp++)
+ if (any(*cp, "=-+?")) {
+ c = *cp;
+ *cp++ = 0;
+ break;
+ }
+ if (s[1] == 0 && (*s == '*' || *s == '@')) {
+ if (dolc > 1) {
+ /* currently this does not distinguish $* and $@ */
+ /* should check dollar */
+ e.linep = s;
+ PUSHIO(awordlist, dolv+1, dolchar);
+ return(0);
+ } else { /* trap the nasty ${=} */
+ s[0] = '1';
+ s[1] = 0;
+ }
+ }
+ vp = lookup(s);
+ if ((dolp = vp->value) == null) {
+ switch (c) {
+ case '=':
+ if (isdigit(*s)) {
+ err("cannot use ${...=...} with $n");
+ gflg++;
+ break;
+ }
+ setval(vp, cp);
+ dolp = vp->value;
+ break;
+
+ case '-':
+ dolp = strsave(cp, areanum);
+ break;
+
+ case '?':
+ if (*cp == 0) {
+ prs("missing value for ");
+ err(s);
+ } else
+ err(cp);
+ gflg++;
+ break;
+ }
+ } else if (c == '+')
+ dolp = strsave(cp, areanum);
+ if (flag['u'] && dolp == null) {
+ prs("unset variable: ");
+ err(s);
+ gflg++;
+ }
+ e.linep = s;
+ PUSHIO(aword, dolp, quoted ? qstrchar : strchar);
+ return(0);
+}
+
+/*
+ * Run the command in `...` and read its output.
+ */
+
+static int
+grave(quoted)
+int quoted;
+{
+ char *cp;
+ register int i;
+ int j;
+ int pf[2];
+ static char child_cmd[LINELIM];
+ char *src;
+ char *dest;
+ int count;
+ int ignore;
+ int ignore_once;
+ char *argument_list[4];
+
+#if __GNUC__
+ /* Avoid longjmp clobbering */
+ (void) &cp;
+#endif
+
+ for (cp = e.iop->argp->aword; *cp != '`'; cp++)
+ if (*cp == 0) {
+ err("no closing `");
+ return(0);
+ }
+
+ /* string copy with dollar expansion */
+ src = e.iop->argp->aword;
+ dest = child_cmd;
+ count = 0;
+ ignore = 0;
+ ignore_once = 0;
+ while ((*src != '`') && (count < LINELIM)) {
+ if (*src == '\'')
+ ignore = !ignore;
+ if (*src == '\\')
+ ignore_once = 1;
+ if (*src == '$' && !ignore && !ignore_once) {
+ struct var *vp;
+ char var_name[LINELIM];
+ char alt_value[LINELIM];
+ int var_index = 0;
+ int alt_index = 0;
+ char operator = 0;
+ int braces = 0;
+ char *value;
+
+ src++;
+ if (*src == '{') {
+ braces = 1;
+ src++;
+ }
+
+ var_name[var_index++] = *src++;
+ while (isalnum(*src))
+ var_name[var_index++] = *src++;
+ var_name[var_index] = 0;
+
+ if (braces) {
+ switch (*src) {
+ case '}':
+ break;
+ case '-':
+ case '=':
+ case '+':
+ case '?':
+ operator = *src;
+ break;
+ default:
+ err("unclosed ${\n");
+ return(0);
+ }
+ if (operator) {
+ src++;
+ while (*src && (*src != '}')) {
+ alt_value[alt_index++] = *src++;
+ }
+ alt_value[alt_index] = 0;
+ if (*src != '}') {
+ err("unclosed ${\n");
+ return(0);
+ }
+ }
+ src++;
+ }
+
+ vp = lookup(var_name);
+ if (vp->value != null)
+ value = (operator == '+')? alt_value : vp->value;
+ else if (operator == '?') {
+ err(alt_value);
+ return(0);
+ } else if (alt_index && (operator != '+')) {
+ value = alt_value;
+ if (operator == '=')
+ setval(vp, value);
+ } else
+ continue;
+
+ while (*value && (count < LINELIM)) {
+ *dest++ = *value++;
+ count++;
+ }
+ } else {
+ *dest++ = *src++;
+ count++;
+ ignore_once = 0;
+ }
+ }
+ *dest = '\0';
+
+ if (openpipe(pf) < 0)
+ return(0);
+ while ((i = vfork()) == -1 && errno == EAGAIN)
+ ;
+ if (i < 0) {
+ closepipe(pf);
+ err((char*)bb_msg_memory_exhausted);
+ return(0);
+ }
+ if (i != 0) {
+ waitpid(i, NULL, 0);
+ e.iop->argp->aword = ++cp;
+ close(pf[1]);
+ PUSHIO(afile, remap(pf[0]), (int(*)(struct ioarg *))((quoted)? qgravechar: gravechar));
+ return(1);
+ }
+ /* allow trapped signals */
+ /* XXX - Maybe this signal stuff should go as well? */
+ for (j=0; j<=_NSIG; j++)
+ if (ourtrap[j] && signal(j, SIG_IGN) != SIG_IGN)
+ signal(j, SIG_DFL);
+
+ dup2(pf[1], 1);
+ closepipe(pf);
+
+ argument_list[0] = shellname;
+ argument_list[1] = "-c";
+ argument_list[2] = child_cmd;
+ argument_list[3] = 0;
+
+ prs(rexecve(argument_list[0], argument_list, makenv()));
+ _exit(1);
+}
+
+
+static char *
+unquote(as)
+register char *as;
+{
+ register char *s;
+
+ if ((s = as) != NULL)
+ while (*s)
+ *s++ &= ~QUOTE;
+ return(as);
+}
+
+/* -------- glob.c -------- */
+
+/*
+ * glob
+ */
+
+#define scopy(x) strsave((x), areanum)
+#define BLKSIZ 512
+#define NDENT ((BLKSIZ+sizeof(struct dirent)-1)/sizeof(struct dirent))
+
+static struct wdblock *cl, *nl;
+static char spcl[] = "[?*";
+
+static struct wdblock *
+glob(cp, wb)
+char *cp;
+struct wdblock *wb;
+{
+ register int i;
+ register char *pp;
+
+ if (cp == 0)
+ return(wb);
+ i = 0;
+ for (pp = cp; *pp; pp++)
+ if (any(*pp, spcl))
+ i++;
+ else if (!any(*pp & ~QUOTE, spcl))
+ *pp &= ~QUOTE;
+ if (i != 0) {
+ for (cl = addword(scopy(cp), (struct wdblock *)0); anyspcl(cl); cl = nl) {
+ nl = newword(cl->w_nword*2);
+ for(i=0; i<cl->w_nword; i++) { /* for each argument */
+ for (pp = cl->w_words[i]; *pp; pp++)
+ if (any(*pp, spcl)) {
+ globname(cl->w_words[i], pp);
+ break;
+ }
+ if (*pp == '\0')
+ nl = addword(scopy(cl->w_words[i]), nl);
+ }
+ for(i=0; i<cl->w_nword; i++)
+ DELETE(cl->w_words[i]);
+ DELETE(cl);
+ }
+ for(i=0; i<cl->w_nword; i++)
+ unquote(cl->w_words[i]);
+ glob0((char *)cl->w_words, cl->w_nword, sizeof(char *), xstrcmp);
+ if (cl->w_nword) {
+ for (i=0; i<cl->w_nword; i++)
+ wb = addword(cl->w_words[i], wb);
+ DELETE(cl);
+ return(wb);
+ }
+ }
+ wb = addword(unquote(cp), wb);
+ return(wb);
+}
+
+static void
+globname(we, pp)
+char *we;
+register char *pp;
+{
+ register char *np, *cp;
+ char *name, *gp, *dp;
+ int k;
+ DIR *dirp;
+ struct dirent *de;
+ char dname[NAME_MAX+1];
+ struct stat dbuf;
+
+ for (np = we; np != pp; pp--)
+ if (pp[-1] == '/')
+ break;
+ for (dp = cp = space((int)(pp-np)+3); np < pp;)
+ *cp++ = *np++;
+ *cp++ = '.';
+ *cp = '\0';
+ for (gp = cp = space(strlen(pp)+1); *np && *np != '/';)
+ *cp++ = *np++;
+ *cp = '\0';
+ dirp = opendir(dp);
+ if (dirp == 0) {
+ DELETE(dp);
+ DELETE(gp);
+ return;
+ }
+ dname[NAME_MAX] = '\0';
+ while ((de=readdir(dirp))!=NULL) {
+ /* XXX Hmmm... What this could be? (abial) */
+ /*
+ if (ent[j].d_ino == 0)
+ continue;
+ */
+ strncpy(dname, de->d_name, NAME_MAX);
+ if (dname[0] == '.')
+ if (*gp != '.')
+ continue;
+ for(k=0; k<NAME_MAX; k++)
+ if (any(dname[k], spcl))
+ dname[k] |= QUOTE;
+ if (gmatch(dname, gp)) {
+ name = generate(we, pp, dname, np);
+ if (*np && !anys(np, spcl)) {
+ if (stat(name,&dbuf)) {
+ DELETE(name);
+ continue;
+ }
+ }
+ nl = addword(name, nl);
+ }
+ }
+ closedir(dirp);
+ DELETE(dp);
+ DELETE(gp);
+}
+
+/*
+ * generate a pathname as below.
+ * start..end1 / middle end
+ * the slashes come for free
+ */
+static char *
+generate(start1, end1, middle, end)
+char *start1;
+register char *end1;
+char *middle, *end;
+{
+ char *p;
+ register char *op, *xp;
+
+ p = op = space((int)(end1-start1)+strlen(middle)+strlen(end)+2);
+ for (xp = start1; xp != end1;)
+ *op++ = *xp++;
+ for (xp = middle; (*op++ = *xp++) != '\0';)
+ ;
+ op--;
+ for (xp = end; (*op++ = *xp++) != '\0';)
+ ;
+ return(p);
+}
+
+static int
+anyspcl(wb)
+register struct wdblock *wb;
+{
+ register int i;
+ register char **wd;
+
+ wd = wb->w_words;
+ for (i=0; i<wb->w_nword; i++)
+ if (anys(spcl, *wd++))
+ return(1);
+ return(0);
+}
+
+static int
+xstrcmp(p1, p2)
+char *p1, *p2;
+{
+ return(strcmp(*(char **)p1, *(char **)p2));
+}
+
+/* -------- word.c -------- */
+
+static struct wdblock *
+newword(nw)
+register int nw;
+{
+ register struct wdblock *wb;
+
+ wb = (struct wdblock *) space(sizeof(*wb) + nw*sizeof(char *));
+ wb->w_bsize = nw;
+ wb->w_nword = 0;
+ return(wb);
+}
+
+static struct wdblock *
+addword(wd, wb)
+char *wd;
+register struct wdblock *wb;
+{
+ register struct wdblock *wb2;
+ register int nw;
+
+ if (wb == NULL)
+ wb = newword(NSTART);
+ if ((nw = wb->w_nword) >= wb->w_bsize) {
+ wb2 = newword(nw * 2);
+ memcpy((char *)wb2->w_words, (char *)wb->w_words, nw*sizeof(char *));
+ wb2->w_nword = nw;
+ DELETE(wb);
+ wb = wb2;
+ }
+ wb->w_words[wb->w_nword++] = wd;
+ return(wb);
+}
+static
+char **
+getwords(wb)
+register struct wdblock *wb;
+{
+ register char **wd;
+ register int nb;
+
+ if (wb == NULL)
+ return((char **)NULL);
+ if (wb->w_nword == 0) {
+ DELETE(wb);
+ return((char **)NULL);
+ }
+ wd = (char **) space(nb = sizeof(*wd) * wb->w_nword);
+ memcpy((char *)wd, (char *)wb->w_words, nb);
+ DELETE(wb); /* perhaps should done by caller */
+ return(wd);
+}
+
+int (*func)(char *, char *);
+int globv;
+
+static void
+glob0(a0, a1, a2, a3)
+char *a0;
+unsigned a1;
+int a2;
+int (*a3) (char *, char *);
+{
+ func = a3;
+ globv = a2;
+ glob1(a0, a0 + a1 * a2);
+}
+
+static void
+glob1(base, lim)
+char *base, *lim;
+{
+ register char *i, *j;
+ int v2;
+ char *lptr, *hptr;
+ int c;
+ unsigned n;
+
+
+ v2 = globv;
+
+top:
+ if ((n=(int)(lim-base)) <= v2)
+ return;
+ n = v2 * (n / (2*v2));
+ hptr = lptr = base+n;
+ i = base;
+ j = lim-v2;
+ for(;;) {
+ if (i < lptr) {
+ if ((c = (*func)(i, lptr)) == 0) {
+ glob2(i, lptr -= v2);
+ continue;
+ }
+ if (c < 0) {
+ i += v2;
+ continue;
+ }
+ }
+
+begin:
+ if (j > hptr) {
+ if ((c = (*func)(hptr, j)) == 0) {
+ glob2(hptr += v2, j);
+ goto begin;
+ }
+ if (c > 0) {
+ if (i == lptr) {
+ glob3(i, hptr += v2, j);
+ i = lptr += v2;
+ goto begin;
+ }
+ glob2(i, j);
+ j -= v2;
+ i += v2;
+ continue;
+ }
+ j -= v2;
+ goto begin;
+ }
+
+
+ if (i == lptr) {
+ if (lptr-base >= lim-hptr) {
+ glob1(hptr+v2, lim);
+ lim = lptr;
+ } else {
+ glob1(base, lptr);
+ base = hptr+v2;
+ }
+ goto top;
+ }
+
+
+ glob3(j, lptr -= v2, i);
+ j = hptr -= v2;
+ }
+}
+
+static void
+glob2(i, j)
+char *i, *j;
+{
+ register char *index1, *index2, c;
+ int m;
+
+ m = globv;
+ index1 = i;
+ index2 = j;
+ do {
+ c = *index1;
+ *index1++ = *index2;
+ *index2++ = c;
+ } while(--m);
+}
+
+static void
+glob3(i, j, k)
+char *i, *j, *k;
+{
+ register char *index1, *index2, *index3;
+ int c;
+ int m;
+
+ m = globv;
+ index1 = i;
+ index2 = j;
+ index3 = k;
+ do {
+ c = *index1;
+ *index1++ = *index3;
+ *index3++ = *index2;
+ *index2++ = c;
+ } while(--m);
+}
+
+/* -------- io.c -------- */
+
+/*
+ * shell IO
+ */
+
+static int my_getc( int ec)
+{
+ register int c;
+
+ if(e.linep > elinep) {
+ while((c=readc()) != '\n' && c)
+ ;
+ err("input line too long");
+ gflg++;
+ return(c);
+ }
+ c = readc();
+ if ((ec != '\'') && (ec != '`') && (e.iop->task != XGRAVE)) {
+ if(c == '\\') {
+ c = readc();
+ if (c == '\n' && ec != '\"')
+ return(my_getc(ec));
+ c |= QUOTE;
+ }
+ }
+ return(c);
+}
+
+static void
+unget(c)
+int c;
+{
+ if (e.iop >= e.iobase)
+ e.iop->peekc = c;
+}
+
+static int
+eofc()
+
+{
+ return e.iop < e.iobase || (e.iop->peekc == 0 && e.iop->prev == 0);
+}
+
+static int
+readc()
+{
+ register int c;
+
+ for (; e.iop >= e.iobase; e.iop--)
+ if ((c = e.iop->peekc) != '\0') {
+ e.iop->peekc = 0;
+ return(c);
+ }
+ else {
+ if (e.iop->prev != 0) {
+ if ((c = (*e.iop->iofn)(e.iop->argp, e.iop)) != '\0') {
+ if (c == -1) {
+ e.iop++;
+ continue;
+ }
+ if (e.iop == iostack)
+ ioecho(c);
+ return(e.iop->prev = c);
+ }
+ else if (e.iop->task == XIO && e.iop->prev != '\n') {
+ e.iop->prev = 0;
+ if (e.iop == iostack)
+ ioecho('\n');
+ return '\n';
+ }
+ }
+ if (e.iop->task == XIO) {
+ if (multiline)
+ return e.iop->prev = 0;
+ if (interactive && e.iop == iostack+1) {
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+ current_prompt=prompt->value;
+#else
+ prs(prompt->value);
+#endif
+ }
+ }
+ }
+ if (e.iop >= iostack)
+ return(0);
+ leave();
+ /* NOTREACHED */
+ return(0);
+}
+
+static void
+ioecho(c)
+char c;
+{
+ if (flag['v'])
+ write(2, &c, sizeof c);
+}
+
+static void
+pushio(struct ioarg *argp, int (*fn)(struct ioarg *))
+{
+ if (++e.iop >= &iostack[NPUSH]) {
+ e.iop--;
+ err("Shell input nested too deeply");
+ gflg++;
+ return;
+ }
+ e.iop->iofn = (int (*)(struct ioarg *, struct io *))fn;
+
+ if (argp->afid != AFID_NOBUF)
+ e.iop->argp = argp;
+ else {
+ e.iop->argp = ioargstack + (e.iop - iostack);
+ *e.iop->argp = *argp;
+ e.iop->argp->afbuf = e.iop == &iostack[0] ? &mainbuf : &sharedbuf;
+ if (isatty(e.iop->argp->afile) == 0 &&
+ (e.iop == &iostack[0] ||
+ lseek(e.iop->argp->afile, 0L, 1) != -1)) {
+ if (++bufid == AFID_NOBUF)
+ bufid = AFID_ID;
+ e.iop->argp->afid = bufid;
+ }
+ }
+
+ e.iop->prev = ~'\n';
+ e.iop->peekc = 0;
+ e.iop->xchar = 0;
+ e.iop->nlcount = 0;
+ if (fn == filechar || fn == linechar)
+ e.iop->task = XIO;
+ else if (fn == (int(*)(struct ioarg *))gravechar || fn == (int(*)(struct ioarg *))qgravechar)
+ e.iop->task = XGRAVE;
+ else
+ e.iop->task = XOTHER;
+}
+
+static struct io *
+setbase(ip)
+struct io *ip;
+{
+ register struct io *xp;
+
+ xp = e.iobase;
+ e.iobase = ip;
+ return(xp);
+}
+
+/*
+ * Input generating functions
+ */
+
+/*
+ * Produce the characters of a string, then a newline, then EOF.
+ */
+static int
+nlchar(ap)
+register struct ioarg *ap;
+{
+ register int c;
+
+ if (ap->aword == NULL)
+ return(0);
+ if ((c = *ap->aword++) == 0) {
+ ap->aword = NULL;
+ return('\n');
+ }
+ return(c);
+}
+
+/*
+ * Given a list of words, produce the characters
+ * in them, with a space after each word.
+ */
+static int
+wdchar(ap)
+register struct ioarg *ap;
+{
+ register char c;
+ register char **wl;
+
+ if ((wl = ap->awordlist) == NULL)
+ return(0);
+ if (*wl != NULL) {
+ if ((c = *(*wl)++) != 0)
+ return(c & 0177);
+ ap->awordlist++;
+ return(' ');
+ }
+ ap->awordlist = NULL;
+ return('\n');
+}
+
+/*
+ * Return the characters of a list of words,
+ * producing a space between them.
+ */
+static int
+dolchar(ap)
+register struct ioarg *ap;
+{
+ register char *wp;
+
+ if ((wp = *ap->awordlist++) != NULL) {
+ PUSHIO(aword, wp, *ap->awordlist == NULL? strchar: xxchar);
+ return(-1);
+ }
+ return(0);
+}
+
+static int
+xxchar(ap)
+register struct ioarg *ap;
+{
+ register int c;
+
+ if (ap->aword == NULL)
+ return(0);
+ if ((c = *ap->aword++) == '\0') {
+ ap->aword = NULL;
+ return(' ');
+ }
+ return(c);
+}
+
+/*
+ * Produce the characters from a single word (string).
+ */
+static int
+strchar(ap)
+register struct ioarg *ap;
+{
+ register int c;
+
+ if (ap->aword == NULL || (c = *ap->aword++) == 0)
+ return(0);
+ return(c);
+}
+
+/*
+ * Produce quoted characters from a single word (string).
+ */
+static int
+qstrchar(ap)
+register struct ioarg *ap;
+{
+ register int c;
+
+ if (ap->aword == NULL || (c = *ap->aword++) == 0)
+ return(0);
+ return(c|QUOTE);
+}
+
+/*
+ * Return the characters from a file.
+ */
+static int
+filechar(ap)
+register struct ioarg *ap;
+{
+ register int i;
+ char c;
+ struct iobuf *bp = ap->afbuf;
+
+ if (ap->afid != AFID_NOBUF) {
+ if ((i = ap->afid != bp->id) || bp->bufp == bp->ebufp) {
+ if (i)
+ lseek(ap->afile, ap->afpos, 0);
+ i = safe_read(ap->afile, bp->buf, sizeof(bp->buf));
+ if (i <= 0) {
+ closef(ap->afile);
+ return 0;
+ }
+ bp->id = ap->afid;
+ bp->ebufp = (bp->bufp = bp->buf) + i;
+ }
+ ap->afpos++;
+ return *bp->bufp++ & 0177;
+ }
+
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+ if (interactive && isatty(ap->afile)) {
+ static char mycommand[BUFSIZ];
+ static int position = 0, size = 0;
+
+ while (size == 0 || position >= size) {
+ cmdedit_read_input(current_prompt, mycommand);
+ size = strlen(mycommand);
+ position = 0;
+ }
+ c = mycommand[position];
+ position++;
+ return(c);
+ } else
+#endif
+ {
+ i = safe_read(ap->afile, &c, sizeof(c));
+ return(i == sizeof(c)? c&0177: (closef(ap->afile), 0));
+ }
+}
+
+/*
+ * Return the characters from a here temp file.
+ */
+static int
+herechar(ap)
+register struct ioarg *ap;
+{
+ char c;
+
+
+ if (read(ap->afile, &c, sizeof(c)) != sizeof(c)) {
+ close(ap->afile);
+ c = 0;
+ }
+ return (c);
+
+}
+
+/*
+ * Return the characters produced by a process (`...`).
+ * Quote them if required, and remove any trailing newline characters.
+ */
+static int
+gravechar(ap, iop)
+struct ioarg *ap;
+struct io *iop;
+{
+ register int c;
+
+ if ((c = qgravechar(ap, iop)&~QUOTE) == '\n')
+ c = ' ';
+ return(c);
+}
+
+static int
+qgravechar(ap, iop)
+register struct ioarg *ap;
+struct io *iop;
+{
+ register int c;
+
+ if (iop->xchar) {
+ if (iop->nlcount) {
+ iop->nlcount--;
+ return('\n'|QUOTE);
+ }
+ c = iop->xchar;
+ iop->xchar = 0;
+ } else if ((c = filechar(ap)) == '\n') {
+ iop->nlcount = 1;
+ while ((c = filechar(ap)) == '\n')
+ iop->nlcount++;
+ iop->xchar = c;
+ if (c == 0)
+ return(c);
+ iop->nlcount--;
+ c = '\n';
+ }
+ return(c!=0? c|QUOTE: 0);
+}
+
+/*
+ * Return a single command (usually the first line) from a file.
+ */
+static int
+linechar(ap)
+register struct ioarg *ap;
+{
+ register int c;
+
+ if ((c = filechar(ap)) == '\n') {
+ if (!multiline) {
+ closef(ap->afile);
+ ap->afile = -1; /* illegal value */
+ }
+ }
+ return(c);
+}
+
+static void
+prs(s)
+register char *s;
+{
+ if (*s)
+ write(2, s, strlen(s));
+}
+
+static void
+prn(u)
+unsigned u;
+{
+ prs(itoa(u));
+}
+
+static void
+closef(i)
+register int i;
+{
+ if (i > 2)
+ close(i);
+}
+
+static void
+closeall()
+{
+ register int u;
+
+ for (u=NUFILE; u<NOFILE;)
+ close(u++);
+}
+
+/*
+ * remap fd into Shell's fd space
+ */
+static int
+remap(fd)
+register int fd;
+{
+ register int i;
+ int map[NOFILE];
+
+ if (fd < e.iofd) {
+ for (i=0; i<NOFILE; i++)
+ map[i] = 0;
+ do {
+ map[fd] = 1;
+ fd = dup(fd);
+ } while (fd >= 0 && fd < e.iofd);
+ for (i=0; i<NOFILE; i++)
+ if (map[i])
+ close(i);
+ if (fd < 0)
+ err("too many files open in shell");
+ }
+ return(fd);
+}
+
+static int
+openpipe(pv)
+register int *pv;
+{
+ register int i;
+
+ if ((i = pipe(pv)) < 0)
+ err("can't create pipe - try again");
+ return(i);
+}
+
+static void
+closepipe(pv)
+register int *pv;
+{
+ if (pv != NULL) {
+ close(*pv++);
+ close(*pv);
+ }
+}
+
+/* -------- here.c -------- */
+
+/*
+ * here documents
+ */
+
+static void
+markhere(s, iop)
+register char *s;
+struct ioword *iop;
+{
+ register struct here *h, *lh;
+
+ h = (struct here *) space(sizeof(struct here));
+ if (h == 0)
+ return;
+ h->h_tag = evalstr(s, DOSUB);
+ if (h->h_tag == 0)
+ return;
+ h->h_iop = iop;
+ iop->io_name = 0;
+ h->h_next = NULL;
+ if (inhere == 0)
+ inhere = h;
+ else
+ for (lh = inhere; lh!=NULL; lh = lh->h_next)
+ if (lh->h_next == 0) {
+ lh->h_next = h;
+ break;
+ }
+ iop->io_flag |= IOHERE|IOXHERE;
+ for (s = h->h_tag; *s; s++)
+ if (*s & QUOTE) {
+ iop->io_flag &= ~ IOXHERE;
+ *s &= ~ QUOTE;
+ }
+ h->h_dosub = iop->io_flag & IOXHERE;
+}
+
+static void
+gethere()
+{
+ register struct here *h, *hp;
+
+ /* Scan here files first leaving inhere list in place */
+ for (hp = h = inhere; h != NULL; hp = h, h = h->h_next)
+ readhere(&h->h_iop->io_name, h->h_tag, h->h_dosub? 0: '\'');
+
+ /* Make inhere list active - keep list intact for scraphere */
+ if (hp != NULL) {
+ hp->h_next = acthere;
+ acthere = inhere;
+ inhere = NULL;
+ }
+}
+
+static void
+readhere(name, s, ec)
+char **name;
+register char *s;
+int ec;
+{
+ int tf;
+ char tname[30] = ".msh_XXXXXX";
+ register int c;
+ jmp_buf ev;
+ char myline [LINELIM+1];
+ char *thenext;
+
+ tf = mkstemp(tname);
+ if (tf < 0)
+ return;
+ *name = strsave(tname, areanum);
+ if (newenv(setjmp(errpt = ev)) != 0)
+ unlink(tname);
+ else {
+ pushio(e.iop->argp, (int(*)(struct ioarg *))e.iop->iofn);
+ e.iobase = e.iop;
+ for (;;) {
+ if (interactive && e.iop <= iostack) {
+#ifdef CONFIG_FEATURE_COMMAND_EDITING
+ current_prompt=cprompt->value;
+#else
+ prs(cprompt->value);
+#endif
+ }
+ thenext = myline;
+ while ((c = my_getc(ec)) != '\n' && c) {
+ if (ec == '\'')
+ c &= ~ QUOTE;
+ if (thenext >= &myline[LINELIM]) {
+ c = 0;
+ break;
+ }
+ *thenext++ = c;
+ }
+ *thenext = 0;
+ if (strcmp(s, myline) == 0 || c == 0)
+ break;
+ *thenext++ = '\n';
+ write (tf, myline, (int)(thenext-myline));
+ }
+ if (c == 0) {
+ prs("here document `"); prs(s); err("' unclosed");
+ }
+ quitenv();
+ }
+ close(tf);
+}
+
+/*
+ * open here temp file.
+ * if unquoted here, expand here temp file into second temp file.
+ */
+static int
+herein(hname, xdoll)
+char *hname;
+int xdoll;
+{
+ register int hf;
+ int tf;
+
+#if __GNUC__
+ /* Avoid longjmp clobbering */
+ (void) &tf;
+#endif
+ if (hname == 0)
+ return(-1);
+ hf = open(hname, 0);
+ if (hf < 0)
+ return (-1);
+ if (xdoll) {
+ char c;
+ char tname[30] = ".msh_XXXXXX";
+ jmp_buf ev;
+
+ tf = mkstemp(tname);
+ if (tf < 0)
+ return (-1);
+ if (newenv(setjmp(errpt = ev)) == 0) {
+ PUSHIO(afile, hf, herechar);
+ setbase(e.iop);
+ while ((c = subgetc(0, 0)) != 0) {
+ c &= ~ QUOTE;
+ write(tf, &c, sizeof c);
+ }
+ quitenv();
+ } else
+ unlink(tname);
+ close(tf);
+ tf = open(tname, 0);
+ unlink(tname);
+ return (tf);
+ } else
+ return (hf);
+}
+
+static void
+scraphere()
+{
+ register struct here *h;
+
+ for (h = inhere; h != NULL; h = h->h_next) {
+ if (h->h_iop && h->h_iop->io_name)
+ unlink(h->h_iop->io_name);
+ }
+ inhere = NULL;
+}
+
+/* unlink here temp files before a freearea(area) */
+static void
+freehere(area)
+int area;
+{
+ register struct here *h, *hl;
+
+ hl = NULL;
+ for (h = acthere; h != NULL; h = h->h_next)
+ if (getarea((char *) h) >= area) {
+ if (h->h_iop->io_name != NULL)
+ unlink(h->h_iop->io_name);
+ if (hl == NULL)
+ acthere = h->h_next;
+ else
+ hl->h_next = h->h_next;
+ } else
+ hl = h;
+}
+
+
+
+/*
+ * Copyright (c) 1987,1997, Prentice Hall
+ * All rights reserved.
+ *
+ * Redistribution and use of the MINIX operating system in source and
+ * binary forms, with or without modification, are permitted provided
+ * that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 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.
+ *
+ * Neither the name of Prentice Hall nor the names of the software
+ * authors or contributors may be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS, AUTHORS, AND
+ * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL PRENTICE HALL OR ANY AUTHORS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
generated by cgit v1.2.3-54-g00ecf (git 2.45.1) at 2024-05-20 00:29:29 +0000