1 /* vi: set sw=4 ts=4: */
3 * ash shell port for busybox
5 * Copyright (c) 1989, 1991, 1993, 1994
6 * The Regents of the University of California. All rights reserved.
8 * This code is derived from software contributed to Berkeley by
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 * This version of ash is adapted from the source in Debian's ash 0.3.8-5
28 * Modified by Erik Andersen <andersee@debian.org> and
29 * Vladimir Oleynik <dzo@simtreas.ru> to be used in busybox
32 * Original copyright notice is retained at the end of this file.
36 /* Enable this to compile in extra debugging noise. When debugging is
37 * on, debugging info will be written to $HOME/trace and a quit signal
38 * will generate a core dump. */
41 /* These are here to work with glibc -- Don't change these... */
63 #include <sys/cdefs.h>
64 #include <sys/ioctl.h>
65 #include <sys/param.h>
66 #include <sys/resource.h>
68 #include <sys/times.h>
69 #include <sys/types.h>
75 #if !defined(FNMATCH_BROKEN)
78 #if !defined(GLOB_BROKEN)
82 #ifdef CONFIG_ASH_JOB_CONTROL
88 #if defined(__uClinux__)
89 #error "Do not even bother, ash will not run on uClinux"
93 * This file was generated by the mksyntax program.
97 #define CWORD 0 /* character is nothing special */
98 #define CNL 1 /* newline character */
99 #define CBACK 2 /* a backslash character */
100 #define CSQUOTE 3 /* single quote */
101 #define CDQUOTE 4 /* double quote */
102 #define CENDQUOTE 5 /* a terminating quote */
103 #define CBQUOTE 6 /* backwards single quote */
104 #define CVAR 7 /* a dollar sign */
105 #define CENDVAR 8 /* a '}' character */
106 #define CLP 9 /* a left paren in arithmetic */
107 #define CRP 10 /* a right paren in arithmetic */
108 #define CENDFILE 11 /* end of file */
109 #define CCTL 12 /* like CWORD, except it must be escaped */
110 #define CSPCL 13 /* these terminate a word */
111 #define CIGN 14 /* character should be ignored */
131 #define TENDBQUOTE 13
151 /* control characters in argument strings */
152 #define CTLESC '\201'
153 #define CTLVAR '\202'
154 #define CTLENDVAR '\203'
155 #define CTLBACKQ '\204'
156 #define CTLQUOTE 01 /* ored with CTLBACKQ code if in quotes */
157 /* CTLBACKQ | CTLQUOTE == '\205' */
158 #define CTLARI '\206'
159 #define CTLENDARI '\207'
160 #define CTLQUOTEMARK '\210'
163 #define is_digit(c) ((c)>='0' && (c)<='9')
164 #define is_name(c) (((c) < CTLESC || (c) > CTLENDARI) && ((c) == '_' || isalpha((unsigned char) (c))))
165 #define is_in_name(c) (((c) < CTLESC || (c) > CTLENDARI) && ((c) == '_' || isalnum((unsigned char) (c))))
168 * is_special(c) evaluates to 1 for c in "!#$*-0123456789?@"; 0 otherwise
169 * (assuming ascii char codes, as the original implementation did)
171 #define is_special(c) \
172 ( (((unsigned int)c) - 33 < 32) \
173 && ((0xc1ff920dUL >> (((unsigned int)c) - 33)) & 1))
175 #define digit_val(c) ((c) - '0')
178 #define S_DFL 1 /* default signal handling (SIG_DFL) */
179 #define S_CATCH 2 /* signal is caught */
180 #define S_IGN 3 /* signal is ignored (SIG_IGN) */
181 #define S_HARD_IGN 4 /* signal is ignored permenantly */
182 #define S_RESET 5 /* temporary - to reset a hard ignored sig */
185 /* variable substitution byte (follows CTLVAR) */
186 #define VSTYPE 0x0f /* type of variable substitution */
187 #define VSNUL 0x10 /* colon--treat the empty string as unset */
188 #define VSQUOTE 0x80 /* inside double quotes--suppress splitting */
190 /* values of VSTYPE field */
191 #define VSNORMAL 0x1 /* normal variable: $var or ${var} */
192 #define VSMINUS 0x2 /* ${var-text} */
193 #define VSPLUS 0x3 /* ${var+text} */
194 #define VSQUESTION 0x4 /* ${var?message} */
195 #define VSASSIGN 0x5 /* ${var=text} */
196 #define VSTRIMLEFT 0x6 /* ${var#pattern} */
197 #define VSTRIMLEFTMAX 0x7 /* ${var##pattern} */
198 #define VSTRIMRIGHT 0x8 /* ${var%pattern} */
199 #define VSTRIMRIGHTMAX 0x9 /* ${var%%pattern} */
200 #define VSLENGTH 0xa /* ${#var} */
202 /* flags passed to redirect */
203 #define REDIR_PUSH 01 /* save previous values of file descriptors */
204 #define REDIR_BACKQ 02 /* save the command output to pipe */
207 * BSD setjmp saves the signal mask, which violates ANSI C and takes time,
208 * so we use _setjmp instead.
212 #define setjmp(jmploc) _setjmp(jmploc)
213 #define longjmp(jmploc, val) _longjmp(jmploc, val)
217 * Most machines require the value returned from malloc to be aligned
218 * in some way. The following macro will get this right on many machines.
227 #define ALIGN(nbytes) (((nbytes) + sizeof(union align) - 1) & ~(sizeof(union align) - 1))
230 #ifdef CONFIG_LOCALE_SUPPORT
232 static void change_lc_all(const char *value);
233 static void change_lc_ctype(const char *value);
237 * These macros allow the user to suspend the handling of interrupt signals
238 * over a period of time. This is similar to SIGHOLD to or sigblock, but
239 * much more efficient and portable. (But hacking the kernel is so much
240 * more fun than worrying about efficiency and portability. :-))
243 static void onint(void);
244 static volatile int suppressint;
245 static volatile int intpending;
247 #define INTOFF suppressint++
248 #ifndef CONFIG_ASH_OPTIMIZE_FOR_SIZE
249 #define INTON { if (--suppressint == 0 && intpending) onint(); }
250 #define FORCEINTON {suppressint = 0; if (intpending) onint();}
252 static void __inton(void);
253 static void forceinton(void);
255 #define INTON __inton()
256 #define FORCEINTON forceinton()
259 #define CLEAR_PENDING_INT intpending = 0
260 #define int_pending() intpending
263 typedef void *pointer;
266 #define NULL (void *)0
269 static pointer stalloc(int);
270 static void stunalloc(pointer);
271 static void ungrabstackstr(char *, char *);
272 static char *growstackstr(void);
273 static char *makestrspace(size_t newlen);
276 * Parse trees for commands are allocated in lifo order, so we use a stack
277 * to make this more efficient, and also to avoid all sorts of exception
278 * handling code to handle interrupts in the middle of a parse.
280 * The size 504 was chosen because the Ultrix malloc handles that size
284 #define MINSIZE 504 /* minimum size of a block */
288 struct stack_block *prev;
292 static struct stack_block stackbase;
293 static struct stack_block *stackp = &stackbase;
294 static struct stackmark *markp;
295 static char *stacknxt = stackbase.space;
296 static int stacknleft = MINSIZE;
299 #define equal(s1, s2) (strcmp(s1, s2) == 0)
301 #define stackblock() stacknxt
302 #define stackblocksize() stacknleft
303 #define STARTSTACKSTR(p) p = stackblock(), sstrnleft = stackblocksize()
305 #define STPUTC(c, p) (--sstrnleft >= 0? (*p++ = (c)) : (p = growstackstr(), *p++ = (c)))
306 #define CHECKSTRSPACE(n, p) { if (sstrnleft < n) p = makestrspace(n); }
307 #define STACKSTRNUL(p) (sstrnleft == 0? (p = growstackstr(), *p = '\0') : (*p = '\0'))
310 #define USTPUTC(c, p) (--sstrnleft, *p++ = (c))
311 #define STUNPUTC(p) (++sstrnleft, --p)
312 #define STTOPC(p) p[-1]
313 #define STADJUST(amount, p) (p += (amount), sstrnleft -= (amount))
314 #define grabstackstr(p) stalloc(stackblocksize() - sstrnleft)
318 #define TRACE(param) trace param
319 typedef union node unode;
320 static void trace(const char *, ...);
321 static void trargs(char **);
322 static void showtree(unode *);
323 static void trputc(int);
324 static void trputs(const char *);
325 static void opentrace(void);
360 #define EXP_FULL 0x1 /* perform word splitting & file globbing */
361 #define EXP_TILDE 0x2 /* do normal tilde expansion */
362 #define EXP_VARTILDE 0x4 /* expand tildes in an assignment */
363 #define EXP_REDIR 0x8 /* file glob for a redirection (1 match only) */
364 #define EXP_CASE 0x10 /* keeps quotes around for CASE pattern */
365 #define EXP_RECORD 0x20 /* need to record arguments for ifs breakup */
370 static char optet_vals[NOPTS];
372 static const char *const optlist[NOPTS] = {
391 #define optent_name(optent) (optent+1)
392 #define optent_letter(optent) optent[0]
393 #define optent_val(optent) optet_vals[optent]
395 #define eflag optent_val(0)
396 #define fflag optent_val(1)
397 #define Iflag optent_val(2)
398 #define iflag optent_val(3)
399 #define mflag optent_val(4)
400 #define nflag optent_val(5)
401 #define sflag optent_val(6)
402 #define xflag optent_val(7)
403 #define vflag optent_val(8)
404 #define Vflag optent_val(9)
405 #define Eflag optent_val(10)
406 #define Cflag optent_val(11)
407 #define aflag optent_val(12)
408 #define bflag optent_val(13)
409 #define uflag optent_val(14)
410 #define qflag optent_val(15)
413 /* Mode argument to forkshell. Don't change FORK_FG or FORK_BG. */
431 union node *redirect;
438 struct nodelist *cmdlist;
445 union node *redirect;
453 union node *elsepart;
484 struct nodelist *backquote;
522 struct nbinary nbinary;
525 struct nredir nredir;
529 struct nclist nclist;
539 struct nodelist *next;
543 struct backcmd { /* result of evalbackcmd */
544 int fd; /* file descriptor to read from */
545 char *buf; /* buffer */
546 int nleft; /* number of chars in buffer */
547 struct job *jp; /* job structure for command */
555 const struct builtincmd *cmd;
560 struct strlist *next;
566 struct strlist *list;
567 struct strlist **lastp;
571 struct strpush *prev; /* preceding string on stack */
574 #ifdef CONFIG_ASH_ALIAS
575 struct alias *ap; /* if push was associated with an alias */
577 char *string; /* remember the string since it may change */
581 struct parsefile *prev; /* preceding file on stack */
582 int linno; /* current line */
583 int fd; /* file descriptor (or -1 if string) */
584 int nleft; /* number of chars left in this line */
585 int lleft; /* number of chars left in this buffer */
586 char *nextc; /* next char in buffer */
587 char *buf; /* input buffer */
588 struct strpush *strpush; /* for pushing strings at this level */
589 struct strpush basestrpush; /* so pushing one is fast */
593 struct stack_block *stackp;
596 struct stackmark *marknext;
600 int nparam; /* # of positional parameters (without $0) */
601 unsigned char malloc; /* if parameter list dynamically allocated */
602 char **p; /* parameter list */
603 int optind; /* next parameter to be processed by getopts */
604 int optoff; /* used by getopts */
608 * When commands are first encountered, they are entered in a hash table.
609 * This ensures that a full path search will not have to be done for them
610 * on each invocation.
612 * We should investigate converting to a linear search, even though that
613 * would make the command name "hash" a misnomer.
615 #define CMDTABLESIZE 31 /* should be prime */
616 #define ARB 1 /* actual size determined at run time */
621 struct tblentry *next; /* next entry in hash chain */
622 union param param; /* definition of builtin function */
623 short cmdtype; /* index identifying command */
624 char rehash; /* if set, cd done since entry created */
625 char cmdname[ARB]; /* name of command */
629 static struct tblentry *cmdtable[CMDTABLESIZE];
630 static int builtinloc = -1; /* index in path of %builtin, or -1 */
631 static int exerrno = 0; /* Last exec error */
634 static void tryexec(char *, char **, char **);
635 static void printentry(struct tblentry *, int);
636 static void clearcmdentry(int);
637 static struct tblentry *cmdlookup(const char *, int);
638 static void delete_cmd_entry(void);
639 static int path_change(const char *, int *);
642 static void flushall(void);
643 static void out2fmt(const char *, ...)
644 __attribute__ ((__format__(__printf__, 1, 2)));
645 static int xwrite(int, const char *, int);
647 static inline void outstr(const char *p, FILE * file)
651 static void out1str(const char *p)
655 static void out2str(const char *p)
660 #ifndef CONFIG_ASH_OPTIMIZE_FOR_SIZE
661 #define out2c(c) putc((c), stderr)
663 static void out2c(int c)
670 #ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE
671 #define USE_SIT_FUNCTION
674 /* number syntax index */
675 #define BASESYNTAX 0 /* not in quotes */
676 #define DQSYNTAX 1 /* in double quotes */
677 #define SQSYNTAX 2 /* in single quotes */
678 #define ARISYNTAX 3 /* in arithmetic */
680 static const char S_I_T[][4] = {
681 {CSPCL, CIGN, CIGN, CIGN}, /* 0, PEOA */
682 {CSPCL, CWORD, CWORD, CWORD}, /* 1, ' ' */
683 {CNL, CNL, CNL, CNL}, /* 2, \n */
684 {CWORD, CCTL, CCTL, CWORD}, /* 3, !*-/:=?[]~ */
685 {CDQUOTE, CENDQUOTE, CWORD, CDQUOTE}, /* 4, '"' */
686 {CVAR, CVAR, CWORD, CVAR}, /* 5, $ */
687 {CSQUOTE, CWORD, CENDQUOTE, CSQUOTE}, /* 6, "'" */
688 {CSPCL, CWORD, CWORD, CLP}, /* 7, ( */
689 {CSPCL, CWORD, CWORD, CRP}, /* 8, ) */
690 {CBACK, CBACK, CCTL, CBACK}, /* 9, \ */
691 {CBQUOTE, CBQUOTE, CWORD, CBQUOTE}, /* 10, ` */
692 {CENDVAR, CENDVAR, CWORD, CENDVAR}, /* 11, } */
693 #ifndef USE_SIT_FUNCTION
694 {CENDFILE, CENDFILE, CENDFILE, CENDFILE}, /* 12, PEOF */
695 {CWORD, CWORD, CWORD, CWORD}, /* 13, 0-9A-Za-z */
696 {CCTL, CCTL, CCTL, CCTL} /* 14, CTLESC ... */
700 #ifdef USE_SIT_FUNCTION
702 #define U_C(c) ((unsigned char)(c))
704 static int SIT(int c, int syntax)
706 static const char spec_symbls[] = "\t\n !\"$&'()*-/:;<=>?[\\]`|}~";
707 static const char syntax_index_table[] = {
708 1, 2, 1, 3, 4, 5, 1, 6, /* "\t\n !\"$&'" */
709 7, 8, 3, 3, 3, 3, 1, 1, /* "()*-/:;<" */
710 3, 1, 3, 3, 9, 3, 10, 1, /* "=>?[\\]`|" */
716 if (c == PEOF) /* 2^8+2 */
718 if (c == PEOA) /* 2^8+1 */
720 else if (U_C(c) >= U_C(CTLESC) && U_C(c) <= U_C(CTLQUOTEMARK))
723 s = strchr(spec_symbls, c);
726 indx = syntax_index_table[(s - spec_symbls)];
728 return S_I_T[indx][syntax];
731 #else /* USE_SIT_FUNCTION */
733 #define SIT(c, syntax) S_I_T[(int)syntax_index_table[((int)c)+SYNBASE]][syntax]
735 #define CSPCL_CIGN_CIGN_CIGN 0
736 #define CSPCL_CWORD_CWORD_CWORD 1
737 #define CNL_CNL_CNL_CNL 2
738 #define CWORD_CCTL_CCTL_CWORD 3
739 #define CDQUOTE_CENDQUOTE_CWORD_CDQUOTE 4
740 #define CVAR_CVAR_CWORD_CVAR 5
741 #define CSQUOTE_CWORD_CENDQUOTE_CSQUOTE 6
742 #define CSPCL_CWORD_CWORD_CLP 7
743 #define CSPCL_CWORD_CWORD_CRP 8
744 #define CBACK_CBACK_CCTL_CBACK 9
745 #define CBQUOTE_CBQUOTE_CWORD_CBQUOTE 10
746 #define CENDVAR_CENDVAR_CWORD_CENDVAR 11
747 #define CENDFILE_CENDFILE_CENDFILE_CENDFILE 12
748 #define CWORD_CWORD_CWORD_CWORD 13
749 #define CCTL_CCTL_CCTL_CCTL 14
751 static const char syntax_index_table[258] = {
752 /* BASESYNTAX_DQSYNTAX_SQSYNTAX_ARISYNTAX */
753 /* 0 -130 PEOF */ CENDFILE_CENDFILE_CENDFILE_CENDFILE,
754 /* 1 -129 PEOA */ CSPCL_CIGN_CIGN_CIGN,
755 /* 2 -128 0xff */ CWORD_CWORD_CWORD_CWORD,
756 /* 3 -127 */ CCTL_CCTL_CCTL_CCTL,
758 /* 4 -126 */ CCTL_CCTL_CCTL_CCTL,
759 /* 5 -125 */ CCTL_CCTL_CCTL_CCTL,
760 /* 6 -124 */ CCTL_CCTL_CCTL_CCTL,
761 /* 7 -123 */ CCTL_CCTL_CCTL_CCTL,
762 /* 8 -122 */ CCTL_CCTL_CCTL_CCTL,
763 /* 9 -121 */ CCTL_CCTL_CCTL_CCTL,
764 /* 10 -120 */ CCTL_CCTL_CCTL_CCTL,
766 /* 11 -119 */ CWORD_CWORD_CWORD_CWORD,
767 /* 12 -118 */ CWORD_CWORD_CWORD_CWORD,
768 /* 13 -117 */ CWORD_CWORD_CWORD_CWORD,
769 /* 14 -116 */ CWORD_CWORD_CWORD_CWORD,
770 /* 15 -115 */ CWORD_CWORD_CWORD_CWORD,
771 /* 16 -114 */ CWORD_CWORD_CWORD_CWORD,
772 /* 17 -113 */ CWORD_CWORD_CWORD_CWORD,
773 /* 18 -112 */ CWORD_CWORD_CWORD_CWORD,
774 /* 19 -111 */ CWORD_CWORD_CWORD_CWORD,
775 /* 20 -110 */ CWORD_CWORD_CWORD_CWORD,
776 /* 21 -109 */ CWORD_CWORD_CWORD_CWORD,
777 /* 22 -108 */ CWORD_CWORD_CWORD_CWORD,
778 /* 23 -107 */ CWORD_CWORD_CWORD_CWORD,
779 /* 24 -106 */ CWORD_CWORD_CWORD_CWORD,
780 /* 25 -105 */ CWORD_CWORD_CWORD_CWORD,
781 /* 26 -104 */ CWORD_CWORD_CWORD_CWORD,
782 /* 27 -103 */ CWORD_CWORD_CWORD_CWORD,
783 /* 28 -102 */ CWORD_CWORD_CWORD_CWORD,
784 /* 29 -101 */ CWORD_CWORD_CWORD_CWORD,
785 /* 30 -100 */ CWORD_CWORD_CWORD_CWORD,
786 /* 31 -99 */ CWORD_CWORD_CWORD_CWORD,
787 /* 32 -98 */ CWORD_CWORD_CWORD_CWORD,
788 /* 33 -97 */ CWORD_CWORD_CWORD_CWORD,
789 /* 34 -96 */ CWORD_CWORD_CWORD_CWORD,
790 /* 35 -95 */ CWORD_CWORD_CWORD_CWORD,
791 /* 36 -94 */ CWORD_CWORD_CWORD_CWORD,
792 /* 37 -93 */ CWORD_CWORD_CWORD_CWORD,
793 /* 38 -92 */ CWORD_CWORD_CWORD_CWORD,
794 /* 39 -91 */ CWORD_CWORD_CWORD_CWORD,
795 /* 40 -90 */ CWORD_CWORD_CWORD_CWORD,
796 /* 41 -89 */ CWORD_CWORD_CWORD_CWORD,
797 /* 42 -88 */ CWORD_CWORD_CWORD_CWORD,
798 /* 43 -87 */ CWORD_CWORD_CWORD_CWORD,
799 /* 44 -86 */ CWORD_CWORD_CWORD_CWORD,
800 /* 45 -85 */ CWORD_CWORD_CWORD_CWORD,
801 /* 46 -84 */ CWORD_CWORD_CWORD_CWORD,
802 /* 47 -83 */ CWORD_CWORD_CWORD_CWORD,
803 /* 48 -82 */ CWORD_CWORD_CWORD_CWORD,
804 /* 49 -81 */ CWORD_CWORD_CWORD_CWORD,
805 /* 50 -80 */ CWORD_CWORD_CWORD_CWORD,
806 /* 51 -79 */ CWORD_CWORD_CWORD_CWORD,
807 /* 52 -78 */ CWORD_CWORD_CWORD_CWORD,
808 /* 53 -77 */ CWORD_CWORD_CWORD_CWORD,
809 /* 54 -76 */ CWORD_CWORD_CWORD_CWORD,
810 /* 55 -75 */ CWORD_CWORD_CWORD_CWORD,
811 /* 56 -74 */ CWORD_CWORD_CWORD_CWORD,
812 /* 57 -73 */ CWORD_CWORD_CWORD_CWORD,
813 /* 58 -72 */ CWORD_CWORD_CWORD_CWORD,
814 /* 59 -71 */ CWORD_CWORD_CWORD_CWORD,
815 /* 60 -70 */ CWORD_CWORD_CWORD_CWORD,
816 /* 61 -69 */ CWORD_CWORD_CWORD_CWORD,
817 /* 62 -68 */ CWORD_CWORD_CWORD_CWORD,
818 /* 63 -67 */ CWORD_CWORD_CWORD_CWORD,
819 /* 64 -66 */ CWORD_CWORD_CWORD_CWORD,
820 /* 65 -65 */ CWORD_CWORD_CWORD_CWORD,
821 /* 66 -64 */ CWORD_CWORD_CWORD_CWORD,
822 /* 67 -63 */ CWORD_CWORD_CWORD_CWORD,
823 /* 68 -62 */ CWORD_CWORD_CWORD_CWORD,
824 /* 69 -61 */ CWORD_CWORD_CWORD_CWORD,
825 /* 70 -60 */ CWORD_CWORD_CWORD_CWORD,
826 /* 71 -59 */ CWORD_CWORD_CWORD_CWORD,
827 /* 72 -58 */ CWORD_CWORD_CWORD_CWORD,
828 /* 73 -57 */ CWORD_CWORD_CWORD_CWORD,
829 /* 74 -56 */ CWORD_CWORD_CWORD_CWORD,
830 /* 75 -55 */ CWORD_CWORD_CWORD_CWORD,
831 /* 76 -54 */ CWORD_CWORD_CWORD_CWORD,
832 /* 77 -53 */ CWORD_CWORD_CWORD_CWORD,
833 /* 78 -52 */ CWORD_CWORD_CWORD_CWORD,
834 /* 79 -51 */ CWORD_CWORD_CWORD_CWORD,
835 /* 80 -50 */ CWORD_CWORD_CWORD_CWORD,
836 /* 81 -49 */ CWORD_CWORD_CWORD_CWORD,
837 /* 82 -48 */ CWORD_CWORD_CWORD_CWORD,
838 /* 83 -47 */ CWORD_CWORD_CWORD_CWORD,
839 /* 84 -46 */ CWORD_CWORD_CWORD_CWORD,
840 /* 85 -45 */ CWORD_CWORD_CWORD_CWORD,
841 /* 86 -44 */ CWORD_CWORD_CWORD_CWORD,
842 /* 87 -43 */ CWORD_CWORD_CWORD_CWORD,
843 /* 88 -42 */ CWORD_CWORD_CWORD_CWORD,
844 /* 89 -41 */ CWORD_CWORD_CWORD_CWORD,
845 /* 90 -40 */ CWORD_CWORD_CWORD_CWORD,
846 /* 91 -39 */ CWORD_CWORD_CWORD_CWORD,
847 /* 92 -38 */ CWORD_CWORD_CWORD_CWORD,
848 /* 93 -37 */ CWORD_CWORD_CWORD_CWORD,
849 /* 94 -36 */ CWORD_CWORD_CWORD_CWORD,
850 /* 95 -35 */ CWORD_CWORD_CWORD_CWORD,
851 /* 96 -34 */ CWORD_CWORD_CWORD_CWORD,
852 /* 97 -33 */ CWORD_CWORD_CWORD_CWORD,
853 /* 98 -32 */ CWORD_CWORD_CWORD_CWORD,
854 /* 99 -31 */ CWORD_CWORD_CWORD_CWORD,
855 /* 100 -30 */ CWORD_CWORD_CWORD_CWORD,
856 /* 101 -29 */ CWORD_CWORD_CWORD_CWORD,
857 /* 102 -28 */ CWORD_CWORD_CWORD_CWORD,
858 /* 103 -27 */ CWORD_CWORD_CWORD_CWORD,
859 /* 104 -26 */ CWORD_CWORD_CWORD_CWORD,
860 /* 105 -25 */ CWORD_CWORD_CWORD_CWORD,
861 /* 106 -24 */ CWORD_CWORD_CWORD_CWORD,
862 /* 107 -23 */ CWORD_CWORD_CWORD_CWORD,
863 /* 108 -22 */ CWORD_CWORD_CWORD_CWORD,
864 /* 109 -21 */ CWORD_CWORD_CWORD_CWORD,
865 /* 110 -20 */ CWORD_CWORD_CWORD_CWORD,
866 /* 111 -19 */ CWORD_CWORD_CWORD_CWORD,
867 /* 112 -18 */ CWORD_CWORD_CWORD_CWORD,
868 /* 113 -17 */ CWORD_CWORD_CWORD_CWORD,
869 /* 114 -16 */ CWORD_CWORD_CWORD_CWORD,
870 /* 115 -15 */ CWORD_CWORD_CWORD_CWORD,
871 /* 116 -14 */ CWORD_CWORD_CWORD_CWORD,
872 /* 117 -13 */ CWORD_CWORD_CWORD_CWORD,
873 /* 118 -12 */ CWORD_CWORD_CWORD_CWORD,
874 /* 119 -11 */ CWORD_CWORD_CWORD_CWORD,
875 /* 120 -10 */ CWORD_CWORD_CWORD_CWORD,
876 /* 121 -9 */ CWORD_CWORD_CWORD_CWORD,
877 /* 122 -8 */ CWORD_CWORD_CWORD_CWORD,
878 /* 123 -7 */ CWORD_CWORD_CWORD_CWORD,
879 /* 124 -6 */ CWORD_CWORD_CWORD_CWORD,
880 /* 125 -5 */ CWORD_CWORD_CWORD_CWORD,
881 /* 126 -4 */ CWORD_CWORD_CWORD_CWORD,
882 /* 127 -3 */ CWORD_CWORD_CWORD_CWORD,
883 /* 128 -2 */ CWORD_CWORD_CWORD_CWORD,
884 /* 129 -1 */ CWORD_CWORD_CWORD_CWORD,
885 /* 130 0 */ CWORD_CWORD_CWORD_CWORD,
886 /* 131 1 */ CWORD_CWORD_CWORD_CWORD,
887 /* 132 2 */ CWORD_CWORD_CWORD_CWORD,
888 /* 133 3 */ CWORD_CWORD_CWORD_CWORD,
889 /* 134 4 */ CWORD_CWORD_CWORD_CWORD,
890 /* 135 5 */ CWORD_CWORD_CWORD_CWORD,
891 /* 136 6 */ CWORD_CWORD_CWORD_CWORD,
892 /* 137 7 */ CWORD_CWORD_CWORD_CWORD,
893 /* 138 8 */ CWORD_CWORD_CWORD_CWORD,
894 /* 139 9 "\t" */ CSPCL_CWORD_CWORD_CWORD,
895 /* 140 10 "\n" */ CNL_CNL_CNL_CNL,
896 /* 141 11 */ CWORD_CWORD_CWORD_CWORD,
897 /* 142 12 */ CWORD_CWORD_CWORD_CWORD,
898 /* 143 13 */ CWORD_CWORD_CWORD_CWORD,
899 /* 144 14 */ CWORD_CWORD_CWORD_CWORD,
900 /* 145 15 */ CWORD_CWORD_CWORD_CWORD,
901 /* 146 16 */ CWORD_CWORD_CWORD_CWORD,
902 /* 147 17 */ CWORD_CWORD_CWORD_CWORD,
903 /* 148 18 */ CWORD_CWORD_CWORD_CWORD,
904 /* 149 19 */ CWORD_CWORD_CWORD_CWORD,
905 /* 150 20 */ CWORD_CWORD_CWORD_CWORD,
906 /* 151 21 */ CWORD_CWORD_CWORD_CWORD,
907 /* 152 22 */ CWORD_CWORD_CWORD_CWORD,
908 /* 153 23 */ CWORD_CWORD_CWORD_CWORD,
909 /* 154 24 */ CWORD_CWORD_CWORD_CWORD,
910 /* 155 25 */ CWORD_CWORD_CWORD_CWORD,
911 /* 156 26 */ CWORD_CWORD_CWORD_CWORD,
912 /* 157 27 */ CWORD_CWORD_CWORD_CWORD,
913 /* 158 28 */ CWORD_CWORD_CWORD_CWORD,
914 /* 159 29 */ CWORD_CWORD_CWORD_CWORD,
915 /* 160 30 */ CWORD_CWORD_CWORD_CWORD,
916 /* 161 31 */ CWORD_CWORD_CWORD_CWORD,
917 /* 162 32 " " */ CSPCL_CWORD_CWORD_CWORD,
918 /* 163 33 "!" */ CWORD_CCTL_CCTL_CWORD,
919 /* 164 34 """ */ CDQUOTE_CENDQUOTE_CWORD_CDQUOTE,
920 /* 165 35 "#" */ CWORD_CWORD_CWORD_CWORD,
921 /* 166 36 "$" */ CVAR_CVAR_CWORD_CVAR,
922 /* 167 37 "%" */ CWORD_CWORD_CWORD_CWORD,
923 /* 168 38 "&" */ CSPCL_CWORD_CWORD_CWORD,
924 /* 169 39 "'" */ CSQUOTE_CWORD_CENDQUOTE_CSQUOTE,
925 /* 170 40 "(" */ CSPCL_CWORD_CWORD_CLP,
926 /* 171 41 ")" */ CSPCL_CWORD_CWORD_CRP,
927 /* 172 42 "*" */ CWORD_CCTL_CCTL_CWORD,
928 /* 173 43 "+" */ CWORD_CWORD_CWORD_CWORD,
929 /* 174 44 "," */ CWORD_CWORD_CWORD_CWORD,
930 /* 175 45 "-" */ CWORD_CCTL_CCTL_CWORD,
931 /* 176 46 "." */ CWORD_CWORD_CWORD_CWORD,
932 /* 177 47 "/" */ CWORD_CCTL_CCTL_CWORD,
933 /* 178 48 "0" */ CWORD_CWORD_CWORD_CWORD,
934 /* 179 49 "1" */ CWORD_CWORD_CWORD_CWORD,
935 /* 180 50 "2" */ CWORD_CWORD_CWORD_CWORD,
936 /* 181 51 "3" */ CWORD_CWORD_CWORD_CWORD,
937 /* 182 52 "4" */ CWORD_CWORD_CWORD_CWORD,
938 /* 183 53 "5" */ CWORD_CWORD_CWORD_CWORD,
939 /* 184 54 "6" */ CWORD_CWORD_CWORD_CWORD,
940 /* 185 55 "7" */ CWORD_CWORD_CWORD_CWORD,
941 /* 186 56 "8" */ CWORD_CWORD_CWORD_CWORD,
942 /* 187 57 "9" */ CWORD_CWORD_CWORD_CWORD,
943 /* 188 58 ":" */ CWORD_CCTL_CCTL_CWORD,
944 /* 189 59 ";" */ CSPCL_CWORD_CWORD_CWORD,
945 /* 190 60 "<" */ CSPCL_CWORD_CWORD_CWORD,
946 /* 191 61 "=" */ CWORD_CCTL_CCTL_CWORD,
947 /* 192 62 ">" */ CSPCL_CWORD_CWORD_CWORD,
948 /* 193 63 "?" */ CWORD_CCTL_CCTL_CWORD,
949 /* 194 64 "@" */ CWORD_CWORD_CWORD_CWORD,
950 /* 195 65 "A" */ CWORD_CWORD_CWORD_CWORD,
951 /* 196 66 "B" */ CWORD_CWORD_CWORD_CWORD,
952 /* 197 67 "C" */ CWORD_CWORD_CWORD_CWORD,
953 /* 198 68 "D" */ CWORD_CWORD_CWORD_CWORD,
954 /* 199 69 "E" */ CWORD_CWORD_CWORD_CWORD,
955 /* 200 70 "F" */ CWORD_CWORD_CWORD_CWORD,
956 /* 201 71 "G" */ CWORD_CWORD_CWORD_CWORD,
957 /* 202 72 "H" */ CWORD_CWORD_CWORD_CWORD,
958 /* 203 73 "I" */ CWORD_CWORD_CWORD_CWORD,
959 /* 204 74 "J" */ CWORD_CWORD_CWORD_CWORD,
960 /* 205 75 "K" */ CWORD_CWORD_CWORD_CWORD,
961 /* 206 76 "L" */ CWORD_CWORD_CWORD_CWORD,
962 /* 207 77 "M" */ CWORD_CWORD_CWORD_CWORD,
963 /* 208 78 "N" */ CWORD_CWORD_CWORD_CWORD,
964 /* 209 79 "O" */ CWORD_CWORD_CWORD_CWORD,
965 /* 210 80 "P" */ CWORD_CWORD_CWORD_CWORD,
966 /* 211 81 "Q" */ CWORD_CWORD_CWORD_CWORD,
967 /* 212 82 "R" */ CWORD_CWORD_CWORD_CWORD,
968 /* 213 83 "S" */ CWORD_CWORD_CWORD_CWORD,
969 /* 214 84 "T" */ CWORD_CWORD_CWORD_CWORD,
970 /* 215 85 "U" */ CWORD_CWORD_CWORD_CWORD,
971 /* 216 86 "V" */ CWORD_CWORD_CWORD_CWORD,
972 /* 217 87 "W" */ CWORD_CWORD_CWORD_CWORD,
973 /* 218 88 "X" */ CWORD_CWORD_CWORD_CWORD,
974 /* 219 89 "Y" */ CWORD_CWORD_CWORD_CWORD,
975 /* 220 90 "Z" */ CWORD_CWORD_CWORD_CWORD,
976 /* 221 91 "[" */ CWORD_CCTL_CCTL_CWORD,
977 /* 222 92 "\" */ CBACK_CBACK_CCTL_CBACK,
978 /* 223 93 "]" */ CWORD_CCTL_CCTL_CWORD,
979 /* 224 94 "^" */ CWORD_CWORD_CWORD_CWORD,
980 /* 225 95 "_" */ CWORD_CWORD_CWORD_CWORD,
981 /* 226 96 "`" */ CBQUOTE_CBQUOTE_CWORD_CBQUOTE,
982 /* 227 97 "a" */ CWORD_CWORD_CWORD_CWORD,
983 /* 228 98 "b" */ CWORD_CWORD_CWORD_CWORD,
984 /* 229 99 "c" */ CWORD_CWORD_CWORD_CWORD,
985 /* 230 100 "d" */ CWORD_CWORD_CWORD_CWORD,
986 /* 231 101 "e" */ CWORD_CWORD_CWORD_CWORD,
987 /* 232 102 "f" */ CWORD_CWORD_CWORD_CWORD,
988 /* 233 103 "g" */ CWORD_CWORD_CWORD_CWORD,
989 /* 234 104 "h" */ CWORD_CWORD_CWORD_CWORD,
990 /* 235 105 "i" */ CWORD_CWORD_CWORD_CWORD,
991 /* 236 106 "j" */ CWORD_CWORD_CWORD_CWORD,
992 /* 237 107 "k" */ CWORD_CWORD_CWORD_CWORD,
993 /* 238 108 "l" */ CWORD_CWORD_CWORD_CWORD,
994 /* 239 109 "m" */ CWORD_CWORD_CWORD_CWORD,
995 /* 240 110 "n" */ CWORD_CWORD_CWORD_CWORD,
996 /* 241 111 "o" */ CWORD_CWORD_CWORD_CWORD,
997 /* 242 112 "p" */ CWORD_CWORD_CWORD_CWORD,
998 /* 243 113 "q" */ CWORD_CWORD_CWORD_CWORD,
999 /* 244 114 "r" */ CWORD_CWORD_CWORD_CWORD,
1000 /* 245 115 "s" */ CWORD_CWORD_CWORD_CWORD,
1001 /* 246 116 "t" */ CWORD_CWORD_CWORD_CWORD,
1002 /* 247 117 "u" */ CWORD_CWORD_CWORD_CWORD,
1003 /* 248 118 "v" */ CWORD_CWORD_CWORD_CWORD,
1004 /* 249 119 "w" */ CWORD_CWORD_CWORD_CWORD,
1005 /* 250 120 "x" */ CWORD_CWORD_CWORD_CWORD,
1006 /* 251 121 "y" */ CWORD_CWORD_CWORD_CWORD,
1007 /* 252 122 "z" */ CWORD_CWORD_CWORD_CWORD,
1008 /* 253 123 "{" */ CWORD_CWORD_CWORD_CWORD,
1009 /* 254 124 "|" */ CSPCL_CWORD_CWORD_CWORD,
1010 /* 255 125 "}" */ CENDVAR_CENDVAR_CWORD_CENDVAR,
1011 /* 256 126 "~" */ CWORD_CCTL_CCTL_CWORD,
1012 /* 257 127 */ CWORD_CWORD_CWORD_CWORD,
1015 #endif /* USE_SIT_FUNCTION */
1018 /* first char is indicating which tokens mark the end of a list */
1019 static const char *const tokname_array[] = {
1034 #define KWDOFFSET 14
1035 /* the following are keywords */
1054 static const char *tokname(int tok)
1056 static char buf[16];
1060 sprintf(buf + (tok >= TSEMI), "%s%c",
1061 tokname_array[tok] + 1, (tok >= TSEMI ? '"' : 0));
1065 static int plinno = 1; /* input line number */
1067 static int parselleft; /* copy of parsefile->lleft */
1069 static struct parsefile basepf; /* top level input file */
1070 static char basebuf[BUFSIZ]; /* buffer for top level input file */
1071 static struct parsefile *parsefile = &basepf; /* current input file */
1074 * NEOF is returned by parsecmd when it encounters an end of file. It
1075 * must be distinct from NULL, so we use the address of a variable that
1076 * happens to be handy.
1079 static int tokpushback; /* last token pushed back */
1081 #define NEOF ((union node *)&tokpushback)
1082 static int checkkwd; /* 1 == check for kwds, 2 == also eat newlines */
1085 static void error(const char *, ...) __attribute__ ((__noreturn__));
1086 static void exerror(int, const char *, ...) __attribute__ ((__noreturn__));
1087 static void shellexec(char **, char **, const char *, int)
1088 __attribute__ ((noreturn));
1089 static void exitshell(int) __attribute__ ((noreturn));
1091 static int goodname(const char *);
1092 static void ignoresig(int);
1093 static void onsig(int);
1094 static void dotrap(void);
1095 static int decode_signal(const char *, int);
1097 static void setparam(char **);
1098 static void freeparam(volatile struct shparam *);
1100 /* reasons for skipping commands (see comment on breakcmd routine) */
1106 /* values of cmdtype */
1107 #define CMDUNKNOWN -1 /* no entry in table for command */
1108 #define CMDNORMAL 0 /* command is an executable program */
1109 #define CMDBUILTIN 1 /* command is a shell builtin */
1110 #define CMDFUNCTION 2 /* command is a shell function */
1112 #define DO_ERR 1 /* find_command prints errors */
1113 #define DO_ABS 2 /* find_command checks absolute paths */
1114 #define DO_NOFUN 4 /* find_command ignores functions */
1115 #define DO_BRUTE 8 /* find_command ignores hash table */
1122 #define VEXPORT 0x01 /* variable is exported */
1123 #define VREADONLY 0x02 /* variable cannot be modified */
1124 #define VSTRFIXED 0x04 /* variable struct is staticly allocated */
1125 #define VTEXTFIXED 0x08 /* text is staticly allocated */
1126 #define VSTACK 0x10 /* text is allocated on the stack */
1127 #define VUNSET 0x20 /* the variable is not set */
1128 #define VNOFUNC 0x40 /* don't call the callback function */
1132 struct var *next; /* next entry in hash list */
1133 int flags; /* flags are defined above */
1134 char *text; /* name=value */
1135 void (*func) (const char *);
1136 /* function to be called when */
1137 /* the variable gets set/unset */
1141 struct localvar *next; /* next local variable in list */
1142 struct var *vp; /* the variable that was made local */
1143 int flags; /* saved flags */
1144 char *text; /* saved text */
1148 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
1149 #define rmescapes(p) _rmescapes((p), 0)
1150 static char *_rmescapes(char *, int);
1152 static void rmescapes(char *);
1155 static int casematch(union node *, const char *);
1156 static void clearredir(void);
1157 static void popstring(void);
1158 static void readcmdfile(const char *);
1160 static int number(const char *);
1161 static int is_number(const char *, int *num);
1162 static char *single_quote(const char *);
1163 static int nextopt(const char *);
1165 static void redirect(union node *, int);
1166 static void popredir(void);
1167 static int dup_as_newfd(int, int);
1169 static void changepath(const char *newval);
1170 static void getoptsreset(const char *value);
1173 static int parsenleft; /* copy of parsefile->nleft */
1174 static char *parsenextc; /* copy of parsefile->nextc */
1175 static int rootpid; /* pid of main shell */
1176 static int rootshell; /* true if we aren't a child of the main shell */
1178 static const char spcstr[] = " ";
1179 static const char snlfmt[] = "%s\n";
1181 static int sstrnleft;
1182 static int herefd = -1;
1184 static struct localvar *localvars;
1186 static struct var vifs;
1187 static struct var vmail;
1188 static struct var vmpath;
1189 static struct var vpath;
1190 static struct var vps1;
1191 static struct var vps2;
1192 static struct var voptind;
1194 #ifdef CONFIG_LOCALE_SUPPORT
1195 static struct var vlc_all;
1196 static struct var vlc_ctype;
1199 #ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
1200 static struct var vhistfile;
1207 void (*func) (const char *);
1210 static const char defpathvar[] =
1211 "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
1212 #define defpath (defpathvar + 5)
1215 static const char defifsvar[] = "IFS= \t\n";
1217 #define defifs (defifsvar + 4)
1219 static const char defifs[] = " \t\n";
1222 static const struct varinit varinit[] = {
1224 {&vifs, VSTRFIXED | VTEXTFIXED, defifsvar,
1226 {&vifs, VSTRFIXED | VTEXTFIXED | VUNSET, "IFS=",
1229 {&vmail, VSTRFIXED | VTEXTFIXED | VUNSET, "MAIL=",
1231 {&vmpath, VSTRFIXED | VTEXTFIXED | VUNSET, "MAILPATH=",
1233 {&vpath, VSTRFIXED | VTEXTFIXED, defpathvar,
1235 #if defined(CONFIG_FEATURE_COMMAND_EDITING) && defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
1236 {&vps1, VSTRFIXED | VTEXTFIXED, "PS1=\\w \\$ ",
1238 #endif /* else vps1 depends on uid */
1239 {&vps2, VSTRFIXED | VTEXTFIXED, "PS2=> ",
1241 {&voptind, VSTRFIXED | VTEXTFIXED, "OPTIND=1",
1243 #ifdef CONFIG_LOCALE_SUPPORT
1244 {&vlc_all, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_ALL=",
1246 {&vlc_ctype, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_CTYPE=",
1249 #ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
1250 {&vhistfile, VSTRFIXED | VTEXTFIXED | VUNSET, "HISTFILE=",
1259 static struct var *vartab[VTABSIZE];
1262 * The following macros access the values of the above variables.
1263 * They have to skip over the name. They return the null string
1264 * for unset variables.
1267 #define ifsval() (vifs.text + 4)
1268 #define ifsset() ((vifs.flags & VUNSET) == 0)
1269 #define mailval() (vmail.text + 5)
1270 #define mpathval() (vmpath.text + 9)
1271 #define pathval() (vpath.text + 5)
1272 #define ps1val() (vps1.text + 4)
1273 #define ps2val() (vps2.text + 4)
1274 #define optindval() (voptind.text + 7)
1276 #define mpathset() ((vmpath.flags & VUNSET) == 0)
1278 static void initvar(void);
1279 static void setvar(const char *, const char *, int);
1280 static void setvareq(char *, int);
1281 static void listsetvar(struct strlist *);
1282 static const char *lookupvar(const char *);
1283 static const char *bltinlookup(const char *);
1284 static char **environment(void);
1285 static int showvarscmd(int, char **);
1286 static void mklocal(char *);
1287 static void poplocalvars(void);
1288 static int unsetvar(const char *);
1289 static int varequal(const char *, const char *);
1292 static char *arg0; /* value of $0 */
1293 static struct shparam shellparam; /* current positional parameters */
1294 static char **argptr; /* argument list for builtin commands */
1295 static char *optionarg; /* set by nextopt (like getopt) */
1296 static char *optptr; /* used by nextopt */
1297 static char *minusc; /* argument to -c option */
1300 #ifdef CONFIG_ASH_ALIAS
1302 #define ALIASINUSE 1
1314 static struct alias *atab[ATABSIZE];
1316 static void setalias(char *, char *);
1317 static struct alias **hashalias(const char *);
1318 static struct alias *freealias(struct alias *);
1319 static struct alias **__lookupalias(const char *);
1321 static void setalias(char *name, char *val)
1323 struct alias *ap, **app;
1325 app = __lookupalias(name);
1329 if (!(ap->flag & ALIASINUSE)) {
1332 ap->val = xstrdup(val);
1333 ap->flag &= ~ALIASDEAD;
1336 ap = xmalloc(sizeof(struct alias));
1337 ap->name = xstrdup(name);
1338 ap->val = xstrdup(val);
1346 static int unalias(char *name)
1350 app = __lookupalias(name);
1354 *app = freealias(*app);
1362 static void rmaliases(void)
1364 struct alias *ap, **app;
1368 for (i = 0; i < ATABSIZE; i++) {
1370 for (ap = *app; ap; ap = *app) {
1371 *app = freealias(*app);
1380 static void printalias(const struct alias *ap)
1384 p = single_quote(ap->val);
1385 printf("alias %s=%s\n", ap->name, p);
1391 * TODO - sort output
1393 static int aliascmd(int argc, char **argv)
1402 for (i = 0; i < ATABSIZE; i++)
1403 for (ap = atab[i]; ap; ap = ap->next) {
1408 while ((n = *++argv) != NULL) {
1409 if ((v = strchr(n + 1, '=')) == NULL) { /* n+1: funny ksh stuff */
1410 if ((ap = *__lookupalias(n)) == NULL) {
1411 out2fmt("%s: %s not found\n", "alias", n);
1424 static int unaliascmd(int argc, char **argv)
1428 while ((i = nextopt("a")) != '\0') {
1434 for (i = 0; *argptr; argptr++) {
1435 if (unalias(*argptr)) {
1436 out2fmt("%s: %s not found\n", "unalias", *argptr);
1444 static struct alias **hashalias(const char *p)
1446 unsigned int hashval;
1451 return &atab[hashval % ATABSIZE];
1454 static struct alias *freealias(struct alias *ap)
1458 if (ap->flag & ALIASINUSE) {
1459 ap->flag |= ALIASDEAD;
1471 static struct alias **__lookupalias(const char *name)
1473 struct alias **app = hashalias(name);
1475 for (; *app; app = &(*app)->next) {
1476 if (equal(name, (*app)->name)) {
1485 #ifdef CONFIG_ASH_MATH_SUPPORT
1486 /* The generated file arith.c has been replaced with a custom hand
1487 * written implementation written by Aaron Lehmann <aaronl@vitelus.com>.
1488 * This is now part of libbb, so that it can be used by all the shells
1490 static void expari(int);
1493 static char *trap[NSIG]; /* trap handler commands */
1494 static char sigmode[NSIG - 1]; /* current value of signal */
1495 static char gotsig[NSIG - 1]; /* indicates specified signal received */
1496 static int pendingsigs; /* indicates some signal received */
1499 * This file was generated by the mkbuiltins program.
1502 #ifdef CONFIG_ASH_JOB_CONTROL
1503 static int bgcmd(int, char **);
1504 static int fgcmd(int, char **);
1505 static int killcmd(int, char **);
1507 static int bltincmd(int, char **);
1508 static int cdcmd(int, char **);
1509 static int breakcmd(int, char **);
1511 #ifdef CONFIG_ASH_CMDCMD
1512 static int commandcmd(int, char **);
1514 static int dotcmd(int, char **);
1515 static int evalcmd(int, char **);
1516 static int execcmd(int, char **);
1517 static int exitcmd(int, char **);
1518 static int exportcmd(int, char **);
1519 static int histcmd(int, char **);
1520 static int hashcmd(int, char **);
1521 static int helpcmd(int, char **);
1522 static int jobscmd(int, char **);
1523 static int localcmd(int, char **);
1524 static int pwdcmd(int, char **);
1525 static int readcmd(int, char **);
1526 static int returncmd(int, char **);
1527 static int setcmd(int, char **);
1528 static int setvarcmd(int, char **);
1529 static int shiftcmd(int, char **);
1530 static int trapcmd(int, char **);
1531 static int umaskcmd(int, char **);
1533 #ifdef CONFIG_ASH_ALIAS
1534 static int aliascmd(int, char **);
1535 static int unaliascmd(int, char **);
1537 static int unsetcmd(int, char **);
1538 static int waitcmd(int, char **);
1539 static int ulimitcmd(int, char **);
1540 static int timescmd(int, char **);
1542 #ifdef CONFIG_ASH_MATH_SUPPORT
1543 static int letcmd(int, char **);
1545 static int typecmd(int, char **);
1547 #ifdef CONFIG_ASH_GETOPTS
1548 static int getoptscmd(int, char **);
1552 static int true_main(int, char **);
1554 #ifndef CONFIG_FALSE
1555 static int false_main(int, char **);
1558 static void setpwd(const char *, int);
1561 #define BUILTIN_NOSPEC "0"
1562 #define BUILTIN_SPECIAL "1"
1563 #define BUILTIN_REGULAR "2"
1564 #define BUILTIN_ASSIGN "4"
1565 #define BUILTIN_SPEC_ASSG "5"
1566 #define BUILTIN_REG_ASSG "6"
1568 #define IS_BUILTIN_SPECIAL(builtincmd) ((builtincmd)->name[0] & 1)
1569 #define IS_BUILTIN_REGULAR(builtincmd) ((builtincmd)->name[0] & 2)
1570 #define IS_BUILTIN_ASSIGN(builtincmd) ((builtincmd)->name[0] & 4)
1574 int (*const builtinfunc) (int, char **);
1579 /* It is CRUCIAL that this listing be kept in ascii order, otherwise
1580 * the binary search in find_builtin() will stop working. If you value
1581 * your kneecaps, you'll be sure to *make sure* that any changes made
1582 * to this array result in the listing remaining in ascii order. You
1585 static const struct builtincmd builtincmds[] = {
1586 {BUILTIN_SPECIAL ".", dotcmd}, /* first, see declare DOTCMD */
1587 {BUILTIN_SPECIAL ":", true_main},
1588 #ifdef CONFIG_ASH_ALIAS
1589 {BUILTIN_REG_ASSG "alias", aliascmd},
1591 #ifdef CONFIG_ASH_JOB_CONTROL
1592 {BUILTIN_REGULAR "bg", bgcmd},
1594 {BUILTIN_SPECIAL "break", breakcmd},
1595 {BUILTIN_SPECIAL "builtin", bltincmd},
1596 {BUILTIN_REGULAR "cd", cdcmd},
1597 {BUILTIN_NOSPEC "chdir", cdcmd},
1598 #ifdef CONFIG_ASH_CMDCMD
1599 {BUILTIN_REGULAR "command", commandcmd},
1601 {BUILTIN_SPECIAL "continue", breakcmd},
1602 {BUILTIN_SPECIAL "eval", evalcmd},
1603 {BUILTIN_SPECIAL "exec", execcmd},
1604 {BUILTIN_SPECIAL "exit", exitcmd},
1605 {BUILTIN_SPEC_ASSG "export", exportcmd},
1606 {BUILTIN_REGULAR "false", false_main},
1607 {BUILTIN_REGULAR "fc", histcmd},
1608 #ifdef CONFIG_ASH_JOB_CONTROL
1609 {BUILTIN_REGULAR "fg", fgcmd},
1611 #ifdef CONFIG_ASH_GETOPTS
1612 {BUILTIN_REGULAR "getopts", getoptscmd},
1614 {BUILTIN_NOSPEC "hash", hashcmd},
1615 {BUILTIN_NOSPEC "help", helpcmd},
1616 {BUILTIN_REGULAR "jobs", jobscmd},
1617 #ifdef CONFIG_ASH_JOB_CONTROL
1618 {BUILTIN_REGULAR "kill", killcmd},
1620 #ifdef CONFIG_ASH_MATH_SUPPORT
1621 {BUILTIN_REGULAR "let", letcmd},
1623 {BUILTIN_ASSIGN "local", localcmd},
1624 {BUILTIN_NOSPEC "pwd", pwdcmd},
1625 {BUILTIN_REGULAR "read", readcmd},
1626 {BUILTIN_SPEC_ASSG "readonly", exportcmd},
1627 {BUILTIN_SPECIAL "return", returncmd},
1628 {BUILTIN_SPECIAL "set", setcmd},
1629 {BUILTIN_NOSPEC "setvar", setvarcmd},
1630 {BUILTIN_SPECIAL "shift", shiftcmd},
1631 {BUILTIN_SPECIAL "times", timescmd},
1632 {BUILTIN_SPECIAL "trap", trapcmd},
1633 {BUILTIN_REGULAR "true", true_main},
1634 {BUILTIN_NOSPEC "type", typecmd},
1635 {BUILTIN_NOSPEC "ulimit", ulimitcmd},
1636 {BUILTIN_REGULAR "umask", umaskcmd},
1637 #ifdef CONFIG_ASH_ALIAS
1638 {BUILTIN_REGULAR "unalias", unaliascmd},
1640 {BUILTIN_SPECIAL "unset", unsetcmd},
1641 {BUILTIN_REGULAR "wait", waitcmd},
1644 #define NUMBUILTINS (sizeof (builtincmds) / sizeof (struct builtincmd) )
1646 #define DOTCMD &builtincmds[0]
1647 static struct builtincmd *BLTINCMD;
1648 static struct builtincmd *EXECCMD;
1649 static struct builtincmd *EVALCMD;
1652 #define JOBSTOPPED 1 /* all procs are stopped */
1653 #define JOBDONE 2 /* all procs are completed */
1656 * A job structure contains information about a job. A job is either a
1657 * single process or a set of processes contained in a pipeline. In the
1658 * latter case, pidlist will be non-NULL, and will point to a -1 terminated
1663 pid_t pid; /* process id */
1664 int status; /* status flags (defined above) */
1665 char *cmd; /* text of command being run */
1669 static int job_warning; /* user was warned about stopped jobs */
1671 #ifdef CONFIG_ASH_JOB_CONTROL
1672 static void setjobctl(int enable);
1674 #define setjobctl(on) /* do nothing */
1679 struct procstat ps0; /* status of process */
1680 struct procstat *ps; /* status or processes when more than one */
1681 short nprocs; /* number of processes */
1682 short pgrp; /* process group of this job */
1683 char state; /* true if job is finished */
1684 char used; /* true if this entry is in used */
1685 char changed; /* true if status has changed */
1686 #ifdef CONFIG_ASH_JOB_CONTROL
1687 char jobctl; /* job running under job control */
1691 static struct job *jobtab; /* array of jobs */
1692 static int njobs; /* size of array */
1693 static int backgndpid = -1; /* pid of last background process */
1695 #ifdef CONFIG_ASH_JOB_CONTROL
1696 static int initialpgrp; /* pgrp of shell on invocation */
1697 static int curjob; /* current job */
1701 static struct job *makejob(const union node *, int);
1702 static int forkshell(struct job *, const union node *, int);
1703 static int waitforjob(struct job *);
1705 static int docd(char *, int);
1706 static void getpwd(void);
1708 static char *padvance(const char **, const char *);
1710 static char nullstr[1]; /* zero length string */
1711 static char *curdir = nullstr; /* current working directory */
1713 static int cdcmd(int argc, char **argv)
1722 if ((dest = *argptr) == NULL && (dest = bltinlookup("HOME")) == NULL)
1723 error("HOME not set");
1726 if (dest[0] == '-' && dest[1] == '\0') {
1727 dest = bltinlookup("OLDPWD");
1728 if (!dest || !*dest) {
1737 if (*dest == '/' || (path = bltinlookup("CDPATH")) == NULL)
1739 while ((p = padvance(&path, dest)) != NULL) {
1740 if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) {
1745 if (p[0] == '.' && p[1] == '/' && p[2] != '\0')
1747 print = strcmp(p, dest);
1749 if (docd(p, print) >= 0)
1754 error("can't cd to %s", dest);
1760 * Update curdir (the name of the current directory) in response to a
1761 * cd command. We also call hashcd to let the routines in exec.c know
1762 * that the current directory has changed.
1765 static void hashcd(void);
1767 static inline void updatepwd(const char *dir)
1769 hashcd(); /* update command hash table */
1772 * If our argument is NULL, we don't know the current directory
1774 if (dir == NULL || curdir == nullstr) {
1782 * Actually do the chdir. In an interactive shell, print the
1783 * directory name if "print" is nonzero.
1786 static int docd(char *dest, int print)
1788 TRACE(("docd(\"%s\", %d) called\n", dest, print));
1790 if (chdir(dest) < 0) {
1802 static int pwdcmd(int argc, char **argv)
1808 /* Ask system the current directory */
1809 static void getpwd(void)
1811 curdir = xgetcwd(0);
1816 static void setpwd(const char *val, int setold)
1821 setvar("OLDPWD", curdir, VEXPORT);
1824 if (curdir != nullstr) {
1825 if (val != NULL && *val != '/')
1826 val = cated = concat_path_file(curdir, val);
1832 curdir = simplify_path(val);
1835 setvar("PWD", curdir, VEXPORT);
1839 * Errors and exceptions.
1843 * Code to handle exceptions in C.
1847 * We enclose jmp_buf in a structure so that we can declare pointers to
1848 * jump locations. The global variable handler contains the location to
1849 * jump to when an exception occurs, and the global variable exception
1850 * contains a code identifying the exeception. To implement nested
1851 * exception handlers, the user should save the value of handler on entry
1852 * to an inner scope, set handler to point to a jmploc structure for the
1853 * inner scope, and restore handler on exit from the scope.
1861 #define EXINT 0 /* SIGINT received */
1862 #define EXERROR 1 /* a generic error */
1863 #define EXSHELLPROC 2 /* execute a shell procedure */
1864 #define EXEXEC 3 /* command execution failed */
1865 #define EXREDIR 4 /* redirection error */
1867 static struct jmploc *handler;
1868 static int exception;
1870 static void exverror(int, const char *, va_list)
1871 __attribute__ ((__noreturn__));
1874 * Called to raise an exception. Since C doesn't include exceptions, we
1875 * just do a longjmp to the exception handler. The type of exception is
1876 * stored in the global variable "exception".
1879 static void exraise(int) __attribute__ ((__noreturn__));
1881 static void exraise(int e)
1884 if (handler == NULL)
1889 longjmp(handler->loc, 1);
1894 * Called from trap.c when a SIGINT is received. (If the user specifies
1895 * that SIGINT is to be trapped or ignored using the trap builtin, then
1896 * this routine is not called.) Suppressint is nonzero when interrupts
1897 * are held using the INTOFF macro. The call to _exit is necessary because
1898 * there is a short period after a fork before the signal handlers are
1899 * set to the appropriate value for the child. (The test for iflag is
1900 * just defensive programming.)
1903 static void onint(void)
1912 sigemptyset(&mysigset);
1913 sigprocmask(SIG_SETMASK, &mysigset, NULL);
1914 if (!(rootshell && iflag)) {
1915 signal(SIGINT, SIG_DFL);
1923 static char *commandname; /* currently executing command */
1926 * Exverror is called to raise the error exception. If the first argument
1927 * is not NULL then error prints an error message using printf style
1928 * formatting. It then raises the error exception.
1930 static void exverror(int cond, const char *msg, va_list ap)
1937 TRACE(("exverror(%d, \"%s\") pid=%d\n", cond, msg, getpid()));
1939 TRACE(("exverror(%d, NULL) pid=%d\n", cond, getpid()));
1943 out2fmt("%s: ", commandname);
1944 vfprintf(stderr, msg, ap);
1952 static void error(const char *msg, ...)
1957 exverror(EXERROR, msg, ap);
1963 static void exerror(int cond, const char *msg, ...)
1968 exverror(cond, msg, ap);
1976 * Table of error messages.
1980 short errcode; /* error number */
1981 short action; /* operation which encountered the error */
1985 * Types of operations (passed to the errmsg routine).
1988 #define E_OPEN 01 /* opening a file */
1989 #define E_CREAT 02 /* creating a file */
1990 #define E_EXEC 04 /* executing a program */
1992 #define ALL (E_OPEN|E_CREAT|E_EXEC)
1994 static const struct errname errormsg[] = {
2048 #define ERRNAME_SIZE (sizeof(errormsg)/sizeof(struct errname))
2051 * Return a string describing an error. The returned string may be a
2052 * pointer to a static buffer that will be overwritten on the next call.
2053 * Action describes the operation that got the error.
2056 static const char *errmsg(int e, int action)
2058 struct errname const *ep;
2059 static char buf[12];
2061 for (ep = errormsg; ep < errormsg + ERRNAME_SIZE; ep++) {
2062 if (ep->errcode == e && (ep->action & action) != 0)
2066 snprintf(buf, sizeof buf, "error %d", e);
2071 #ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE
2072 static void __inton()
2074 if (--suppressint == 0 && intpending) {
2078 static void forceinton(void)
2086 /* flags in argument to evaltree */
2087 #define EV_EXIT 01 /* exit after evaluating tree */
2088 #define EV_TESTED 02 /* exit status is checked; ignore -e flag */
2089 #define EV_BACKCMD 04 /* command executing within back quotes */
2091 static int evalskip; /* set if we are skipping commands */
2092 static int skipcount; /* number of levels to skip */
2093 static int loopnest; /* current loop nesting level */
2094 static int funcnest; /* depth of function calls */
2097 static struct strlist *cmdenviron; /* environment for builtin command */
2098 static int exitstatus; /* exit status of last command */
2099 static int oexitstatus; /* saved exit status */
2101 static void evalsubshell(const union node *, int);
2102 static void expredir(union node *);
2103 static void prehash(union node *);
2104 static void eprintlist(struct strlist *);
2106 static union node *parsecmd(int);
2109 * Called to reset things after an exception.
2113 * The eval commmand.
2115 static void evalstring(char *, int);
2117 static int evalcmd(int argc, char **argv)
2126 STARTSTACKSTR(concat);
2130 STPUTC(*p++, concat);
2131 if ((p = *ap++) == NULL)
2133 STPUTC(' ', concat);
2135 STPUTC('\0', concat);
2136 p = grabstackstr(concat);
2138 evalstring(p, EV_TESTED);
2144 * Execute a command or commands contained in a string.
2147 static void evaltree(union node *, int);
2148 static void setinputstring(char *);
2149 static void popfile(void);
2150 static void setstackmark(struct stackmark *mark);
2151 static void popstackmark(struct stackmark *mark);
2154 static void evalstring(char *s, int flag)
2157 struct stackmark smark;
2159 setstackmark(&smark);
2161 while ((n = parsecmd(0)) != NEOF) {
2163 popstackmark(&smark);
2166 popstackmark(&smark);
2169 static struct builtincmd *find_builtin(const char *);
2170 static void expandarg(union node *, struct arglist *, int);
2171 static void calcsize(const union node *);
2172 static union node *copynode(const union node *);
2175 * Make a copy of a parse tree.
2178 static int funcblocksize; /* size of structures in function */
2179 static int funcstringsize; /* size of strings in node */
2180 static pointer funcblock; /* block to allocate function from */
2181 static char *funcstring; /* block to allocate strings from */
2184 static inline union node *copyfunc(union node *n)
2191 funcblock = xmalloc(funcblocksize + funcstringsize);
2192 funcstring = (char *) funcblock + funcblocksize;
2197 * Add a new command entry, replacing any existing command entry for
2201 static inline void addcmdentry(char *name, struct cmdentry *entry)
2203 struct tblentry *cmdp;
2206 cmdp = cmdlookup(name, 1);
2207 if (cmdp->cmdtype == CMDFUNCTION) {
2208 free(cmdp->param.func);
2210 cmdp->cmdtype = entry->cmdtype;
2211 cmdp->param = entry->u;
2215 static inline void evalloop(const union node *n, int flags)
2223 evaltree(n->nbinary.ch1, EV_TESTED);
2225 skipping:if (evalskip == SKIPCONT && --skipcount <= 0) {
2229 if (evalskip == SKIPBREAK && --skipcount <= 0)
2233 if (n->type == NWHILE) {
2234 if (exitstatus != 0)
2237 if (exitstatus == 0)
2240 evaltree(n->nbinary.ch2, flags);
2241 status = exitstatus;
2246 exitstatus = status;
2249 static void evalfor(const union node *n, int flags)
2251 struct arglist arglist;
2254 struct stackmark smark;
2256 setstackmark(&smark);
2257 arglist.lastp = &arglist.list;
2258 for (argp = n->nfor.args; argp; argp = argp->narg.next) {
2259 oexitstatus = exitstatus;
2260 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE | EXP_RECORD);
2264 *arglist.lastp = NULL;
2269 for (sp = arglist.list; sp; sp = sp->next) {
2270 setvar(n->nfor.var, sp->text, 0);
2271 evaltree(n->nfor.body, flags);
2273 if (evalskip == SKIPCONT && --skipcount <= 0) {
2277 if (evalskip == SKIPBREAK && --skipcount <= 0)
2284 popstackmark(&smark);
2287 static inline void evalcase(const union node *n, int flags)
2291 struct arglist arglist;
2292 struct stackmark smark;
2294 setstackmark(&smark);
2295 arglist.lastp = &arglist.list;
2296 oexitstatus = exitstatus;
2297 expandarg(n->ncase.expr, &arglist, EXP_TILDE);
2298 for (cp = n->ncase.cases; cp && evalskip == 0; cp = cp->nclist.next) {
2299 for (patp = cp->nclist.pattern; patp; patp = patp->narg.next) {
2300 if (casematch(patp, arglist.list->text)) {
2301 if (evalskip == 0) {
2302 evaltree(cp->nclist.body, flags);
2309 popstackmark(&smark);
2313 * Evaluate a pipeline. All the processes in the pipeline are children
2314 * of the process creating the pipeline. (This differs from some versions
2315 * of the shell, which make the last process in a pipeline the parent
2319 static inline void evalpipe(union node *n, int flags)
2322 struct nodelist *lp;
2327 TRACE(("evalpipe(0x%lx) called\n", (long) n));
2329 for (lp = n->npipe.cmdlist; lp; lp = lp->next)
2333 jp = makejob(n, pipelen);
2335 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
2339 if (pipe(pip) < 0) {
2341 error("Pipe call failed");
2344 if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) {
2357 evaltree(lp->n, flags);
2364 if (n->npipe.backgnd == 0) {
2365 exitstatus = waitforjob(jp);
2366 TRACE(("evalpipe: job done exit status %d\n", exitstatus));
2371 static void find_command(const char *, struct cmdentry *, int, const char *);
2373 static int isassignment(const char *word)
2375 if (!is_name(*word)) {
2380 } while (is_in_name(*word));
2381 return *word == '=';
2385 static void evalcommand(union node *cmd, int flags)
2387 struct stackmark smark;
2389 struct arglist arglist;
2390 struct arglist varlist;
2396 struct cmdentry cmdentry;
2398 char *volatile savecmdname;
2399 volatile struct shparam saveparam;
2400 struct localvar *volatile savelocalvars;
2405 struct jmploc *volatile savehandler;
2406 struct jmploc jmploc;
2409 /* Avoid longjmp clobbering */
2417 /* First expand the arguments. */
2418 TRACE(("evalcommand(0x%lx, %d) called\n", (long) cmd, flags));
2419 setstackmark(&smark);
2420 arglist.lastp = &arglist.list;
2421 varlist.lastp = &varlist.list;
2423 oexitstatus = exitstatus;
2426 for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
2427 expandarg(argp, &varlist, EXP_VARTILDE);
2429 for (argp = cmd->ncmd.args; argp && !arglist.list; argp = argp->narg.next) {
2430 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
2433 struct builtincmd *bcmd;
2436 bcmd = find_builtin(arglist.list->text);
2437 pseudovarflag = bcmd && IS_BUILTIN_ASSIGN(bcmd);
2438 for (; argp; argp = argp->narg.next) {
2439 if (pseudovarflag && isassignment(argp->narg.text)) {
2440 expandarg(argp, &arglist, EXP_VARTILDE);
2443 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
2446 *arglist.lastp = NULL;
2447 *varlist.lastp = NULL;
2448 expredir(cmd->ncmd.redirect);
2450 for (sp = arglist.list; sp; sp = sp->next)
2452 argv = stalloc(sizeof(char *) * (argc + 1));
2454 for (sp = arglist.list; sp; sp = sp->next) {
2455 TRACE(("evalcommand arg: %s\n", sp->text));
2460 if (iflag && funcnest == 0 && argc > 0)
2464 /* Print the command if xflag is set. */
2467 eprintlist(varlist.list);
2468 eprintlist(arglist.list);
2472 /* Now locate the command. */
2474 cmdentry.cmdtype = CMDBUILTIN;
2475 cmdentry.u.cmd = BLTINCMD;
2478 const char *oldpath;
2479 int findflag = DO_ERR;
2483 * Modify the command lookup path, if a PATH= assignment
2486 for (sp = varlist.list; sp; sp = sp->next)
2487 if (varequal(sp->text, defpathvar)) {
2488 path = sp->text + 5;
2489 findflag |= DO_BRUTE;
2492 oldfindflag = findflag;
2495 find_command(argv[0], &cmdentry, findflag, path);
2496 if (cmdentry.cmdtype == CMDUNKNOWN) { /* command not found */
2500 /* implement bltin and command here */
2501 if (cmdentry.cmdtype != CMDBUILTIN) {
2504 if (spclbltin < 0) {
2505 spclbltin = !!(IS_BUILTIN_SPECIAL(cmdentry.u.cmd)) * 2;
2507 if (cmdentry.u.cmd == BLTINCMD) {
2509 struct builtincmd *bcmd;
2514 if (!(bcmd = find_builtin(*argv))) {
2515 out2fmt("%s: not found\n", *argv);
2519 cmdentry.u.cmd = bcmd;
2520 if (bcmd != BLTINCMD)
2524 if (cmdentry.u.cmd == find_builtin("command")) {
2529 if (*argv[0] == '-') {
2530 if (!equal(argv[0], "-p")) {
2540 findflag |= DO_BRUTE;
2543 findflag = oldfindflag;
2545 findflag |= DO_NOFUN;
2553 /* Fork off a child process if necessary. */
2554 if (cmd->ncmd.backgnd
2555 || (cmdentry.cmdtype == CMDNORMAL && (!(flags & EV_EXIT) || trap[0]))
2558 jp = makejob(cmd, 1);
2559 mode = cmd->ncmd.backgnd;
2560 if (forkshell(jp, cmd, mode) != 0)
2561 goto parent; /* at end of routine */
2568 /* This is the child process if a fork occurred. */
2569 /* Execute the command. */
2570 if (cmdentry.cmdtype == CMDFUNCTION) {
2572 trputs("Shell function: ");
2575 exitstatus = oexitstatus;
2576 saveparam = shellparam;
2577 shellparam.malloc = 0;
2578 shellparam.nparam = argc - 1;
2579 shellparam.p = argv + 1;
2581 savelocalvars = localvars;
2584 if (setjmp(jmploc.loc)) {
2585 if (exception == EXREDIR) {
2589 saveparam.optind = shellparam.optind;
2590 saveparam.optoff = shellparam.optoff;
2591 freeparam(&shellparam);
2592 shellparam = saveparam;
2594 localvars = savelocalvars;
2595 handler = savehandler;
2596 longjmp(handler->loc, 1);
2598 savehandler = handler;
2600 redirect(cmd->ncmd.redirect, REDIR_PUSH);
2601 listsetvar(varlist.list);
2603 evaltree(cmdentry.u.func, flags & EV_TESTED);
2608 localvars = savelocalvars;
2609 saveparam.optind = shellparam.optind;
2610 saveparam.optoff = shellparam.optoff;
2611 freeparam(&shellparam);
2612 shellparam = saveparam;
2613 handler = savehandler;
2616 if (evalskip == SKIPFUNC) {
2620 } else if (cmdentry.cmdtype == CMDBUILTIN) {
2624 trputs("builtin command: ");
2627 redir = (cmdentry.u.cmd == EXECCMD) ? 0 : REDIR_PUSH;
2628 savecmdname = commandname;
2630 listsetvar(varlist.list);
2632 cmdenviron = varlist.list;
2635 if (setjmp(jmploc.loc)) {
2637 exitstatus = (e == EXINT) ? SIGINT + 128 : 2;
2640 savehandler = handler;
2642 redirect(cmd->ncmd.redirect, redir);
2643 commandname = argv[0];
2645 optptr = NULL; /* initialize nextopt */
2646 exitstatus = (*cmdentry.u.cmd->builtinfunc) (argc, argv);
2650 commandname = savecmdname;
2651 handler = savehandler;
2653 if (e == EXINT || spclbltin & 2) {
2659 if (cmdentry.u.cmd != EXECCMD)
2663 trputs("normal command: ");
2666 redirect(cmd->ncmd.redirect, 0);
2668 for (sp = varlist.list; sp; sp = sp->next)
2669 setvareq(sp->text, VEXPORT | VSTACK);
2670 envp = environment();
2671 shellexec(argv, envp, path, cmdentry.u.index);
2673 if (flags & EV_EXIT)
2674 exitshell(exitstatus);
2677 parent: /* parent process gets here (if we forked) */
2678 if (mode == 0) { /* argument to fork */
2679 exitstatus = waitforjob(jp);
2685 setvar("_", lastarg, 0);
2686 popstackmark(&smark);
2690 * Evaluate a parse tree. The value is left in the global variable
2693 static void evaltree(union node *n, int flags)
2698 TRACE(("evaltree(NULL) called\n"));
2701 TRACE(("evaltree(0x%lx: %d) called\n", (long) n, n->type));
2704 evaltree(n->nbinary.ch1, flags & EV_TESTED);
2707 evaltree(n->nbinary.ch2, flags);
2710 evaltree(n->nbinary.ch1, EV_TESTED);
2711 if (evalskip || exitstatus != 0)
2713 evaltree(n->nbinary.ch2, flags);
2716 evaltree(n->nbinary.ch1, EV_TESTED);
2717 if (evalskip || exitstatus == 0)
2719 evaltree(n->nbinary.ch2, flags);
2722 expredir(n->nredir.redirect);
2723 redirect(n->nredir.redirect, REDIR_PUSH);
2724 evaltree(n->nredir.n, flags);
2728 evalsubshell(n, flags);
2731 evalsubshell(n, flags);
2734 evaltree(n->nif.test, EV_TESTED);
2737 if (exitstatus == 0)
2738 evaltree(n->nif.ifpart, flags);
2739 else if (n->nif.elsepart)
2740 evaltree(n->nif.elsepart, flags);
2756 struct builtincmd *bcmd;
2757 struct cmdentry entry;
2759 if ((bcmd = find_builtin(n->narg.text)) && IS_BUILTIN_SPECIAL(bcmd)
2761 out2fmt("%s is a special built-in\n", n->narg.text);
2765 entry.cmdtype = CMDFUNCTION;
2766 entry.u.func = copyfunc(n->narg.next);
2767 addcmdentry(n->narg.text, &entry);
2772 evaltree(n->nnot.com, EV_TESTED);
2773 exitstatus = !exitstatus;
2781 evalcommand(n, flags);
2786 printf("Node type = %d\n", n->type);
2793 if (flags & EV_EXIT ||
2794 (checkexit && eflag && exitstatus && !(flags & EV_TESTED))
2796 exitshell(exitstatus);
2800 * Kick off a subshell to evaluate a tree.
2803 static void evalsubshell(const union node *n, int flags)
2806 int backgnd = (n->type == NBACKGND);
2808 expredir(n->nredir.redirect);
2809 if (!backgnd && flags & EV_EXIT && !trap[0])
2813 if (forkshell(jp, n, backgnd) == 0) {
2817 flags &= ~EV_TESTED;
2819 redirect(n->nredir.redirect, 0);
2820 evaltree(n->nredir.n, flags); /* never returns */
2823 exitstatus = waitforjob(jp);
2829 * Compute the names of the files in a redirection list.
2832 static void fixredir(union node *n, const char *text, int err);
2834 static void expredir(union node *n)
2838 for (redir = n; redir; redir = redir->nfile.next) {
2841 fn.lastp = &fn.list;
2842 oexitstatus = exitstatus;
2843 switch (redir->type) {
2849 expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
2850 redir->nfile.expfname = fn.list->text;
2854 if (redir->ndup.vname) {
2855 expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE);
2856 fixredir(redir, fn.list->text, 1);
2865 * Execute a command inside back quotes. If it's a builtin command, we
2866 * want to save its output in a block obtained from malloc. Otherwise
2867 * we fork off a subprocess and get the output of the command via a pipe.
2868 * Should be called with interrupts off.
2871 static void evalbackcmd(union node *n, struct backcmd *result)
2875 struct stackmark smark; /* unnecessary */
2877 setstackmark(&smark);
2888 error("Pipe call failed");
2890 if (forkshell(jp, n, FORK_NOJOB) == 0) {
2895 dup_as_newfd(pip[1], 1);
2899 evaltree(n, EV_EXIT);
2902 result->fd = pip[0];
2905 popstackmark(&smark);
2906 TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
2907 result->fd, result->buf, result->nleft, result->jp));
2912 * Execute a simple command.
2916 * Search for a command. This is called before we fork so that the
2917 * location of the command will be available in the parent as well as
2918 * the child. The check for "goodname" is an overly conservative
2919 * check that the name will not be subject to expansion.
2922 static void prehash(union node *n)
2924 struct cmdentry entry;
2926 if (n->type == NCMD && n->ncmd.args)
2927 if (goodname(n->ncmd.args->narg.text))
2928 find_command(n->ncmd.args->narg.text, &entry, 0, pathval());
2933 * Builtin commands. Builtin commands whose functions are closely
2934 * tied to evaluation are implemented here.
2938 * No command given, or a bltin command with no arguments. Set the
2939 * specified variables.
2942 int bltincmd(int argc, char **argv)
2945 * Preserve exitstatus of a previous possible redirection
2953 * Handle break and continue commands. Break, continue, and return are
2954 * all handled by setting the evalskip flag. The evaluation routines
2955 * above all check this flag, and if it is set they start skipping
2956 * commands rather than executing them. The variable skipcount is
2957 * the number of loops to break/continue, or the number of function
2958 * levels to return. (The latter is always 1.) It should probably
2959 * be an error to break out of more loops than exist, but it isn't
2960 * in the standard shell so we don't make it one here.
2963 static int breakcmd(int argc, char **argv)
2965 int n = argc > 1 ? number(argv[1]) : 1;
2968 error("Illegal number: %s", argv[1]);
2972 evalskip = (**argv == 'c') ? SKIPCONT : SKIPBREAK;
2980 * The return command.
2983 static int returncmd(int argc, char **argv)
2985 int ret = argc > 1 ? number(argv[1]) : oexitstatus;
2988 evalskip = SKIPFUNC;
2992 /* Do what ksh does; skip the rest of the file */
2993 evalskip = SKIPFILE;
3000 #ifndef CONFIG_FALSE
3001 static int false_main(int argc, char **argv)
3008 static int true_main(int argc, char **argv)
3015 * Controls whether the shell is interactive or not.
3018 static void setsignal(int signo);
3020 #ifdef CONFIG_ASH_MAIL
3021 static void chkmail(int silent);
3024 static void setinteractive(int on)
3026 static int is_interactive;
3027 static int do_banner = 0;
3029 if (on == is_interactive)
3034 #ifdef CONFIG_ASH_MAIL
3037 is_interactive = on;
3038 if (do_banner == 0 && is_interactive) {
3039 /* Looks like they want an interactive shell */
3040 #ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
3041 printf("\n\n" BB_BANNER " Built-in shell (ash)\n");
3042 printf("Enter 'help' for a list of built-in commands.\n\n");
3048 static void optschanged(void)
3050 setinteractive(iflag);
3055 static int execcmd(int argc, char **argv)
3060 iflag = 0; /* exit on error */
3063 for (sp = cmdenviron; sp; sp = sp->next)
3064 setvareq(sp->text, VEXPORT | VSTACK);
3065 shellexec(argv + 1, environment(), pathval(), 0);
3070 static void eprintlist(struct strlist *sp)
3072 for (; sp; sp = sp->next) {
3073 out2fmt(" %s", sp->text);
3078 * Exec a program. Never returns. If you change this routine, you may
3079 * have to change the find_command routine as well.
3082 static const char *pathopt; /* set by padvance */
3084 static void shellexec(char **argv, char **envp, const char *path, int idx)
3089 if (strchr(argv[0], '/') != NULL
3090 #ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
3091 || find_applet_by_name(argv[0])
3095 tryexec(argv[0], argv, envp);
3099 while ((cmdname = padvance(&path, argv[0])) != NULL) {
3100 if (--idx < 0 && pathopt == NULL) {
3101 tryexec(cmdname, argv, envp);
3102 if (errno != ENOENT && errno != ENOTDIR)
3109 /* Map to POSIX errors */
3121 exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC));
3126 * Clear traps on a fork.
3128 static void clear_traps(void)
3132 for (tp = trap; tp < &trap[NSIG]; tp++) {
3133 if (*tp && **tp) { /* trap not NULL or SIG_IGN */
3138 setsignal(tp - trap);
3145 static int preadbuffer(void);
3146 static void pushfile(void);
3149 * Read a character from the script, returning PEOF on end of file.
3150 * Nul characters in the input are silently discarded.
3153 #ifndef CONFIG_ASH_OPTIMIZE_FOR_SIZE
3154 #define pgetc_macro() (--parsenleft >= 0? *parsenextc++ : preadbuffer())
3155 static int pgetc(void)
3157 return pgetc_macro();
3160 static int pgetc_macro(void)
3162 return --parsenleft >= 0 ? *parsenextc++ : preadbuffer();
3165 static inline int pgetc(void)
3167 return pgetc_macro();
3173 * Undo the last call to pgetc. Only one character may be pushed back.
3174 * PEOF may be pushed back.
3177 static void pungetc(void)
3184 static void popfile(void)
3186 struct parsefile *pf = parsefile;
3194 parsefile = pf->prev;
3196 parsenleft = parsefile->nleft;
3197 parselleft = parsefile->lleft;
3198 parsenextc = parsefile->nextc;
3199 plinno = parsefile->linno;
3205 * Return to top level.
3208 static void popallfiles(void)
3210 while (parsefile != &basepf)
3215 * Close the file(s) that the shell is reading commands from. Called
3216 * after a fork is done.
3219 static void closescript(void)
3222 if (parsefile->fd > 0) {
3223 close(parsefile->fd);
3230 * Like setinputfile, but takes an open file descriptor. Call this with
3234 static void setinputfd(int fd, int push)
3236 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
3242 while (parsefile->strpush)
3246 if (parsefile->buf == NULL)
3247 parsefile->buf = xmalloc(BUFSIZ);
3248 parselleft = parsenleft = 0;
3254 * Set the input to take input from a file. If push is set, push the
3255 * old input onto the stack first.
3258 static void setinputfile(const char *fname, int push)
3264 if ((fd = open(fname, O_RDONLY)) < 0)
3265 error("Can't open %s", fname);
3267 myfileno2 = dup_as_newfd(fd, 10);
3270 error("Out of file descriptors");
3273 setinputfd(fd, push);
3278 static void tryexec(char *cmd, char **argv, char **envp)
3282 #ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
3284 char **argv_l = argv;
3287 #ifdef CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN
3288 name = get_last_path_component(name);
3291 for (argc_l = 0; *argv_l != NULL; argv_l++, argc_l++)
3294 for (argc_l = 0; *argv_l != NULL; argv_l++, argc_l++)
3296 run_applet_by_name(name, argc_l, argv);
3299 execve(cmd, argv, envp);
3302 } else if (errno == ENOEXEC) {
3306 for (ap = argv; *ap; ap++);
3307 ap = new = xmalloc((ap - argv + 2) * sizeof(char *));
3308 *ap++ = cmd = "/bin/sh";
3309 while ((*ap++ = *argv++));
3315 static char *commandtext(const union node *);
3318 * Do a path search. The variable path (passed by reference) should be
3319 * set to the start of the path before the first call; padvance will update
3320 * this value as it proceeds. Successive calls to padvance will return
3321 * the possible path expansions in sequence. If an option (indicated by
3322 * a percent sign) appears in the path entry then the global variable
3323 * pathopt will be set to point to it; otherwise pathopt will be set to
3327 static const char *pathopt;
3329 static void growstackblock(void);
3332 static char *padvance(const char **path, const char *name)
3342 for (p = start; *p && *p != ':' && *p != '%'; p++);
3343 len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */
3344 while (stackblocksize() < len)
3348 memcpy(q, start, p - start);
3356 while (*p && *p != ':')
3363 return stalloc(len);
3367 * Wrapper around strcmp for qsort/bsearch/...
3369 static int pstrcmp(const void *a, const void *b)
3371 return strcmp((const char *) a, (*(const char *const *) b) + 1);
3375 * Find a keyword is in a sorted array.
3378 static const char *const *findkwd(const char *s)
3380 return bsearch(s, tokname_array + KWDOFFSET,
3381 (sizeof(tokname_array) / sizeof(const char *)) - KWDOFFSET,
3382 sizeof(const char *), pstrcmp);
3386 /*** Command hashing code ***/
3388 static int hashcmd(int argc, char **argv)
3390 struct tblentry **pp;
3391 struct tblentry *cmdp;
3394 struct cmdentry entry;
3397 #ifdef CONFIG_ASH_ALIAS
3398 const struct alias *ap;
3402 while ((c = nextopt("rvV")) != '\0') {
3406 } else if (c == 'v' || c == 'V') {
3410 if (*argptr == NULL) {
3411 for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
3412 for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
3413 if (cmdp->cmdtype != CMDBUILTIN) {
3414 printentry(cmdp, verbose);
3421 while ((name = *argptr++) != NULL) {
3422 if ((cmdp = cmdlookup(name, 0)) != NULL
3423 && (cmdp->cmdtype == CMDNORMAL
3424 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
3426 #ifdef CONFIG_ASH_ALIAS
3427 /* Then look at the aliases */
3428 if ((ap = *__lookupalias(name)) != NULL) {
3430 printf("%s is an alias for %s\n", name, ap->val);
3436 /* First look at the keywords */
3437 if (findkwd(name) != 0) {
3439 printf("%s is a shell keyword\n", name);
3445 find_command(name, &entry, DO_ERR, pathval());
3446 if (entry.cmdtype == CMDUNKNOWN)
3449 cmdp = cmdlookup(name, 0);
3451 printentry(cmdp, verbose == 'v');
3458 static void printentry(struct tblentry *cmdp, int verbose)
3464 printf("%s%s", cmdp->cmdname, (verbose ? " is " : ""));
3465 if (cmdp->cmdtype == CMDNORMAL) {
3466 idx = cmdp->param.index;
3469 name = padvance(&path, cmdp->cmdname);
3471 } while (--idx >= 0);
3474 } else if (cmdp->cmdtype == CMDBUILTIN) {
3476 out1str("a shell builtin");
3477 } else if (cmdp->cmdtype == CMDFUNCTION) {
3480 out1str("a function\n");
3481 name = commandtext(cmdp->param.func);
3482 printf("%s() {\n %s\n}", cmdp->cmdname, name);
3488 error("internal error: cmdtype %d", cmdp->cmdtype);
3491 puts(cmdp->rehash ? "*" : nullstr);
3496 /*** List the available builtins ***/
3499 static int helpcmd(int argc, char **argv)
3503 printf("\nBuilt-in commands:\n-------------------\n");
3504 for (col = 0, i = 0; i < NUMBUILTINS; i++) {
3505 col += printf("%c%s", ((col == 0) ? '\t' : ' '),
3506 builtincmds[i].name + 1);
3512 #ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
3514 extern const struct BB_applet applets[];
3515 extern const size_t NUM_APPLETS;
3517 for (i = 0; i < NUM_APPLETS; i++) {
3519 col += printf("%c%s", ((col == 0) ? '\t' : ' '), applets[i].name);
3528 return EXIT_SUCCESS;
3532 * Resolve a command name. If you change this routine, you may have to
3533 * change the shellexec routine as well.
3536 static int prefix(const char *, const char *);
3539 find_command(const char *name, struct cmdentry *entry, int act,
3542 struct tblentry *cmdp;
3552 struct builtincmd *bcmd;
3554 /* If name contains a slash, don't use the hash table */
3555 if (strchr(name, '/') != NULL) {
3557 while (stat(name, &statb) < 0) {
3558 if (errno != ENOENT && errno != ENOTDIR)
3560 entry->cmdtype = CMDUNKNOWN;
3561 entry->u.index = -1;
3564 entry->cmdtype = CMDNORMAL;
3565 entry->u.index = -1;
3568 entry->cmdtype = CMDNORMAL;
3573 #ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
3574 if (find_applet_by_name(name)) {
3575 entry->cmdtype = CMDNORMAL;
3576 entry->u.index = -1;
3582 if (act & DO_BRUTE) {
3583 firstchange = path_change(path, &bltin);
3589 /* If name is in the table, and not invalidated by cd, we're done */
3590 if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0) {
3591 if (cmdp->cmdtype == CMDFUNCTION) {
3592 if (act & DO_NOFUN) {
3597 } else if (act & DO_BRUTE) {
3598 if ((cmdp->cmdtype == CMDNORMAL &&
3599 cmdp->param.index >= firstchange) ||
3600 (cmdp->cmdtype == CMDBUILTIN &&
3601 ((builtinloc < 0 && bltin >= 0) ?
3602 bltin : builtinloc) >= firstchange)) {
3603 /* need to recompute the entry */
3612 bcmd = find_builtin(name);
3613 regular = bcmd && IS_BUILTIN_REGULAR(bcmd);
3616 if (cmdp && (cmdp->cmdtype == CMDBUILTIN)) {
3619 } else if (act & DO_BRUTE) {
3620 if (firstchange == 0) {
3625 /* If %builtin not in path, check for builtin next */
3626 if (regular || (bltin < 0 && bcmd)) {
3629 entry->cmdtype = CMDBUILTIN;
3630 entry->u.cmd = bcmd;
3634 cmdp = cmdlookup(name, 1);
3635 cmdp->cmdtype = CMDBUILTIN;
3636 cmdp->param.cmd = bcmd;
3641 /* We have to search path. */
3642 prev = -1; /* where to start */
3643 if (cmdp && cmdp->rehash) { /* doing a rehash */
3644 if (cmdp->cmdtype == CMDBUILTIN)
3647 prev = cmdp->param.index;
3653 while ((fullname = padvance(&path, name)) != NULL) {
3654 stunalloc(fullname);
3656 if (idx >= firstchange) {
3660 if (prefix("builtin", pathopt)) {
3661 if ((bcmd = find_builtin(name))) {
3665 } else if (!(act & DO_NOFUN) && prefix("func", pathopt)) {
3668 continue; /* ignore unimplemented options */
3671 /* if rehash, don't redo absolute path names */
3672 if (fullname[0] == '/' && idx <= prev && idx < firstchange) {
3675 TRACE(("searchexec \"%s\": no change\n", name));
3678 while (stat(fullname, &statb) < 0) {
3679 if (errno != ENOENT && errno != ENOTDIR)
3683 e = EACCES; /* if we fail, this will be the error */
3684 if (!S_ISREG(statb.st_mode))
3686 if (pathopt) { /* this is a %func directory */
3687 stalloc(strlen(fullname) + 1);
3688 readcmdfile(fullname);
3689 if ((cmdp = cmdlookup(name, 0)) == NULL
3690 || cmdp->cmdtype != CMDFUNCTION)
3691 error("%s not defined in %s", name, fullname);
3692 stunalloc(fullname);
3695 TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
3696 /* If we aren't called with DO_BRUTE and cmdp is set, it must
3697 be a function and we're being called with DO_NOFUN */
3699 entry->cmdtype = CMDNORMAL;
3700 entry->u.index = idx;
3704 cmdp = cmdlookup(name, 1);
3705 cmdp->cmdtype = CMDNORMAL;
3706 cmdp->param.index = idx;
3711 /* We failed. If there was an entry for this command, delete it */
3712 if (cmdp && updatetbl)
3715 out2fmt("%s: %s\n", name, errmsg(e, E_EXEC));
3716 entry->cmdtype = CMDUNKNOWN;
3721 entry->cmdtype = cmdp->cmdtype;
3722 entry->u = cmdp->param;
3728 * Search the table of builtin commands.
3731 static struct builtincmd *find_builtin(const char *name)
3733 struct builtincmd *bp;
3735 bp = bsearch(name, builtincmds, NUMBUILTINS, sizeof(struct builtincmd),
3742 * Called when a cd is done. Marks all commands so the next time they
3743 * are executed they will be rehashed.
3746 static void hashcd(void)
3748 struct tblentry **pp;
3749 struct tblentry *cmdp;
3751 for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
3752 for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
3753 if (cmdp->cmdtype == CMDNORMAL
3754 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))
3763 * Called before PATH is changed. The argument is the new value of PATH;
3764 * pathval() still returns the old value at this point. Called with
3768 static void changepath(const char *newval)
3773 firstchange = path_change(newval, &bltin);
3774 if (builtinloc < 0 && bltin >= 0)
3775 builtinloc = bltin; /* zap builtins */
3776 clearcmdentry(firstchange);
3778 /* Ensure that getenv("PATH") stays current */
3779 setenv("PATH", newval, 1);
3784 * Clear out command entries. The argument specifies the first entry in
3785 * PATH which has changed.
3788 static void clearcmdentry(int firstchange)
3790 struct tblentry **tblp;
3791 struct tblentry **pp;
3792 struct tblentry *cmdp;
3795 for (tblp = cmdtable; tblp < &cmdtable[CMDTABLESIZE]; tblp++) {
3797 while ((cmdp = *pp) != NULL) {
3798 if ((cmdp->cmdtype == CMDNORMAL &&
3799 cmdp->param.index >= firstchange)
3800 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= firstchange)) {
3813 * Locate a command in the command hash table. If "add" is nonzero,
3814 * add the command to the table if it is not already present. The
3815 * variable "lastcmdentry" is set to point to the address of the link
3816 * pointing to the entry, so that delete_cmd_entry can delete the
3820 static struct tblentry **lastcmdentry;
3822 static struct tblentry *cmdlookup(const char *name, int add)
3826 struct tblentry *cmdp;
3827 struct tblentry **pp;
3834 pp = &cmdtable[hashval % CMDTABLESIZE];
3835 for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
3836 if (equal(cmdp->cmdname, name))
3840 if (add && cmdp == NULL) {
3842 cmdp = *pp = xmalloc(sizeof(struct tblentry) - ARB
3843 + strlen(name) + 1);
3845 cmdp->cmdtype = CMDUNKNOWN;
3847 strcpy(cmdp->cmdname, name);
3855 * Delete the command entry returned on the last lookup.
3858 static void delete_cmd_entry(void)
3860 struct tblentry *cmdp;
3863 cmdp = *lastcmdentry;
3864 *lastcmdentry = cmdp->next;
3873 static const unsigned char nodesize[26] = {
3874 ALIGN(sizeof(struct nbinary)),
3875 ALIGN(sizeof(struct ncmd)),
3876 ALIGN(sizeof(struct npipe)),
3877 ALIGN(sizeof(struct nredir)),
3878 ALIGN(sizeof(struct nredir)),
3879 ALIGN(sizeof(struct nredir)),
3880 ALIGN(sizeof(struct nbinary)),
3881 ALIGN(sizeof(struct nbinary)),
3882 ALIGN(sizeof(struct nif)),
3883 ALIGN(sizeof(struct nbinary)),
3884 ALIGN(sizeof(struct nbinary)),
3885 ALIGN(sizeof(struct nfor)),
3886 ALIGN(sizeof(struct ncase)),
3887 ALIGN(sizeof(struct nclist)),
3888 ALIGN(sizeof(struct narg)),
3889 ALIGN(sizeof(struct narg)),
3890 ALIGN(sizeof(struct nfile)),
3891 ALIGN(sizeof(struct nfile)),
3892 ALIGN(sizeof(struct nfile)),
3893 ALIGN(sizeof(struct nfile)),
3894 ALIGN(sizeof(struct nfile)),
3895 ALIGN(sizeof(struct ndup)),
3896 ALIGN(sizeof(struct ndup)),
3897 ALIGN(sizeof(struct nhere)),
3898 ALIGN(sizeof(struct nhere)),
3899 ALIGN(sizeof(struct nnot)),
3905 * Delete a function if it exists.
3908 static void unsetfunc(char *name)
3910 struct tblentry *cmdp;
3912 if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->cmdtype == CMDFUNCTION) {
3913 free(cmdp->param.func);
3920 * Locate and print what a word is...
3923 static int typecmd(int argc, char **argv)
3931 for (i = 1; i < argc; i++) {
3932 argv_a[0] = argv[i];
3935 err |= hashcmd(2, argv);
3940 #ifdef CONFIG_ASH_CMDCMD
3941 static int commandcmd(int argc, char **argv)
3944 int default_path = 0;
3945 int verify_only = 0;
3946 int verbose_verify_only = 0;
3948 while ((c = nextopt("pvV")) != '\0')
3957 verbose_verify_only = 1;
3961 if (default_path + verify_only + verbose_verify_only > 1 || !*argptr) {
3962 out2str("command [-p] command [arg ...]\n"
3963 "command {-v|-V} command\n");
3967 if (verify_only || verbose_verify_only) {
3971 argv_a[0] = *argptr;
3973 optptr = verbose_verify_only ? "v" : "V"; /* reverse special */
3974 return hashcmd(argc, argv);
3981 static int path_change(const char *newval, int *bltin)
3983 const char *old, *new;
3989 firstchange = 9999; /* assume no change */
3995 if ((*old == '\0' && *new == ':')
3996 || (*old == ':' && *new == '\0'))
3998 old = new; /* ignore subsequent differences */
4002 if (*new == '%' && *bltin < 0 && prefix("builtin", new + 1))
4009 if (builtinloc >= 0 && *bltin < 0)
4015 * Routines to expand arguments to commands. We have to deal with
4016 * backquotes, shell variables, and file metacharacters.
4021 #define RMESCAPE_ALLOC 0x1 /* Allocate a new string */
4022 #define RMESCAPE_GLOB 0x2 /* Add backslashes for glob */
4025 * Structure specifying which parts of the string should be searched
4026 * for IFS characters.
4030 struct ifsregion *next; /* next region in list */
4031 int begoff; /* offset of start of region */
4032 int endoff; /* offset of end of region */
4033 int nulonly; /* search for nul bytes only */
4037 static char *expdest; /* output of current string */
4038 static struct nodelist *argbackq; /* list of back quote expressions */
4039 static struct ifsregion ifsfirst; /* first struct in list of ifs regions */
4040 static struct ifsregion *ifslastp; /* last struct in list */
4041 static struct arglist exparg; /* holds expanded arg list */
4043 static void argstr(char *, int);
4044 static char *exptilde(char *, int);
4045 static void expbackq(union node *, int, int);
4046 static int subevalvar(char *, char *, int, int, int, int, int);
4047 static int varisset(char *, int);
4048 static void strtodest(const char *, int, int);
4049 static void varvalue(char *, int, int);
4050 static void recordregion(int, int, int);
4051 static void removerecordregions(int);
4052 static void ifsbreakup(char *, struct arglist *);
4053 static void ifsfree(void);
4054 static void expandmeta(struct strlist *, int);
4056 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
4057 #define preglob(p) _rmescapes((p), RMESCAPE_ALLOC | RMESCAPE_GLOB)
4058 #if !defined(GLOB_BROKEN)
4059 static void addglob(const glob_t *);
4062 #if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
4063 static void expmeta(char *, char *);
4065 #if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
4066 static struct strlist *expsort(struct strlist *);
4067 static struct strlist *msort(struct strlist *, int);
4069 static int patmatch(char *, char *, int);
4071 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
4072 static int patmatch2(char *, char *, int);
4074 static int pmatch(char *, char *, int);
4076 #define patmatch2 patmatch
4078 static char *cvtnum(int, char *);
4081 * Expand shell variables and backquotes inside a here document.
4084 /* arg: the document, fd: where to write the expanded version */
4085 static inline void expandhere(union node *arg, int fd)
4088 expandarg(arg, (struct arglist *) NULL, 0);
4089 xwrite(fd, stackblock(), expdest - stackblock());
4094 * Perform variable substitution and command substitution on an argument,
4095 * placing the resulting list of arguments in arglist. If EXP_FULL is true,
4096 * perform splitting and file name expansion. When arglist is NULL, perform
4097 * here document expansion.
4100 static void expandarg(union node *arg, struct arglist *arglist, int flag)
4105 argbackq = arg->narg.backquote;
4106 STARTSTACKSTR(expdest);
4107 ifsfirst.next = NULL;
4109 argstr(arg->narg.text, flag);
4110 if (arglist == NULL) {
4111 return; /* here document expanded */
4113 STPUTC('\0', expdest);
4114 p = grabstackstr(expdest);
4115 exparg.lastp = &exparg.list;
4119 if (flag & EXP_FULL) {
4120 ifsbreakup(p, &exparg);
4121 *exparg.lastp = NULL;
4122 exparg.lastp = &exparg.list;
4123 expandmeta(exparg.list, flag);
4125 if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
4127 sp = (struct strlist *) stalloc(sizeof(struct strlist));
4130 exparg.lastp = &sp->next;
4133 *exparg.lastp = NULL;
4135 *arglist->lastp = exparg.list;
4136 arglist->lastp = exparg.lastp;
4142 * Expand a variable, and return a pointer to the next character in the
4146 static inline char *evalvar(char *p, int flag)
4159 int quotes = flag & (EXP_FULL | EXP_CASE);
4162 subtype = varflags & VSTYPE;
4167 p = strchr(p, '=') + 1;
4168 again: /* jump here after setting a variable with ${var=text} */
4170 set = varisset(var, varflags & VSNUL);
4173 val = lookupvar(var);
4174 if (val == NULL || ((varflags & VSNUL) && val[0] == '\0')) {
4181 startloc = expdest - stackblock();
4182 if (set && subtype != VSPLUS) {
4183 /* insert the value of the variable */
4185 varvalue(var, varflags & VSQUOTE, flag);
4186 if (subtype == VSLENGTH) {
4187 varlen = expdest - stackblock() - startloc;
4188 STADJUST(-varlen, expdest);
4191 if (subtype == VSLENGTH) {
4192 varlen = strlen(val);
4195 varflags & VSQUOTE ? DQSYNTAX : BASESYNTAX, quotes);
4200 if (subtype == VSPLUS)
4203 easy = ((varflags & VSQUOTE) == 0 ||
4204 (*var == '@' && shellparam.nparam != 1));
4209 expdest = cvtnum(varlen, expdest);
4216 recordregion(startloc, expdest - stackblock(), varflags & VSQUOTE);
4232 case VSTRIMRIGHTMAX:
4236 * Terminate the string and start recording the pattern
4239 STPUTC('\0', expdest);
4240 patloc = expdest - stackblock();
4241 if (subevalvar(p, NULL, patloc, subtype,
4242 startloc, varflags, quotes) == 0) {
4243 int amount = (expdest - stackblock() - patloc) + 1;
4245 STADJUST(-amount, expdest);
4247 /* Remove any recorded regions beyond start of variable */
4248 removerecordregions(startloc);
4254 if (subevalvar(p, var, 0, subtype, startloc, varflags, quotes)) {
4257 * Remove any recorded regions beyond
4260 removerecordregions(startloc);
4275 if (subtype != VSNORMAL) { /* skip to end of alternative */
4279 if ((c = *p++) == CTLESC)
4281 else if (c == CTLBACKQ || c == (CTLBACKQ | CTLQUOTE)) {
4283 argbackq = argbackq->next;
4284 } else if (c == CTLVAR) {
4285 if ((*p++ & VSTYPE) != VSNORMAL)
4287 } else if (c == CTLENDVAR) {
4298 * Perform variable and command substitution. If EXP_FULL is set, output CTLESC
4299 * characters to allow for further processing. Otherwise treat
4300 * $@ like $* since no splitting will be performed.
4303 static void argstr(char *p, int flag)
4306 int quotes = flag & (EXP_FULL | EXP_CASE); /* do CTLESC */
4309 if (*p == '~' && (flag & (EXP_TILDE | EXP_VARTILDE)))
4310 p = exptilde(p, flag);
4314 case CTLENDVAR: /* ??? */
4317 /* "$@" syntax adherence hack */
4318 if (p[0] == CTLVAR && p[2] == '@' && p[3] == '=')
4320 if ((flag & EXP_FULL) != 0)
4330 p = evalvar(p, flag);
4333 case CTLBACKQ | CTLQUOTE:
4334 expbackq(argbackq->n, c & CTLQUOTE, flag);
4335 argbackq = argbackq->next;
4337 #ifdef CONFIG_ASH_MATH_SUPPORT
4345 * sort of a hack - expand tildes in variable
4346 * assignments (after the first '=' and after ':'s).
4349 if (flag & EXP_VARTILDE && *p == '~') {
4356 p = exptilde(p, flag);
4365 static char *exptilde(char *p, int flag)
4367 char c, *startp = p;
4370 int quotes = flag & (EXP_FULL | EXP_CASE);
4372 while ((c = *p) != '\0') {
4379 if (flag & EXP_VARTILDE)
4389 if (*(startp + 1) == '\0') {
4390 if ((home = lookupvar("HOME")) == NULL)
4393 if ((pw = getpwnam(startp + 1)) == NULL)
4400 strtodest(home, SQSYNTAX, quotes);
4408 static void removerecordregions(int endoff)
4410 if (ifslastp == NULL)
4413 if (ifsfirst.endoff > endoff) {
4414 while (ifsfirst.next != NULL) {
4415 struct ifsregion *ifsp;
4418 ifsp = ifsfirst.next->next;
4419 free(ifsfirst.next);
4420 ifsfirst.next = ifsp;
4423 if (ifsfirst.begoff > endoff)
4426 ifslastp = &ifsfirst;
4427 ifsfirst.endoff = endoff;
4432 ifslastp = &ifsfirst;
4433 while (ifslastp->next && ifslastp->next->begoff < endoff)
4434 ifslastp = ifslastp->next;
4435 while (ifslastp->next != NULL) {
4436 struct ifsregion *ifsp;
4439 ifsp = ifslastp->next->next;
4440 free(ifslastp->next);
4441 ifslastp->next = ifsp;
4444 if (ifslastp->endoff > endoff)
4445 ifslastp->endoff = endoff;
4449 #ifdef CONFIG_ASH_MATH_SUPPORT
4451 * Expand arithmetic expression. Backup to start of expression,
4452 * evaluate, place result in (backed up) result, adjust string position.
4454 static void expari(int flag)
4460 int quotes = flag & (EXP_FULL | EXP_CASE);
4466 * This routine is slightly over-complicated for
4467 * efficiency. First we make sure there is
4468 * enough space for the result, which may be bigger
4469 * than the expression if we add exponentation. Next we
4470 * scan backwards looking for the start of arithmetic. If the
4471 * next previous character is a CTLESC character, then we
4472 * have to rescan starting from the beginning since CTLESC
4473 * characters have to be processed left to right.
4475 CHECKSTRSPACE(10, expdest);
4476 USTPUTC('\0', expdest);
4477 start = stackblock();
4479 while (*p != CTLARI && p >= start)
4482 error("missing CTLARI (shouldn't happen)");
4483 if (p > start && *(p - 1) == CTLESC)
4484 for (p = start; *p != CTLARI; p++)
4493 removerecordregions(begoff);
4496 result = arith(p + 2, &errcode);
4499 error("divide by zero");
4501 error("syntax error: \"%s\"\n", p + 2);
4503 snprintf(p, 12, "%d", result);
4507 recordregion(begoff, p - 1 - start, 0);
4508 result = expdest - p + 1;
4509 STADJUST(-result, expdest);
4514 * Expand stuff in backwards quotes.
4517 static void expbackq(union node *cmd, int quoted, int flag)
4519 volatile struct backcmd in;
4523 char *dest = expdest;
4524 volatile struct ifsregion saveifs;
4525 struct ifsregion *volatile savelastp;
4526 struct nodelist *volatile saveargbackq;
4528 int startloc = dest - stackblock();
4529 int syntax = quoted ? DQSYNTAX : BASESYNTAX;
4530 volatile int saveherefd;
4531 int quotes = flag & (EXP_FULL | EXP_CASE);
4532 struct jmploc jmploc;
4533 struct jmploc *volatile savehandler;
4537 /* Avoid longjmp clobbering */
4548 savelastp = ifslastp;
4549 saveargbackq = argbackq;
4550 saveherefd = herefd;
4552 if ((ex = setjmp(jmploc.loc))) {
4555 savehandler = handler;
4558 p = grabstackstr(dest);
4559 evalbackcmd(cmd, (struct backcmd *) &in);
4560 ungrabstackstr(p, dest);
4564 ifslastp = savelastp;
4565 argbackq = saveargbackq;
4566 herefd = saveherefd;
4574 if (--in.nleft < 0) {
4577 i = safe_read(in.fd, buf, sizeof buf);
4578 TRACE(("expbackq: read returns %d\n", i));
4585 if (lastc != '\0') {
4586 if (quotes && SIT(lastc, syntax) == CCTL)
4587 STPUTC(CTLESC, dest);
4588 STPUTC(lastc, dest);
4592 /* Eat all trailing newlines */
4593 for (; dest > stackblock() && dest[-1] == '\n';)
4601 exitstatus = waitforjob(in.jp);
4602 handler = savehandler;
4604 longjmp(handler->loc, 1);
4607 recordregion(startloc, dest - stackblock(), 0);
4608 TRACE(("evalbackq: size=%d: \"%.*s\"\n",
4609 (dest - stackblock()) - startloc,
4610 (dest - stackblock()) - startloc, stackblock() + startloc));
4616 subevalvar(char *p, char *str, int strloc, int subtype, int startloc,
4617 int varflags, int quotes)
4623 int saveherefd = herefd;
4624 struct nodelist *saveargbackq = argbackq;
4628 argstr(p, subtype != VSASSIGN && subtype != VSQUESTION ? EXP_CASE : 0);
4629 STACKSTRNUL(expdest);
4630 herefd = saveherefd;
4631 argbackq = saveargbackq;
4632 startp = stackblock() + startloc;
4634 str = stackblock() + strloc;
4638 setvar(str, startp, 0);
4639 amount = startp - expdest;
4640 STADJUST(amount, expdest);
4647 if (*p != CTLENDVAR) {
4648 out2fmt(snlfmt, startp);
4649 error((char *) NULL);
4651 error("%.*s: parameter %snot set", p - str - 1,
4652 str, (varflags & VSNUL) ? "null or " : nullstr);
4656 for (loc = startp; loc < str; loc++) {
4659 if (patmatch2(str, startp, quotes))
4662 if (quotes && *loc == CTLESC)
4668 for (loc = str - 1; loc >= startp;) {
4671 if (patmatch2(str, startp, quotes))
4675 if (quotes && loc > startp && *(loc - 1) == CTLESC) {
4676 for (q = startp; q < loc; q++)
4686 for (loc = str - 1; loc >= startp;) {
4687 if (patmatch2(str, loc, quotes))
4690 if (quotes && loc > startp && *(loc - 1) == CTLESC) {
4691 for (q = startp; q < loc; q++)
4700 case VSTRIMRIGHTMAX:
4701 for (loc = startp; loc < str - 1; loc++) {
4702 if (patmatch2(str, loc, quotes))
4704 if (quotes && *loc == CTLESC)
4717 amount = ((str - 1) - (loc - startp)) - expdest;
4718 STADJUST(amount, expdest);
4719 while (loc != str - 1)
4724 amount = loc - expdest;
4725 STADJUST(amount, expdest);
4726 STPUTC('\0', expdest);
4727 STADJUST(-1, expdest);
4733 * Test whether a specialized variable is set.
4736 static int varisset(char *name, int nulok)
4739 return backgndpid != -1;
4740 else if (*name == '@' || *name == '*') {
4741 if (*shellparam.p == NULL)
4747 for (av = shellparam.p; *av; av++)
4752 } else if (is_digit(*name)) {
4754 int num = atoi(name);
4756 if (num > shellparam.nparam)
4762 ap = shellparam.p[num - 1];
4764 if (nulok && (ap == NULL || *ap == '\0'))
4771 * Put a string on the stack.
4774 static void strtodest(const char *p, int syntax, int quotes)
4777 if (quotes && SIT(*p, syntax) == CCTL)
4778 STPUTC(CTLESC, expdest);
4779 STPUTC(*p++, expdest);
4784 * Add the value of a specialized variable to the stack string.
4787 static void varvalue(char *name, int quoted, int flags)
4796 int allow_split = flags & EXP_FULL;
4797 int quotes = flags & (EXP_FULL | EXP_CASE);
4799 syntax = quoted ? DQSYNTAX : BASESYNTAX;
4808 num = shellparam.nparam;
4813 expdest = cvtnum(num, expdest);
4816 for (i = 0; i < NOPTS; i++) {
4818 STPUTC(optent_letter(optlist[i]), expdest);
4822 if (allow_split && quoted) {
4823 sep = 1 << CHAR_BIT;
4828 sep = ifsset()? ifsval()[0] : ' ';
4830 sepq = SIT(sep, syntax) == CCTL;
4833 for (ap = shellparam.p; (p = *ap++) != NULL;) {
4834 strtodest(p, syntax, quotes);
4837 STPUTC(CTLESC, expdest);
4838 STPUTC(sep, expdest);
4843 strtodest(arg0, syntax, quotes);
4847 if (num > 0 && num <= shellparam.nparam) {
4848 strtodest(shellparam.p[num - 1], syntax, quotes);
4856 * Record the fact that we have to scan this region of the
4857 * string for IFS characters.
4860 static void recordregion(int start, int end, int nulonly)
4862 struct ifsregion *ifsp;
4864 if (ifslastp == NULL) {
4868 ifsp = (struct ifsregion *) xmalloc(sizeof(struct ifsregion));
4870 ifslastp->next = ifsp;
4874 ifslastp->begoff = start;
4875 ifslastp->endoff = end;
4876 ifslastp->nulonly = nulonly;
4882 * Break the argument string into pieces based upon IFS and add the
4883 * strings to the argument list. The regions of the string to be
4884 * searched for IFS characters have been stored by recordregion.
4886 static void ifsbreakup(char *string, struct arglist *arglist)
4888 struct ifsregion *ifsp;
4893 const char *ifs, *realifs;
4901 realifs = ifsset()? ifsval() : defifs;
4902 if (ifslastp != NULL) {
4905 p = string + ifsp->begoff;
4906 nulonly = ifsp->nulonly;
4907 ifs = nulonly ? nullstr : realifs;
4909 while (p < string + ifsp->endoff) {
4913 if (strchr(ifs, *p)) {
4915 ifsspc = (strchr(defifs, *p) != NULL);
4916 /* Ignore IFS whitespace at start */
4917 if (q == start && ifsspc) {
4923 sp = (struct strlist *) stalloc(sizeof *sp);
4925 *arglist->lastp = sp;
4926 arglist->lastp = &sp->next;
4930 if (p >= string + ifsp->endoff) {
4936 if (strchr(ifs, *p) == NULL) {
4939 } else if (strchr(defifs, *p) == NULL) {
4955 } while ((ifsp = ifsp->next) != NULL);
4956 if (!(*start || (!ifsspc && start > string && nulonly))) {
4961 sp = (struct strlist *) stalloc(sizeof *sp);
4963 *arglist->lastp = sp;
4964 arglist->lastp = &sp->next;
4967 static void ifsfree(void)
4969 while (ifsfirst.next != NULL) {
4970 struct ifsregion *ifsp;
4973 ifsp = ifsfirst.next->next;
4974 free(ifsfirst.next);
4975 ifsfirst.next = ifsp;
4979 ifsfirst.next = NULL;
4983 * Add a file name to the list.
4986 static void addfname(const char *name)
4989 size_t len = strlen(name) + 1;
4991 sp = (struct strlist *) stalloc(sizeof *sp);
4992 sp->text = memcpy(stalloc(len), name, len);
4994 exparg.lastp = &sp->next;
4998 * Expand shell metacharacters. At this point, the only control characters
4999 * should be escapes. The results are stored in the list exparg.
5002 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN)
5003 static void expandmeta(struct strlist *str, int flag)
5008 /* TODO - EXP_REDIR */
5013 p = preglob(str->text);
5015 switch (glob(p, 0, 0, &pglob)) {
5017 if (pglob.gl_pathv[1] == 0 && !strcmp(p, pglob.gl_pathv[0]))
5028 *exparg.lastp = str;
5029 rmescapes(str->text);
5030 exparg.lastp = &str->next;
5032 default: /* GLOB_NOSPACE */
5033 error("Out of space");
5041 * Add the result of glob(3) to the list.
5044 static void addglob(const glob_t * pglob)
5046 char **p = pglob->gl_pathv;
5054 #else /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
5055 static char *expdir;
5058 static void expandmeta(struct strlist *str, int flag)
5061 struct strlist **savelastp;
5065 /* TODO - EXP_REDIR */
5071 for (;;) { /* fast check for meta chars */
5072 if ((c = *p++) == '\0')
5074 if (c == '*' || c == '?' || c == '[' || c == '!')
5077 savelastp = exparg.lastp;
5079 if (expdir == NULL) {
5080 int i = strlen(str->text);
5082 expdir = xmalloc(i < 2048 ? 2048 : i); /* XXX */
5085 expmeta(expdir, str->text);
5089 if (exparg.lastp == savelastp) {
5094 *exparg.lastp = str;
5095 rmescapes(str->text);
5096 exparg.lastp = &str->next;
5098 *exparg.lastp = NULL;
5099 *savelastp = sp = expsort(*savelastp);
5100 while (sp->next != NULL)
5102 exparg.lastp = &sp->next;
5110 * Do metacharacter (i.e. *, ?, [...]) expansion.
5113 static void expmeta(char *enddir, char *name)
5129 for (p = name;; p++) {
5130 if (*p == '*' || *p == '?')
5132 else if (*p == '[') {
5137 while (*q == CTLQUOTEMARK)
5141 if (*q == '/' || *q == '\0')
5148 } else if (*p == '!' && p[1] == '!' && (p == name || p[-1] == '/')) {
5150 } else if (*p == '\0')
5152 else if (*p == CTLQUOTEMARK)
5154 else if (*p == CTLESC)
5162 if (metaflag == 0) { /* we've reached the end of the file name */
5163 if (enddir != expdir)
5165 for (p = name;; p++) {
5166 if (*p == CTLQUOTEMARK)
5174 if (metaflag == 0 || lstat(expdir, &statb) >= 0)
5179 if (start != name) {
5182 while (*p == CTLQUOTEMARK)
5189 if (enddir == expdir) {
5191 } else if (enddir == expdir + 1 && *expdir == '/') {
5197 if ((dirp = opendir(cp)) == NULL)
5199 if (enddir != expdir)
5201 if (*endname == 0) {
5209 while (*p == CTLQUOTEMARK)
5215 while (!int_pending() && (dp = readdir(dirp)) != NULL) {
5216 if (dp->d_name[0] == '.' && !matchdot)
5218 if (patmatch(start, dp->d_name, 0)) {
5220 strcpy(enddir, dp->d_name);
5223 for (p = enddir, cp = dp->d_name; (*p++ = *cp++) != '\0';)
5226 expmeta(p, endname);
5234 #endif /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
5238 #if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
5240 * Sort the results of file name expansion. It calculates the number of
5241 * strings to sort and then calls msort (short for merge sort) to do the
5245 static struct strlist *expsort(struct strlist *str)
5251 for (sp = str; sp; sp = sp->next)
5253 return msort(str, len);
5257 static struct strlist *msort(struct strlist *list, int len)
5259 struct strlist *p, *q = NULL;
5260 struct strlist **lpp;
5268 for (n = half; --n >= 0;) {
5272 q->next = NULL; /* terminate first half of list */
5273 q = msort(list, half); /* sort first half of list */
5274 p = msort(p, len - half); /* sort second half */
5277 if (strcmp(p->text, q->text) < 0) {
5280 if ((p = *lpp) == NULL) {
5287 if ((q = *lpp) == NULL) {
5300 * Returns true if the pattern matches the string.
5303 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
5304 /* squoted: string might have quote chars */
5305 static int patmatch(char *pattern, char *string, int squoted)
5310 p = preglob(pattern);
5311 q = squoted ? _rmescapes(string, RMESCAPE_ALLOC) : string;
5313 return !fnmatch(p, q, 0);
5317 static int patmatch2(char *pattern, char *string, int squoted)
5323 p = grabstackstr(expdest);
5324 res = patmatch(pattern, string, squoted);
5325 ungrabstackstr(p, expdest);
5329 static int patmatch(char *pattern, char *string, int squoted)
5331 return pmatch(pattern, string, squoted);
5335 static int pmatch(char *pattern, char *string, int squoted)
5347 if (squoted && *q == CTLESC)
5355 if (squoted && *q == CTLESC)
5362 while (c == CTLQUOTEMARK || c == '*')
5364 if (c != CTLESC && c != CTLQUOTEMARK &&
5365 c != '?' && c != '*' && c != '[') {
5367 if (squoted && *q == CTLESC && q[1] == c)
5371 if (squoted && *q == CTLESC)
5377 if (pmatch(p, q, squoted))
5379 if (squoted && *q == CTLESC)
5381 } while (*q++ != '\0');
5392 while (*endp == CTLQUOTEMARK)
5395 goto dft; /* no matching ] */
5396 if (*endp == CTLESC)
5408 if (squoted && chr == CTLESC)
5414 if (c == CTLQUOTEMARK)
5418 if (*p == '-' && p[1] != ']') {
5420 while (*p == CTLQUOTEMARK)
5424 if (chr >= c && chr <= *p)
5431 } while ((c = *p++) != ']');
5432 if (found == invert)
5437 if (squoted && *q == CTLESC)
5454 * Remove any CTLESC characters from a string.
5457 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
5458 static char *_rmescapes(char *str, int flag)
5461 static const char qchars[] = { CTLESC, CTLQUOTEMARK, 0 };
5463 p = strpbrk(str, qchars);
5469 if (flag & RMESCAPE_ALLOC) {
5470 size_t len = p - str;
5472 q = r = stalloc(strlen(p) + len + 1);
5474 memcpy(q, str, len);
5479 if (*p == CTLQUOTEMARK) {
5485 if (flag & RMESCAPE_GLOB && *p != '/') {
5495 static void rmescapes(char *str)
5500 while (*p != CTLESC && *p != CTLQUOTEMARK) {
5506 if (*p == CTLQUOTEMARK) {
5521 * See if a pattern matches in a case statement.
5524 static int casematch(union node *pattern, const char *val)
5526 struct stackmark smark;
5530 setstackmark(&smark);
5531 argbackq = pattern->narg.backquote;
5532 STARTSTACKSTR(expdest);
5534 argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
5535 STPUTC('\0', expdest);
5536 p = grabstackstr(expdest);
5537 result = patmatch(p, (char *) val, 0);
5538 popstackmark(&smark);
5546 static char *cvtnum(int num, char *buf)
5550 CHECKSTRSPACE(32, buf);
5551 len = sprintf(buf, "%d", num);
5557 * Editline and history functions (and glue).
5559 static int histcmd(int argc, char **argv)
5561 error("not compiled with history support");
5567 struct redirtab *next;
5568 short renamed[10]; /* Current ash support only 0-9 descriptors */
5569 /* char on arm (and others) can't be negative */
5572 static struct redirtab *redirlist;
5574 extern char **environ;
5579 * Initialization code.
5582 static void init(void)
5593 basepf.nextc = basepf.buf = basebuf;
5602 for (envp = environ; *envp; envp++) {
5603 if (strchr(*envp, '=')) {
5604 setvareq(*envp, VEXPORT | VTEXTFIXED);
5608 snprintf(ppid, sizeof(ppid), "%d", (int) getppid());
5609 setvar("PPID", ppid, 0);
5616 * This routine is called when an error or an interrupt occurs in an
5617 * interactive shell and control is returned to the main command loop.
5620 /* 1 == check for aliases, 2 == also check for assignments */
5621 static int checkalias; /* also used in no alias mode for check assignments */
5623 static void reset(void)
5635 parselleft = parsenleft = 0; /* clear input buffer */
5639 /* from parser.c: */
5657 * This file implements the input routines used by the parser.
5660 #ifdef CONFIG_FEATURE_COMMAND_EDITING
5661 static const char *cmdedit_prompt;
5662 static inline void putprompt(const char *s)
5667 static inline void putprompt(const char *s)
5673 #define EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */
5678 * Same as pgetc(), but ignores PEOA.
5681 #ifdef CONFIG_ASH_ALIAS
5682 static int pgetc2(void)
5688 } while (c == PEOA);
5692 static inline int pgetc2(void)
5694 return pgetc_macro();
5699 * Read a line from the script.
5702 static inline char *pfgets(char *line, int len)
5708 while (--nleft > 0) {
5723 static inline int preadfd(void)
5726 char *buf = parsefile->buf;
5731 #ifdef CONFIG_FEATURE_COMMAND_EDITING
5733 if (!iflag || parsefile->fd)
5734 nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
5736 nr = cmdedit_read_input((char *) cmdedit_prompt, buf);
5740 nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
5744 if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
5745 int flags = fcntl(0, F_GETFL, 0);
5747 if (flags >= 0 && flags & O_NONBLOCK) {
5748 flags &= ~O_NONBLOCK;
5749 if (fcntl(0, F_SETFL, flags) >= 0) {
5750 out2str("sh: turning off NDELAY mode\n");
5759 static void popstring(void)
5761 struct strpush *sp = parsefile->strpush;
5764 #ifdef CONFIG_ASH_ALIAS
5766 if (parsenextc[-1] == ' ' || parsenextc[-1] == '\t') {
5771 if (sp->string != sp->ap->val) {
5775 sp->ap->flag &= ~ALIASINUSE;
5776 if (sp->ap->flag & ALIASDEAD) {
5777 unalias(sp->ap->name);
5781 parsenextc = sp->prevstring;
5782 parsenleft = sp->prevnleft;
5783 /*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
5784 parsefile->strpush = sp->prev;
5785 if (sp != &(parsefile->basestrpush))
5792 * Refill the input buffer and return the next input character:
5794 * 1) If a string was pushed back on the input, pop it;
5795 * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
5796 * from a string so we can't refill the buffer, return EOF.
5797 * 3) If the is more stuff in this buffer, use it else call read to fill it.
5798 * 4) Process input up to the next newline, deleting nul characters.
5801 static int preadbuffer(void)
5807 while (parsefile->strpush) {
5808 #ifdef CONFIG_ASH_ALIAS
5809 if (parsenleft == -1 && parsefile->strpush->ap &&
5810 parsenextc[-1] != ' ' && parsenextc[-1] != '\t') {
5815 if (--parsenleft >= 0)
5816 return (*parsenextc++);
5818 if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
5823 if (parselleft <= 0) {
5824 if ((parselleft = preadfd()) <= 0) {
5825 parselleft = parsenleft = EOF_NLEFT;
5832 /* delete nul characters */
5833 for (more = 1; more;) {
5841 parsenleft = q - parsenextc;
5842 more = 0; /* Stop processing here */
5848 if (--parselleft <= 0 && more) {
5849 parsenleft = q - parsenextc - 1;
5860 out2str(parsenextc);
5865 return *parsenextc++;
5870 * Push a string back onto the input at this current parsefile level.
5871 * We handle aliases this way.
5873 static void pushstring(char *s, int len, void *ap)
5878 /*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
5879 if (parsefile->strpush) {
5880 sp = xmalloc(sizeof(struct strpush));
5881 sp->prev = parsefile->strpush;
5882 parsefile->strpush = sp;
5884 sp = parsefile->strpush = &(parsefile->basestrpush);
5885 sp->prevstring = parsenextc;
5886 sp->prevnleft = parsenleft;
5887 #ifdef CONFIG_ASH_ALIAS
5888 sp->ap = (struct alias *) ap;
5890 ((struct alias *) ap)->flag |= ALIASINUSE;
5901 * Like setinputfile, but takes input from a string.
5904 static void setinputstring(char *string)
5908 parsenextc = string;
5909 parsenleft = strlen(string);
5910 parsefile->buf = NULL;
5918 * To handle the "." command, a stack of input files is used. Pushfile
5919 * adds a new entry to the stack and popfile restores the previous level.
5922 static void pushfile(void)
5924 struct parsefile *pf;
5926 parsefile->nleft = parsenleft;
5927 parsefile->lleft = parselleft;
5928 parsefile->nextc = parsenextc;
5929 parsefile->linno = plinno;
5930 pf = (struct parsefile *) xmalloc(sizeof(struct parsefile));
5931 pf->prev = parsefile;
5934 pf->basestrpush.prev = NULL;
5938 #ifdef CONFIG_ASH_JOB_CONTROL
5939 static void restartjob(struct job *);
5941 static void freejob(struct job *);
5942 static struct job *getjob(const char *);
5943 static int dowait(int, struct job *);
5947 * We keep track of whether or not fd0 has been redirected. This is for
5948 * background commands, where we want to redirect fd0 to /dev/null only
5949 * if it hasn't already been redirected.
5951 static int fd0_redirected = 0;
5953 /* Return true if fd 0 has already been redirected at least once. */
5954 static inline int fd0_redirected_p(void)
5956 return fd0_redirected != 0;
5959 static void dupredirect(const union node *, int, int fd1dup);
5961 #ifdef CONFIG_ASH_JOB_CONTROL
5963 * Turn job control on and off.
5965 * Note: This code assumes that the third arg to ioctl is a character
5966 * pointer, which is true on Berkeley systems but not System V. Since
5967 * System V doesn't have job control yet, this isn't a problem now.
5972 static void setjobctl(int enable)
5974 if (enable == jobctl || rootshell == 0)
5977 do { /* while we are in the background */
5978 initialpgrp = tcgetpgrp(2);
5979 if (initialpgrp < 0) {
5980 out2str("sh: can't access tty; job control turned off\n");
5984 if (initialpgrp == -1)
5985 initialpgrp = getpgrp();
5986 else if (initialpgrp != getpgrp()) {
5987 killpg(initialpgrp, SIGTTIN);
5994 setpgid(0, rootpid);
5995 tcsetpgrp(2, rootpid);
5996 } else { /* turning job control off */
5997 setpgid(0, initialpgrp);
5998 tcsetpgrp(2, initialpgrp);
6008 #ifdef CONFIG_ASH_JOB_CONTROL
6009 static int killcmd(int argc, char **argv)
6020 ("Usage: kill [-s sigspec | -signum | -sigspec] [pid | job]... or\n"
6021 "kill -l [exitstatus]");
6024 if (*argv[1] == '-') {
6025 signo = decode_signal(argv[1] + 1, 1);
6029 while ((c = nextopt("ls:")) != '\0')
6035 signo = decode_signal(optionarg, 1);
6037 error("invalid signal number or name: %s", optionarg);
6042 error("nextopt returned character code 0%o", c);
6049 if (!list && signo < 0)
6052 if ((signo < 0 || !*argptr) ^ list) {
6061 for (i = 1; i < NSIG; i++) {
6062 name = u_signal_names(0, &i, 1);
6068 name = u_signal_names(*argptr, &signo, -1);
6072 error("invalid signal number or exit status: %s", *argptr);
6077 if (**argptr == '%') {
6078 jp = getjob(*argptr);
6079 if (jp->jobctl == 0)
6080 error("job %s not created under job control", *argptr);
6081 pid = -jp->ps[0].pid;
6083 pid = atoi(*argptr);
6084 if (kill(pid, signo) != 0)
6085 error("%s: %m", *argptr);
6086 } while (*++argptr);
6091 static int fgcmd(int argc, char **argv)
6097 jp = getjob(argv[1]);
6098 if (jp->jobctl == 0)
6099 error("job not created under job control");
6100 pgrp = jp->ps[0].pid;
6101 ioctl(2, TIOCSPGRP, (char *) &pgrp);
6103 status = waitforjob(jp);
6108 static int bgcmd(int argc, char **argv)
6113 jp = getjob(*++argv);
6114 if (jp->jobctl == 0)
6115 error("job not created under job control");
6117 } while (--argc > 1);
6122 static void restartjob(struct job *jp)
6124 struct procstat *ps;
6127 if (jp->state == JOBDONE)
6130 killpg(jp->ps[0].pid, SIGCONT);
6131 for (ps = jp->ps, i = jp->nprocs; --i >= 0; ps++) {
6132 if (WIFSTOPPED(ps->status)) {
6141 static void showjobs(int change);
6144 static int jobscmd(int argc, char **argv)
6152 * Print a list of jobs. If "change" is nonzero, only print jobs whose
6153 * statuses have changed since the last call to showjobs.
6155 * If the shell is interrupted in the process of creating a job, the
6156 * result may be a job structure containing zero processes. Such structures
6157 * will be freed here.
6160 static void showjobs(int change)
6166 struct procstat *ps;
6170 TRACE(("showjobs(%d) called\n", change));
6171 while (dowait(0, (struct job *) NULL) > 0);
6172 for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
6175 if (jp->nprocs == 0) {
6179 if (change && !jp->changed)
6181 procno = jp->nprocs;
6182 for (ps = jp->ps;; ps++) { /* for each process */
6184 snprintf(s, 64, "[%d] %ld ", jobno, (long) ps->pid);
6186 snprintf(s, 64, " %ld ", (long) ps->pid);
6190 if (ps->status == -1) {
6191 /* don't print anything */
6192 } else if (WIFEXITED(ps->status)) {
6193 snprintf(s, 64, "Exit %d", WEXITSTATUS(ps->status));
6195 #ifdef CONFIG_ASH_JOB_CONTROL
6196 if (WIFSTOPPED(ps->status))
6197 i = WSTOPSIG(ps->status);
6198 else /* WIFSIGNALED(ps->status) */
6200 i = WTERMSIG(ps->status);
6201 if ((i & 0x7F) < NSIG && sys_siglist[i & 0x7F])
6202 strcpy(s, sys_siglist[i & 0x7F]);
6204 snprintf(s, 64, "Signal %d", i & 0x7F);
6205 if (WCOREDUMP(ps->status))
6206 strcat(s, " (core dumped)");
6210 printf("%*c%s\n", 30 - col >= 0 ? 30 - col : 0, ' ', ps->cmd);
6215 if (jp->state == JOBDONE) {
6223 * Mark a job structure as unused.
6226 static void freejob(struct job *jp)
6228 const struct procstat *ps;
6232 for (i = jp->nprocs, ps = jp->ps; --i >= 0; ps++) {
6233 if (ps->cmd != nullstr)
6236 if (jp->ps != &jp->ps0)
6239 #ifdef CONFIG_ASH_JOB_CONTROL
6240 if (curjob == jp - jobtab + 1)
6248 static int waitcmd(int argc, char **argv)
6256 job = getjob(*++argv);
6260 for (;;) { /* loop until process terminated or stopped */
6263 status = job->ps[job->nprocs - 1].status;
6269 if (WIFEXITED(status))
6270 retval = WEXITSTATUS(status);
6271 #ifdef CONFIG_ASH_JOB_CONTROL
6272 else if (WIFSTOPPED(status))
6273 retval = WSTOPSIG(status) + 128;
6276 /* XXX: limits number of signals */
6277 retval = WTERMSIG(status) + 128;
6282 for (jp = jobtab;; jp++) {
6283 if (jp >= jobtab + njobs) { /* no running procs */
6286 if (jp->used && jp->state == 0)
6290 if (dowait(2, 0) < 0 && errno == EINTR) {
6299 * Convert a job name to a job structure.
6302 static struct job *getjob(const char *name)
6310 #ifdef CONFIG_ASH_JOB_CONTROL
6312 if ((jobno = curjob) == 0 || jobtab[jobno - 1].used == 0)
6313 error("No current job");
6314 return &jobtab[jobno - 1];
6316 error("No current job");
6318 } else if (name[0] == '%') {
6319 if (is_digit(name[1])) {
6320 jobno = number(name + 1);
6321 if (jobno > 0 && jobno <= njobs && jobtab[jobno - 1].used != 0)
6322 return &jobtab[jobno - 1];
6323 #ifdef CONFIG_ASH_JOB_CONTROL
6324 } else if (name[1] == '%' && name[2] == '\0') {
6328 struct job *found = NULL;
6330 for (jp = jobtab, i = njobs; --i >= 0; jp++) {
6331 if (jp->used && jp->nprocs > 0
6332 && prefix(name + 1, jp->ps[0].cmd)) {
6334 error("%s: ambiguous", name);
6341 } else if (is_number(name, &pid)) {
6342 for (jp = jobtab, i = njobs; --i >= 0; jp++) {
6343 if (jp->used && jp->nprocs > 0
6344 && jp->ps[jp->nprocs - 1].pid == pid)
6348 error("No such job: %s", name);
6355 * Return a new job structure,
6358 static struct job *makejob(const union node *node, int nprocs)
6363 for (i = njobs, jp = jobtab;; jp++) {
6367 jobtab = xmalloc(4 * sizeof jobtab[0]);
6369 jp = xmalloc((njobs + 4) * sizeof jobtab[0]);
6370 memcpy(jp, jobtab, njobs * sizeof jp[0]);
6371 /* Relocate `ps' pointers */
6372 for (i = 0; i < njobs; i++)
6373 if (jp[i].ps == &jobtab[i].ps0)
6374 jp[i].ps = &jp[i].ps0;
6378 jp = jobtab + njobs;
6379 for (i = 4; --i >= 0; jobtab[njobs++].used = 0);
6391 #ifdef CONFIG_ASH_JOB_CONTROL
6392 jp->jobctl = jobctl;
6395 jp->ps = xmalloc(nprocs * sizeof(struct procstat));
6400 TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long) node, nprocs,
6407 * Fork of a subshell. If we are doing job control, give the subshell its
6408 * own process group. Jp is a job structure that the job is to be added to.
6409 * N is the command that will be evaluated by the child. Both jp and n may
6410 * be NULL. The mode parameter can be one of the following:
6411 * FORK_FG - Fork off a foreground process.
6412 * FORK_BG - Fork off a background process.
6413 * FORK_NOJOB - Like FORK_FG, but don't give the process its own
6414 * process group even if job control is on.
6416 * When job control is turned off, background processes have their standard
6417 * input redirected to /dev/null (except for the second and later processes
6423 static int forkshell(struct job *jp, const union node *n, int mode)
6427 #ifdef CONFIG_ASH_JOB_CONTROL
6430 const char *devnull = _PATH_DEVNULL;
6431 const char *nullerr = "Can't open %s";
6433 TRACE(("forkshell(%%%d, 0x%lx, %d) called\n", jp - jobtab, (long) n,
6438 TRACE(("Fork failed, errno=%d\n", errno));
6440 error("Cannot fork");
6447 TRACE(("Child shell %d\n", getpid()));
6448 wasroot = rootshell;
6453 #ifdef CONFIG_ASH_JOB_CONTROL
6454 jobctl = 0; /* do job control only in root shell */
6455 if (wasroot && mode != FORK_NOJOB && mflag) {
6456 if (jp == NULL || jp->nprocs == 0)
6459 pgrp = jp->ps[0].pid;
6461 if (mode == FORK_FG) {
6462 /*** this causes superfluous TIOCSPGRPS ***/
6463 if (tcsetpgrp(2, pgrp) < 0)
6464 error("tcsetpgrp failed, errno=%d", errno);
6468 } else if (mode == FORK_BG) {
6470 if (mode == FORK_BG) {
6474 if ((jp == NULL || jp->nprocs == 0) && !fd0_redirected_p()) {
6476 if (open(devnull, O_RDONLY) != 0)
6477 error(nullerr, devnull);
6480 for (i = njobs, p = jobtab; --i >= 0; p++)
6483 if (wasroot && iflag) {
6490 #ifdef CONFIG_ASH_JOB_CONTROL
6491 if (rootshell && mode != FORK_NOJOB && mflag) {
6492 if (jp == NULL || jp->nprocs == 0)
6495 pgrp = jp->ps[0].pid;
6499 if (mode == FORK_BG)
6500 backgndpid = pid; /* set $! */
6502 struct procstat *ps = &jp->ps[jp->nprocs++];
6507 if (iflag && rootshell && n)
6508 ps->cmd = commandtext(n);
6511 TRACE(("In parent shell: child = %d\n", pid));
6518 * Wait for job to finish.
6520 * Under job control we have the problem that while a child process is
6521 * running interrupts generated by the user are sent to the child but not
6522 * to the shell. This means that an infinite loop started by an inter-
6523 * active user may be hard to kill. With job control turned off, an
6524 * interactive user may place an interactive program inside a loop. If
6525 * the interactive program catches interrupts, the user doesn't want
6526 * these interrupts to also abort the loop. The approach we take here
6527 * is to have the shell ignore interrupt signals while waiting for a
6528 * forground process to terminate, and then send itself an interrupt
6529 * signal if the child process was terminated by an interrupt signal.
6530 * Unfortunately, some programs want to do a bit of cleanup and then
6531 * exit on interrupt; unless these processes terminate themselves by
6532 * sending a signal to themselves (instead of calling exit) they will
6533 * confuse this approach.
6536 static int waitforjob(struct job *jp)
6538 #ifdef CONFIG_ASH_JOB_CONTROL
6539 int mypgrp = getpgrp();
6545 TRACE(("waitforjob(%%%d) called\n", jp - jobtab + 1));
6546 while (jp->state == 0) {
6549 #ifdef CONFIG_ASH_JOB_CONTROL
6551 if (tcsetpgrp(2, mypgrp) < 0)
6552 error("tcsetpgrp failed, errno=%d\n", errno);
6554 if (jp->state == JOBSTOPPED)
6555 curjob = jp - jobtab + 1;
6557 status = jp->ps[jp->nprocs - 1].status;
6558 /* convert to 8 bits */
6559 if (WIFEXITED(status))
6560 st = WEXITSTATUS(status);
6561 #ifdef CONFIG_ASH_JOB_CONTROL
6562 else if (WIFSTOPPED(status))
6563 st = WSTOPSIG(status) + 128;
6566 st = WTERMSIG(status) + 128;
6567 #ifdef CONFIG_ASH_JOB_CONTROL
6570 * This is truly gross.
6571 * If we're doing job control, then we did a TIOCSPGRP which
6572 * caused us (the shell) to no longer be in the controlling
6573 * session -- so we wouldn't have seen any ^C/SIGINT. So, we
6574 * intuit from the subprocess exit status whether a SIGINT
6575 * occured, and if so interrupt ourselves. Yuck. - mycroft
6577 if (WIFSIGNALED(status) && WTERMSIG(status) == SIGINT)
6580 if (jp->state == JOBDONE)
6590 * Wait for a process to terminate.
6594 * Do a wait system call. If job control is compiled in, we accept
6595 * stopped processes. If block is zero, we return a value of zero
6596 * rather than blocking.
6598 * System V doesn't have a non-blocking wait system call. It does
6599 * have a SIGCLD signal that is sent to a process when one of it's
6600 * children dies. The obvious way to use SIGCLD would be to install
6601 * a handler for SIGCLD which simply bumped a counter when a SIGCLD
6602 * was received, and have waitproc bump another counter when it got
6603 * the status of a process. Waitproc would then know that a wait
6604 * system call would not block if the two counters were different.
6605 * This approach doesn't work because if a process has children that
6606 * have not been waited for, System V will send it a SIGCLD when it
6607 * installs a signal handler for SIGCLD. What this means is that when
6608 * a child exits, the shell will be sent SIGCLD signals continuously
6609 * until is runs out of stack space, unless it does a wait call before
6610 * restoring the signal handler. The code below takes advantage of
6611 * this (mis)feature by installing a signal handler for SIGCLD and
6612 * then checking to see whether it was called. If there are any
6613 * children to be waited for, it will be.
6617 static inline int waitproc(int block, int *status)
6622 #ifdef CONFIG_ASH_JOB_CONTROL
6628 return wait3(status, flags, (struct rusage *) NULL);
6631 static int dowait(int block, struct job *job)
6635 struct procstat *sp;
6637 struct job *thisjob;
6643 TRACE(("dowait(%d) called\n", block));
6645 pid = waitproc(block, &status);
6646 TRACE(("wait returns %d, status=%d\n", pid, status));
6647 } while (!(block & 2) && pid == -1 && errno == EINTR);
6652 for (jp = jobtab; jp < jobtab + njobs; jp++) {
6656 for (sp = jp->ps; sp < jp->ps + jp->nprocs; sp++) {
6659 if (sp->pid == pid) {
6660 TRACE(("Changing status of proc %d from 0x%x to 0x%x\n",
6661 pid, sp->status, status));
6662 sp->status = status;
6665 if (sp->status == -1)
6667 else if (WIFSTOPPED(sp->status))
6670 if (stopped) { /* stopped or done */
6671 int state = done ? JOBDONE : JOBSTOPPED;
6673 if (jp->state != state) {
6674 TRACE(("Job %d: changing state from %d to %d\n",
6675 jp - jobtab + 1, jp->state, state));
6677 #ifdef CONFIG_ASH_JOB_CONTROL
6678 if (done && curjob == jp - jobtab + 1)
6679 curjob = 0; /* no current job */
6686 if (!rootshell || !iflag || (job && thisjob == job)) {
6687 core = WCOREDUMP(status);
6688 #ifdef CONFIG_ASH_JOB_CONTROL
6689 if (WIFSTOPPED(status))
6690 sig = WSTOPSIG(status);
6693 if (WIFEXITED(status))
6696 sig = WTERMSIG(status);
6698 if (sig != 0 && sig != SIGINT && sig != SIGPIPE) {
6700 out2fmt("%d: ", pid);
6701 #ifdef CONFIG_ASH_JOB_CONTROL
6702 if (sig == SIGTSTP && rootshell && iflag)
6703 out2fmt("%%%ld ", (long) (job - jobtab + 1));
6705 if (sig < NSIG && sys_siglist[sig])
6706 out2str(sys_siglist[sig]);
6708 out2fmt("Signal %d", sig);
6710 out2str(" - core dumped");
6713 TRACE(("Not printing status: status=%d, sig=%d\n", status, sig));
6716 TRACE(("Not printing status, rootshell=%d, job=0x%x\n", rootshell,
6719 thisjob->changed = 1;
6728 * return 1 if there are stopped jobs, otherwise 0
6730 static int stoppedjobs(void)
6737 for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
6740 if (jp->state == JOBSTOPPED) {
6741 out2str("You have stopped jobs.\n");
6751 * Return a string identifying a command (to be printed by the
6755 static char *cmdnextc;
6756 static int cmdnleft;
6758 #define MAXCMDTEXT 200
6760 static void cmdputs(const char *s)
6771 while ((c = *p++) != '\0') {
6774 else if (c == CTLVAR) {
6779 } else if (c == '=' && subtype != 0) {
6780 *q++ = "}-+?="[(subtype & VSTYPE) - VSNORMAL];
6782 } else if (c == CTLENDVAR) {
6784 } else if (c == CTLBACKQ || c == CTLBACKQ + CTLQUOTE)
6785 cmdnleft++; /* ignore it */
6788 if (--cmdnleft <= 0) {
6798 #define CMDTXT_TABLE
6801 * To collect a lot of redundant code in cmdtxt() case statements, we
6802 * implement a mini language here. Each type of node struct has an
6803 * associated instruction sequence that operates on its members via
6804 * their offsets. The instruction are pack in unsigned chars with
6805 * format IIDDDDDE where the bits are
6806 * I : part of the instruction opcode, which are
6807 * 00 : member is a pointer to another node -- process it recursively
6808 * 40 : member is a pointer to a char string -- output it
6809 * 80 : output the string whose index is stored in the data field
6810 * CC : flag signaling that this case needs external processing
6811 * D : data - either the (shifted) index of a fixed string to output or
6812 * the actual offset of the member to operate on in the struct
6813 * (since we assume bit 0 is set, the offset is not shifted)
6814 * E : flag signaling end of instruction sequence
6816 * WARNING: In order to handle larger offsets for 64bit archs, this code
6817 * assumes that no offset can be an odd number and stores the
6818 * end-of-instructions flag in bit 0.
6821 #define CMDTXT_NOMORE 0x01 /* NOTE: no offset should be odd */
6822 #define CMDTXT_CHARPTR 0x40
6823 #define CMDTXT_STRING 0x80
6824 #define CMDTXT_SPECIAL 0xC0
6825 #define CMDTXT_OFFSETMASK 0x3E
6827 static const char *const cmdtxt_strings[] = {
6828 /* 0 1 2 3 4 5 6 7 */
6829 "; ", "(", ")", " && ", " || ", "if ", "; then ", "...",
6830 /* 8 9 10 11 12 13 */
6831 "while ", "; do ", "; done", "until ", "for ", " in ...",
6833 "case ", "???", "() ...", "<<..."
6836 static const char *const redir_strings[] = {
6837 ">", "<", "<>", ">>", ">|", ">&", "<&"
6840 static const unsigned char cmdtxt_ops[] = {
6841 #define CMDTXT_NSEMI 0
6842 offsetof(union node, nbinary.ch1),
6844 offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE,
6845 #define CMDTXT_NCMD (CMDTXT_NSEMI + 3)
6846 #define CMDTXT_NPIPE (CMDTXT_NCMD)
6847 #define CMDTXT_NCASE (CMDTXT_NCMD)
6848 #define CMDTXT_NTO (CMDTXT_NCMD)
6849 #define CMDTXT_NFROM (CMDTXT_NCMD)
6850 #define CMDTXT_NFROMTO (CMDTXT_NCMD)
6851 #define CMDTXT_NAPPEND (CMDTXT_NCMD)
6852 #define CMDTXT_NTOOV (CMDTXT_NCMD)
6853 #define CMDTXT_NTOFD (CMDTXT_NCMD)
6854 #define CMDTXT_NFROMFD (CMDTXT_NCMD)
6856 #define CMDTXT_NREDIR (CMDTXT_NPIPE + 1)
6857 #define CMDTXT_NBACKGND (CMDTXT_NREDIR)
6858 offsetof(union node, nredir.n) | CMDTXT_NOMORE,
6859 #define CMDTXT_NSUBSHELL (CMDTXT_NBACKGND + 1)
6860 (1 * 2) | CMDTXT_STRING,
6861 offsetof(union node, nredir.n),
6862 (2 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6863 #define CMDTXT_NAND (CMDTXT_NSUBSHELL + 3)
6864 offsetof(union node, nbinary.ch1),
6865 (3 * 2) | CMDTXT_STRING,
6866 offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE,
6867 #define CMDTXT_NOR (CMDTXT_NAND + 3)
6868 offsetof(union node, nbinary.ch1),
6869 (4 * 2) | CMDTXT_STRING,
6870 offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE,
6871 #define CMDTXT_NIF (CMDTXT_NOR + 3)
6872 (5 * 2) | CMDTXT_STRING,
6873 offsetof(union node, nif.test),
6874 (6 * 2) | CMDTXT_STRING,
6875 offsetof(union node, nif.ifpart),
6876 (7 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6877 #define CMDTXT_NWHILE (CMDTXT_NIF + 5)
6878 (8 * 2) | CMDTXT_STRING,
6879 offsetof(union node, nbinary.ch1),
6880 (9 * 2) | CMDTXT_STRING,
6881 offsetof(union node, nbinary.ch2),
6882 (10 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6883 #define CMDTXT_NUNTIL (CMDTXT_NWHILE + 5)
6884 (11 * 2) | CMDTXT_STRING,
6885 offsetof(union node, nbinary.ch1),
6886 (9 * 2) | CMDTXT_STRING,
6887 offsetof(union node, nbinary.ch2),
6888 (10 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6889 #define CMDTXT_NFOR (CMDTXT_NUNTIL + 5)
6890 (12 * 2) | CMDTXT_STRING,
6891 offsetof(union node, nfor.var) | CMDTXT_CHARPTR,
6892 (13 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6893 #define CMDTXT_NCLIST (CMDTXT_NFOR + 3) /* TODO: IS THIS CORRECT??? */
6894 #define CMDTXT_NNOT (CMDTXT_NCLIST) /* TODO: IS THIS CORRECT??? */
6895 (15 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6896 #define CMDTXT_NDEFUN (CMDTXT_NCLIST + 1)
6897 offsetof(union node, narg.text) | CMDTXT_CHARPTR,
6898 (16 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6899 #define CMDTXT_NARG (CMDTXT_NDEFUN + 2)
6900 offsetof(union node, narg.text) | CMDTXT_CHARPTR | CMDTXT_NOMORE,
6901 #define CMDTXT_NHERE (CMDTXT_NARG + 1)
6902 #define CMDTXT_NXHERE (CMDTXT_NHERE)
6903 (17 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6906 #if CMDTXT_NXHERE != 36
6907 #error CMDTXT_NXHERE
6910 static const unsigned char cmdtxt_ops_index[26] = {
6939 static void cmdtxt(const union node *n)
6946 p = cmdtxt_ops + (int) cmdtxt_ops_index[n->type];
6947 if ((*p & CMDTXT_SPECIAL) != CMDTXT_SPECIAL) { /* normal case */
6949 if (*p & CMDTXT_STRING) { /* output fixed string */
6950 cmdputs(cmdtxt_strings
6951 [((int) (*p & CMDTXT_OFFSETMASK) >> 1)]);
6953 const char *pf = ((const char *) n)
6954 + ((int) (*p & CMDTXT_OFFSETMASK));
6956 if (*p & CMDTXT_CHARPTR) { /* output dynamic string */
6957 cmdputs(*((const char **) pf));
6958 } else { /* output field */
6959 cmdtxt(*((const union node **) pf));
6962 } while (!(*p++ & CMDTXT_NOMORE));
6963 } else if (n->type == NCMD) {
6966 for (np = n->ncmd.args; np; np = np->narg.next) {
6971 for (np = n->ncmd.redirect; np; np = np->nfile.next) {
6975 } else if (n->type == NPIPE) {
6976 struct nodelist *lp;
6978 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
6983 } else if (n->type == NCASE) {
6984 cmdputs(cmdtxt_strings[14]);
6985 cmdputs(n->ncase.expr->narg.text);
6986 cmdputs(cmdtxt_strings[13]);
6988 #if (NTO != 16) || (NFROM != 17) || (NFROMTO != 18) || (NAPPEND != 19) || (NTOOV != 20) || (NTOFD != 21) || (NFROMFD != 22)
6989 #error Assumption violated regarding range and ordering of NTO ... NFROMFD!
6994 assert((n->type >= NTO) && (n->type <= NFROMFD));
6997 p = redir_strings[n->type - NTO];
6998 if (n->nfile.fd != ('>' == *p)) {
6999 s[0] = n->nfile.fd + '0';
7004 if (n->type >= NTOFD) {
7005 s[0] = n->ndup.dupfd + '0';
7009 cmdtxt(n->nfile.fname);
7013 #else /* CMDTXT_TABLE */
7014 static void cmdtxt(const union node *n)
7017 struct nodelist *lp;
7026 cmdtxt(n->nbinary.ch1);
7028 cmdtxt(n->nbinary.ch2);
7031 cmdtxt(n->nbinary.ch1);
7033 cmdtxt(n->nbinary.ch2);
7036 cmdtxt(n->nbinary.ch1);
7038 cmdtxt(n->nbinary.ch2);
7041 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
7049 cmdtxt(n->nredir.n);
7054 cmdtxt(n->nredir.n);
7058 cmdtxt(n->nif.test);
7060 cmdtxt(n->nif.ifpart);
7069 cmdtxt(n->nbinary.ch1);
7071 cmdtxt(n->nbinary.ch2);
7076 cmdputs(n->nfor.var);
7081 cmdputs(n->ncase.expr->narg.text);
7085 cmdputs(n->narg.text);
7089 for (np = n->ncmd.args; np; np = np->narg.next) {
7094 for (np = n->ncmd.redirect; np; np = np->nfile.next) {
7100 cmdputs(n->narg.text);
7131 if (n->nfile.fd != i) {
7132 s[0] = n->nfile.fd + '0';
7137 if (n->type == NTOFD || n->type == NFROMFD) {
7138 s[0] = n->ndup.dupfd + '0';
7142 cmdtxt(n->nfile.fname);
7154 #endif /* CMDTXT_TABLE */
7156 static char *commandtext(const union node *n)
7160 cmdnextc = name = xmalloc(MAXCMDTEXT);
7161 cmdnleft = MAXCMDTEXT - 4;
7168 #ifdef CONFIG_ASH_MAIL
7171 * Routines to check for mail.
7175 #define MAXMBOXES 10
7178 static int nmboxes; /* number of mailboxes */
7179 static time_t mailtime[MAXMBOXES]; /* times of mailboxes */
7184 * Print appropriate message(s) if mail has arrived. If the argument is
7185 * nozero, then the value of MAIL has changed, so we just update the
7189 static void chkmail(int silent)
7195 struct stackmark smark;
7202 setstackmark(&smark);
7203 mpath = mpathset()? mpathval() : mailval();
7204 for (i = 0; i < nmboxes; i++) {
7205 p = padvance(&mpath, nullstr);
7210 for (q = p; *q; q++);
7215 q[-1] = '\0'; /* delete trailing '/' */
7216 if (stat(p, &statb) < 0)
7218 if (statb.st_size > mailtime[i] && !silent) {
7219 out2fmt(snlfmt, pathopt ? pathopt : "you have mail");
7221 mailtime[i] = statb.st_size;
7224 popstackmark(&smark);
7227 #endif /* CONFIG_ASH_MAIL */
7232 static short profile_buf[16384];
7236 static int isloginsh = 0;
7238 static void read_profile(const char *);
7239 static void cmdloop(int);
7240 static void options(int);
7241 static void setoption(int, int);
7242 static void procargs(int, char **);
7246 * Main routine. We initialize things, parse the arguments, execute
7247 * profiles if we're a login shell, and then call cmdloop to execute
7248 * commands. The setjmp call sets up the location to jump to when an
7249 * exception occurs. When an exception occurs the variable "state"
7250 * is used to figure out how far we had gotten.
7253 int ash_main(int argc, char **argv)
7255 struct jmploc jmploc;
7256 struct stackmark smark;
7260 BLTINCMD = find_builtin("builtin");
7261 EXECCMD = find_builtin("exec");
7262 EVALCMD = find_builtin("eval");
7264 #ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
7270 monitor(4, etext, profile_buf, sizeof profile_buf, 50);
7272 #if defined(linux) || defined(__GNU__)
7273 signal(SIGCHLD, SIG_DFL);
7276 if (setjmp(jmploc.loc)) {
7279 * When a shell procedure is executed, we raise the
7280 * exception EXSHELLPROC to clean up before executing
7281 * the shell procedure.
7283 if (exception == EXSHELLPROC) {
7289 if (exception == EXEXEC) {
7290 exitstatus = exerrno;
7291 } else if (exception == EXERROR) {
7294 if (state == 0 || iflag == 0 || !rootshell)
7295 exitshell(exitstatus);
7298 if (exception == EXINT) {
7301 popstackmark(&smark);
7302 FORCEINTON; /* enable interrupts */
7305 else if (state == 2)
7307 else if (state == 3)
7315 trputs("Shell args: ");
7321 setstackmark(&smark);
7322 procargs(argc, argv);
7323 #ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
7325 const char *hp = lookupvar("HISTFILE");
7328 hp = lookupvar("HOME");
7330 char *defhp = concat_path_file(hp, ".ash_history");
7331 setvar("HISTFILE", defhp, 0);
7337 if (argv[0] && argv[0][0] == '-')
7341 read_profile("/etc/profile");
7344 read_profile(".profile");
7349 if (getuid() == geteuid() && getgid() == getegid()) {
7351 if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
7353 read_profile(shinit);
7360 if (sflag == 0 || minusc) {
7361 static const char sigs[] = {
7362 SIGINT, SIGQUIT, SIGHUP,
7369 #define SIGSSIZE ((sizeof(sigs)/sizeof(sigs[0])))
7372 for (i = 0; i < SIGSSIZE; i++)
7377 evalstring(minusc, 0);
7379 if (sflag || minusc == NULL) {
7380 state4: /* XXX ??? - why isn't this before the "if" statement */
7381 #ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
7383 const char *hp = lookupvar("HISTFILE");
7386 load_history ( hp );
7394 exitshell(exitstatus);
7400 * Read and execute commands. "Top" is nonzero for the top level command
7401 * loop; it turns on prompting if the shell is interactive.
7404 static void cmdloop(int top)
7407 struct stackmark smark;
7411 TRACE(("cmdloop(%d) called\n", top));
7412 setstackmark(&smark);
7420 #ifdef CONFIG_ASH_MAIL
7425 n = parsecmd(inter);
7426 /* showtree(n); DEBUG */
7428 if (!top || numeof >= 50)
7430 if (!stoppedjobs()) {
7433 out2str("\nUse \"exit\" to leave shell.\n");
7436 } else if (n != NULL && nflag == 0) {
7437 job_warning = (job_warning == 2) ? 1 : 0;
7441 popstackmark(&smark);
7442 setstackmark(&smark);
7443 if (evalskip == SKIPFILE) {
7448 popstackmark(&smark);
7454 * Read /etc/profile or .profile. Return on error.
7457 static void read_profile(const char *name)
7464 if ((fd = open(name, O_RDONLY)) >= 0)
7469 /* -q turns off -x and -v just when executing init files */
7470 /* Note: Might do a little redundant work, but reduces code size. */
7485 * Read a file containing shell functions.
7488 static void readcmdfile(const char *name)
7493 if ((fd = open(name, O_RDONLY)) >= 0)
7496 error("Can't open %s", name);
7505 * Take commands from a file. To be compatable we should do a path
7506 * search for the file, which is necessary to find sub-commands.
7509 static inline char *find_dot_file(char *mybasename)
7512 const char *path = pathval();
7515 /* don't try this for absolute or relative paths */
7516 if (strchr(mybasename, '/'))
7519 while ((fullname = padvance(&path, mybasename)) != NULL) {
7520 if ((stat(fullname, &statb) == 0) && S_ISREG(statb.st_mode)) {
7522 * Don't bother freeing here, since it will
7523 * be freed by the caller.
7527 stunalloc(fullname);
7530 /* not found in the PATH */
7531 error("%s: not found", mybasename);
7535 static int dotcmd(int argc, char **argv)
7538 volatile struct shparam saveparam;
7542 for (sp = cmdenviron; sp; sp = sp->next)
7543 setvareq(xstrdup(sp->text), VSTRFIXED | VTEXTFIXED);
7545 if (argc >= 2) { /* That's what SVR2 does */
7547 struct stackmark smark;
7549 setstackmark(&smark);
7550 fullname = find_dot_file(argv[1]);
7553 saveparam = shellparam;
7554 shellparam.malloc = 0;
7555 shellparam.nparam = argc - 2;
7556 shellparam.p = argv + 2;
7559 setinputfile(fullname, 1);
7560 commandname = fullname;
7565 freeparam(&shellparam);
7566 shellparam = saveparam;
7569 popstackmark(&smark);
7575 static int exitcmd(int argc, char **argv)
7581 exitstatus = number(argv[1]);
7583 exitstatus = oexitstatus;
7584 exitshell(exitstatus);
7588 static pointer stalloc(int nbytes)
7592 nbytes = ALIGN(nbytes);
7593 if (nbytes > stacknleft) {
7595 struct stack_block *sp;
7598 if (blocksize < MINSIZE)
7599 blocksize = MINSIZE;
7601 sp = xmalloc(sizeof(struct stack_block) - MINSIZE + blocksize);
7603 stacknxt = sp->space;
7604 stacknleft = blocksize;
7610 stacknleft -= nbytes;
7615 static void stunalloc(pointer p)
7618 if (p == NULL) { /*DEBUG */
7619 write(2, "stunalloc\n", 10);
7623 if (!(stacknxt >= (char *) p && (char *) p >= stackp->space)) {
7626 stacknleft += stacknxt - (char *) p;
7631 static void setstackmark(struct stackmark *mark)
7633 mark->stackp = stackp;
7634 mark->stacknxt = stacknxt;
7635 mark->stacknleft = stacknleft;
7636 mark->marknext = markp;
7641 static void popstackmark(struct stackmark *mark)
7643 struct stack_block *sp;
7646 markp = mark->marknext;
7647 while (stackp != mark->stackp) {
7652 stacknxt = mark->stacknxt;
7653 stacknleft = mark->stacknleft;
7659 * When the parser reads in a string, it wants to stick the string on the
7660 * stack and only adjust the stack pointer when it knows how big the
7661 * string is. Stackblock (defined in stack.h) returns a pointer to a block
7662 * of space on top of the stack and stackblocklen returns the length of
7663 * this block. Growstackblock will grow this space by at least one byte,
7664 * possibly moving it (like realloc). Grabstackblock actually allocates the
7665 * part of the block that has been used.
7668 static void growstackblock(void)
7671 int newlen = ALIGN(stacknleft * 2 + 100);
7672 char *oldspace = stacknxt;
7673 int oldlen = stacknleft;
7674 struct stack_block *sp;
7675 struct stack_block *oldstackp;
7677 if (stacknxt == stackp->space && stackp != &stackbase) {
7682 sp = xrealloc((pointer) sp,
7683 sizeof(struct stack_block) - MINSIZE + newlen);
7686 stacknxt = sp->space;
7687 stacknleft = newlen;
7689 /* Stack marks pointing to the start of the old block
7690 * must be relocated to point to the new block
7692 struct stackmark *xmark;
7695 while (xmark != NULL && xmark->stackp == oldstackp) {
7696 xmark->stackp = stackp;
7697 xmark->stacknxt = stacknxt;
7698 xmark->stacknleft = stacknleft;
7699 xmark = xmark->marknext;
7704 p = stalloc(newlen);
7705 memcpy(p, oldspace, oldlen);
7706 stacknxt = p; /* free the space */
7707 stacknleft += newlen; /* we just allocated */
7713 static inline void grabstackblock(int len)
7723 * The following routines are somewhat easier to use that the above.
7724 * The user declares a variable of type STACKSTR, which may be declared
7725 * to be a register. The macro STARTSTACKSTR initializes things. Then
7726 * the user uses the macro STPUTC to add characters to the string. In
7727 * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is
7728 * grown as necessary. When the user is done, she can just leave the
7729 * string there and refer to it using stackblock(). Or she can allocate
7730 * the space for it using grabstackstr(). If it is necessary to allow
7731 * someone else to use the stack temporarily and then continue to grow
7732 * the string, the user should use grabstack to allocate the space, and
7733 * then call ungrabstr(p) to return to the previous mode of operation.
7735 * USTPUTC is like STPUTC except that it doesn't check for overflow.
7736 * CHECKSTACKSPACE can be called before USTPUTC to ensure that there
7737 * is space for at least one character.
7741 static char *growstackstr(void)
7743 int len = stackblocksize();
7745 if (herefd >= 0 && len >= 1024) {
7746 xwrite(herefd, stackblock(), len);
7747 sstrnleft = len - 1;
7748 return stackblock();
7751 sstrnleft = stackblocksize() - len - 1;
7752 return stackblock() + len;
7757 * Called from CHECKSTRSPACE.
7760 static char *makestrspace(size_t newlen)
7762 int len = stackblocksize() - sstrnleft;
7766 sstrnleft = stackblocksize() - len;
7767 } while (sstrnleft < newlen);
7768 return stackblock() + len;
7773 static void ungrabstackstr(char *s, char *p)
7775 stacknleft += stacknxt - s;
7777 sstrnleft = stacknleft - (p - s);
7781 * Miscelaneous builtins.
7787 #if !defined(__GLIBC__) || __GLIBC__ == 2 && __GLIBC_MINOR__ < 1
7788 typedef long rlim_t;
7794 * The read builtin. The -e option causes backslashes to escape the
7795 * following character.
7797 * This uses unbuffered input, which may be avoidable in some cases.
7800 static int readcmd(int argc, char **argv)
7815 while ((i = nextopt("p:r")) != '\0') {
7821 if (prompt && isatty(0)) {
7822 out2str(prompt); /* read without cmdedit */
7825 if (*(ap = argptr) == NULL)
7827 if ((ifs = bltinlookup("IFS")) == NULL)
7834 if (read(0, &c, 1) != 1) {
7846 if (!rflag && c == '\\') {
7852 if (startword && *ifs == ' ' && strchr(ifs, c)) {
7856 if (backslash && c == '\\') {
7857 if (read(0, &c, 1) != 1) {
7862 } else if (ap[1] != NULL && strchr(ifs, c) != NULL) {
7864 setvar(*ap, stackblock(), 0);
7873 /* Remove trailing blanks */
7874 while (stackblock() <= --p && strchr(ifs, *p) != NULL)
7876 setvar(*ap, stackblock(), 0);
7877 while (*++ap != NULL)
7878 setvar(*ap, nullstr, 0);
7884 static int umaskcmd(int argc, char **argv)
7886 static const char permuser[3] = "ugo";
7887 static const char permmode[3] = "rwx";
7888 static const short int permmask[] = {
7889 S_IRUSR, S_IWUSR, S_IXUSR,
7890 S_IRGRP, S_IWGRP, S_IXGRP,
7891 S_IROTH, S_IWOTH, S_IXOTH
7897 int symbolic_mode = 0;
7899 while (nextopt("S") != '\0') {
7908 if ((ap = *argptr) == NULL) {
7909 if (symbolic_mode) {
7913 for (i = 0; i < 3; i++) {
7918 for (j = 0; j < 3; j++) {
7919 if ((mask & permmask[3 * i + j]) == 0) {
7928 printf("%.4o\n", mask);
7931 if (is_digit((unsigned char) *ap)) {
7934 if (*ap >= '8' || *ap < '0')
7935 error("Illegal number: %s", argv[1]);
7936 mask = (mask << 3) + (*ap - '0');
7937 } while (*++ap != '\0');
7940 mask = ~mask & 0777;
7941 if (!parse_mode(ap, &mask)) {
7942 error("Illegal mode: %s", ap);
7944 umask(~mask & 0777);
7953 * This code, originally by Doug Gwyn, Doug Kingston, Eric Gisin, and
7954 * Michael Rendell was ripped from pdksh 5.0.8 and hacked for use with
7955 * ash by J.T. Conklin.
7963 short factor; /* multiply by to get rlim_{cur,max} values */
7966 static const struct limits limits[] = {
7968 {"time(seconds)", RLIMIT_CPU, 1},
7971 {"file(blocks)", RLIMIT_FSIZE, 512},
7974 {"data(kbytes)", RLIMIT_DATA, 1024},
7977 {"stack(kbytes)", RLIMIT_STACK, 1024},
7980 {"coredump(blocks)", RLIMIT_CORE, 512},
7983 {"memory(kbytes)", RLIMIT_RSS, 1024},
7985 #ifdef RLIMIT_MEMLOCK
7986 {"locked memory(kbytes)", RLIMIT_MEMLOCK, 1024},
7989 {"process(processes)", RLIMIT_NPROC, 1},
7991 #ifdef RLIMIT_NOFILE
7992 {"nofiles(descriptors)", RLIMIT_NOFILE, 1},
7995 {"vmemory(kbytes)", RLIMIT_VMEM, 1024},
7998 {"swap(kbytes)", RLIMIT_SWAP, 1024},
8003 static int ulimitcmd(int argc, char **argv)
8005 static const char unlimited_string[] = "unlimited";
8008 enum { SOFT = 0x1, HARD = 0x2 } how = SOFT | HARD;
8009 const struct limits *l;
8012 struct rlimit limit;
8016 while ((optc = nextopt("HSa"
8035 #ifdef RLIMIT_MEMLOCK
8041 #ifdef RLIMIT_NOFILE
8053 } else if (optc == 'S') {
8055 } else if (optc == 'a') {
8062 for (l = limits; l->name; l++) {
8063 if (l->name[0] == what)
8065 if (l->name[1] == 'w' && what == 'w')
8069 set = *argptr ? 1 : 0;
8073 if (all || argptr[1])
8074 error("too many arguments");
8075 if (strcmp(p, unlimited_string) == 0)
8076 val = RLIM_INFINITY;
8080 while ((c = *p++) >= '0' && c <= '9') {
8081 val = (val * 10) + (long) (c - '0');
8082 if (val < (rlim_t) 0)
8086 error("bad number");
8092 for (l = limits; l->name; l++) {
8093 printf("%-20s ", l->name);
8094 getrlimit(l->cmd, &limit);
8097 val = limit.rlim_cur;
8098 else if (how & HARD)
8099 val = limit.rlim_max;
8101 if (val == RLIM_INFINITY)
8102 puts(unlimited_string);
8105 printf("%lld\n", (long long) val);
8118 getrlimit(l->cmd, &limit);
8120 limit.rlim_max = val;
8122 limit.rlim_cur = val;
8123 if (setrlimit(l->cmd, &limit) < 0)
8124 error("error setting limit (%m)");
8129 * prefix -- see if pfx is a prefix of string.
8132 static int prefix(char const *pfx, char const *string)
8135 if (*pfx++ != *string++)
8142 * Return true if s is a string of digits, and save munber in intptr
8146 static int is_number(const char *p, int *intptr)
8154 ret += digit_val(*p);
8156 } while (*p != '\0');
8163 * Convert a string of digits to an integer, printing an error message on
8167 static int number(const char *s)
8171 if (!is_number(s, &i))
8172 error("Illegal number: %s", s);
8177 * Produce a possibly single quoted string suitable as input to the shell.
8178 * The return string is allocated on the stack.
8181 static char *single_quote(const char *s)
8189 size_t len1, len1p, len2, len2p;
8191 len1 = strcspn(s, "'");
8192 len2 = strspn(s + len1, "'");
8194 len1p = len1 ? len1 + 2 : len1;
8195 len2p = len2 + ((len2 < 2) ? len2 : 2);
8197 CHECKSTRSPACE(len1p + len2p + 1, p);
8202 memcpy(p + 1, s, len1);
8210 memcpy(q + 1, s, len2);
8213 } else if (len2 == 1) {
8219 STADJUST(len1p + len2p, p);
8224 return grabstackstr(p);
8228 * Routine for dealing with parsed shell commands.
8232 static void sizenodelist(const struct nodelist *);
8233 static struct nodelist *copynodelist(const struct nodelist *);
8234 static char *nodesavestr(const char *);
8236 #define CALCSIZE_TABLE
8237 #define COPYNODE_TABLE
8238 #if defined(CALCSIZE_TABLE) || defined(COPYNODE_TABLE)
8240 * To collect a lot of redundant code in case statements for copynode()
8241 * and calcsize(), we implement a mini language here. Each type of node
8242 * struct has an associated instruction sequence that operates on its
8243 * members via their offsets. The instruction are pack in unsigned chars
8244 * with format IIDDDDDE where the bits are
8245 * I : part of the instruction opcode, which are
8246 * 00 : member is a pointer to another node
8247 * 40 : member is an integer
8248 * 80 : member is a pointer to a nodelist
8249 * CC : member is a pointer to a char string
8250 * D : data - the actual offset of the member to operate on in the struct
8251 * (since we assume bit 0 is set, it is not shifted)
8252 * E : flag signaling end of instruction sequence
8254 * WARNING: In order to handle larger offsets for 64bit archs, this code
8255 * assumes that no offset can be an odd number and stores the
8256 * end-of-instructions flag in bit 0.
8259 #define NODE_INTEGER 0x40
8260 #define NODE_NODELIST 0x80
8261 #define NODE_CHARPTR 0xC0
8262 #define NODE_NOMORE 0x01 /* Note: no offset should be odd (aligned) */
8263 #define NODE_MBRMASK 0xC0
8264 #define NODE_OFFSETMASK 0x3E
8266 static const unsigned char copynode_ops[35] = {
8267 #define COPYNODE_OPS0 0
8268 offsetof(union node, nbinary.ch2),
8269 offsetof(union node, nbinary.ch1) | NODE_NOMORE,
8270 #define COPYNODE_OPS1 (COPYNODE_OPS0 + 2)
8271 offsetof(union node, ncmd.redirect),
8272 offsetof(union node, ncmd.args),
8273 offsetof(union node, ncmd.assign),
8274 offsetof(union node, ncmd.backgnd) | NODE_INTEGER | NODE_NOMORE,
8275 #define COPYNODE_OPS2 (COPYNODE_OPS1 + 4)
8276 offsetof(union node, npipe.cmdlist) | NODE_NODELIST,
8277 offsetof(union node, npipe.backgnd) | NODE_INTEGER | NODE_NOMORE,
8278 #define COPYNODE_OPS3 (COPYNODE_OPS2 + 2)
8279 offsetof(union node, nredir.redirect),
8280 offsetof(union node, nredir.n) | NODE_NOMORE,
8281 #define COPYNODE_OPS4 (COPYNODE_OPS3 + 2)
8282 offsetof(union node, nif.elsepart),
8283 offsetof(union node, nif.ifpart),
8284 offsetof(union node, nif.test) | NODE_NOMORE,
8285 #define COPYNODE_OPS5 (COPYNODE_OPS4 + 3)
8286 offsetof(union node, nfor.var) | NODE_CHARPTR,
8287 offsetof(union node, nfor.body),
8288 offsetof(union node, nfor.args) | NODE_NOMORE,
8289 #define COPYNODE_OPS6 (COPYNODE_OPS5 + 3)
8290 offsetof(union node, ncase.cases),
8291 offsetof(union node, ncase.expr) | NODE_NOMORE,
8292 #define COPYNODE_OPS7 (COPYNODE_OPS6 + 2)
8293 offsetof(union node, nclist.body),
8294 offsetof(union node, nclist.pattern),
8295 offsetof(union node, nclist.next) | NODE_NOMORE,
8296 #define COPYNODE_OPS8 (COPYNODE_OPS7 + 3)
8297 offsetof(union node, narg.backquote) | NODE_NODELIST,
8298 offsetof(union node, narg.text) | NODE_CHARPTR,
8299 offsetof(union node, narg.next) | NODE_NOMORE,
8300 #define COPYNODE_OPS9 (COPYNODE_OPS8 + 3)
8301 offsetof(union node, nfile.fname),
8302 offsetof(union node, nfile.fd) | NODE_INTEGER,
8303 offsetof(union node, nfile.next) | NODE_NOMORE,
8304 #define COPYNODE_OPS10 (COPYNODE_OPS9 + 3)
8305 offsetof(union node, ndup.vname),
8306 offsetof(union node, ndup.dupfd) | NODE_INTEGER,
8307 offsetof(union node, ndup.fd) | NODE_INTEGER,
8308 offsetof(union node, ndup.next) | NODE_NOMORE,
8309 #define COPYNODE_OPS11 (COPYNODE_OPS10 + 4)
8310 offsetof(union node, nhere.doc),
8311 offsetof(union node, nhere.fd) | NODE_INTEGER,
8312 offsetof(union node, nhere.next) | NODE_NOMORE,
8313 #define COPYNODE_OPS12 (COPYNODE_OPS11 + 3)
8314 offsetof(union node, nnot.com) | NODE_NOMORE,
8317 #if COPYNODE_OPS12 != 34
8318 #error COPYNODE_OPS12 is incorrect
8321 static const unsigned char copynode_ops_index[26] = {
8322 COPYNODE_OPS0, /* NSEMI */
8323 COPYNODE_OPS1, /* NCMD */
8324 COPYNODE_OPS2, /* NPIPE */
8325 COPYNODE_OPS3, /* NREDIR */
8326 COPYNODE_OPS3, /* NBACKGND */
8327 COPYNODE_OPS3, /* NSUBSHELL */
8328 COPYNODE_OPS0, /* NAND */
8329 COPYNODE_OPS0, /* NOR */
8330 COPYNODE_OPS4, /* NIF */
8331 COPYNODE_OPS0, /* NWHILE */
8332 COPYNODE_OPS0, /* NUNTIL */
8333 COPYNODE_OPS5, /* NFOR */
8334 COPYNODE_OPS6, /* NCASE */
8335 COPYNODE_OPS7, /* NCLIST */
8336 COPYNODE_OPS8, /* NDEFUN */
8337 COPYNODE_OPS8, /* NARG */
8338 COPYNODE_OPS9, /* NTO */
8339 COPYNODE_OPS9, /* NFROM */
8340 COPYNODE_OPS9, /* NFROMTO */
8341 COPYNODE_OPS9, /* NAPPEND */
8342 COPYNODE_OPS9, /* NTOOV */
8343 COPYNODE_OPS10, /* NTOFD */
8344 COPYNODE_OPS10, /* NFROMFD */
8345 COPYNODE_OPS11, /* NHERE */
8346 COPYNODE_OPS11, /* NXHERE */
8347 COPYNODE_OPS12, /* NNOT */
8350 #if NODE_CHARPTR != NODE_MBRMASK
8351 #error NODE_CHARPTR != NODE_MBRMASK!!!
8353 #endif /* defined(CALCSIZE_TABLE) || defined(COPYNODE_TABLE) */
8355 #ifdef COPYNODE_TABLE
8356 static union node *copynode(const union node *n)
8359 const unsigned char *p;
8365 new->type = n->type;
8366 funcblock = (char *) funcblock + (int) nodesize[n->type];
8367 p = copynode_ops + (int) copynode_ops_index[n->type];
8369 char *nn = ((char *) new) + ((int) (*p & NODE_OFFSETMASK));
8370 const char *no = ((const char *) n) + ((int) (*p & NODE_OFFSETMASK));
8372 if (!(*p & NODE_MBRMASK)) { /* standard node */
8373 *((union node **) nn) = copynode(*((const union node **) no));
8374 } else if ((*p & NODE_MBRMASK) == NODE_CHARPTR) { /* string */
8375 *((const char **) nn) = nodesavestr(*((const char **) no));
8376 } else if (*p & NODE_NODELIST) { /* nodelist */
8377 *((struct nodelist **) nn)
8378 = copynodelist(*((const struct nodelist **) no));
8379 } else { /* integer */
8380 *((int *) nn) = *((int *) no);
8382 } while (!(*p++ & NODE_NOMORE));
8385 #else /* COPYNODE_TABLE */
8386 static union node *copynode(const union node *n)
8393 funcblock = (char *) funcblock + nodesize[n->type];
8400 new->nbinary.ch2 = copynode(n->nbinary.ch2);
8401 new->nbinary.ch1 = copynode(n->nbinary.ch1);
8404 new->ncmd.redirect = copynode(n->ncmd.redirect);
8405 new->ncmd.args = copynode(n->ncmd.args);
8406 new->ncmd.assign = copynode(n->ncmd.assign);
8407 new->ncmd.backgnd = n->ncmd.backgnd;
8410 new->npipe.cmdlist = copynodelist(n->npipe.cmdlist);
8411 new->npipe.backgnd = n->npipe.backgnd;
8416 new->nredir.redirect = copynode(n->nredir.redirect);
8417 new->nredir.n = copynode(n->nredir.n);
8420 new->nif.elsepart = copynode(n->nif.elsepart);
8421 new->nif.ifpart = copynode(n->nif.ifpart);
8422 new->nif.test = copynode(n->nif.test);
8425 new->nfor.var = nodesavestr(n->nfor.var);
8426 new->nfor.body = copynode(n->nfor.body);
8427 new->nfor.args = copynode(n->nfor.args);
8430 new->ncase.cases = copynode(n->ncase.cases);
8431 new->ncase.expr = copynode(n->ncase.expr);
8434 new->nclist.body = copynode(n->nclist.body);
8435 new->nclist.pattern = copynode(n->nclist.pattern);
8436 new->nclist.next = copynode(n->nclist.next);
8440 new->narg.backquote = copynodelist(n->narg.backquote);
8441 new->narg.text = nodesavestr(n->narg.text);
8442 new->narg.next = copynode(n->narg.next);
8449 new->nfile.fname = copynode(n->nfile.fname);
8450 new->nfile.fd = n->nfile.fd;
8451 new->nfile.next = copynode(n->nfile.next);
8455 new->ndup.vname = copynode(n->ndup.vname);
8456 new->ndup.dupfd = n->ndup.dupfd;
8457 new->ndup.fd = n->ndup.fd;
8458 new->ndup.next = copynode(n->ndup.next);
8462 new->nhere.doc = copynode(n->nhere.doc);
8463 new->nhere.fd = n->nhere.fd;
8464 new->nhere.next = copynode(n->nhere.next);
8467 new->nnot.com = copynode(n->nnot.com);
8470 new->type = n->type;
8473 #endif /* COPYNODE_TABLE */
8475 #ifdef CALCSIZE_TABLE
8476 static void calcsize(const union node *n)
8478 const unsigned char *p;
8482 funcblocksize += (int) nodesize[n->type];
8484 p = copynode_ops + (int) copynode_ops_index[n->type];
8486 const char *no = ((const char *) n) + ((int) (*p & NODE_OFFSETMASK));
8488 if (!(*p & NODE_MBRMASK)) { /* standard node */
8489 calcsize(*((const union node **) no));
8490 } else if ((*p & NODE_MBRMASK) == NODE_CHARPTR) { /* string */
8491 funcstringsize += strlen(*((const char **) no)) + 1;
8492 } else if (*p & NODE_NODELIST) { /* nodelist */
8493 sizenodelist(*((const struct nodelist **) no));
8494 } /* else integer -- ignore */
8495 } while (!(*p++ & NODE_NOMORE));
8497 #else /* CALCSIZE_TABLE */
8498 static void calcsize(const union node *n)
8502 funcblocksize += nodesize[n->type];
8509 calcsize(n->nbinary.ch2);
8510 calcsize(n->nbinary.ch1);
8513 calcsize(n->ncmd.redirect);
8514 calcsize(n->ncmd.args);
8515 calcsize(n->ncmd.assign);
8518 sizenodelist(n->npipe.cmdlist);
8523 calcsize(n->nredir.redirect);
8524 calcsize(n->nredir.n);
8527 calcsize(n->nif.elsepart);
8528 calcsize(n->nif.ifpart);
8529 calcsize(n->nif.test);
8532 funcstringsize += strlen(n->nfor.var) + 1;
8533 calcsize(n->nfor.body);
8534 calcsize(n->nfor.args);
8537 calcsize(n->ncase.cases);
8538 calcsize(n->ncase.expr);
8541 calcsize(n->nclist.body);
8542 calcsize(n->nclist.pattern);
8543 calcsize(n->nclist.next);
8547 sizenodelist(n->narg.backquote);
8548 funcstringsize += strlen(n->narg.text) + 1;
8549 calcsize(n->narg.next);
8556 calcsize(n->nfile.fname);
8557 calcsize(n->nfile.next);
8561 calcsize(n->ndup.vname);
8562 calcsize(n->ndup.next);
8566 calcsize(n->nhere.doc);
8567 calcsize(n->nhere.next);
8570 calcsize(n->nnot.com);
8574 #endif /* CALCSIZE_TABLE */
8576 static void sizenodelist(const struct nodelist *lp)
8579 funcblocksize += ALIGN(sizeof(struct nodelist));
8586 static struct nodelist *copynodelist(const struct nodelist *lp)
8588 struct nodelist *start;
8589 struct nodelist **lpp;
8594 funcblock = (char *) funcblock + ALIGN(sizeof(struct nodelist));
8595 (*lpp)->n = copynode(lp->n);
8597 lpp = &(*lpp)->next;
8604 static char *nodesavestr(const char *s)
8607 char *q = funcstring;
8608 char *rtn = funcstring;
8610 while ((*q++ = *p++) != '\0')
8616 #ifdef CONFIG_ASH_GETOPTS
8617 static int getopts(char *, char *, char **, int *, int *);
8621 * Process the shell command line arguments.
8624 static void procargs(int argc, char **argv)
8631 for (i = 0; i < NOPTS; i++)
8634 if (*argptr == NULL && minusc == NULL)
8636 if (iflag == 2 && sflag == 1 && isatty(0) && isatty(1))
8640 for (i = 0; i < NOPTS; i++)
8641 if (optent_val(i) == 2)
8644 if (sflag == 0 && minusc == NULL) {
8645 commandname = argv[0];
8647 setinputfile(arg0, 0);
8650 /* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
8651 if (argptr && minusc && *argptr)
8654 shellparam.p = argptr;
8655 shellparam.optind = 1;
8656 shellparam.optoff = -1;
8657 /* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
8659 shellparam.nparam++;
8668 * Process shell options. The global variable argptr contains a pointer
8669 * to the argument list; we advance it past the options.
8672 static inline void minus_o(const char *name, int val)
8677 out1str("Current option settings\n");
8678 for (i = 0; i < NOPTS; i++)
8679 printf("%-16s%s\n", optent_name(optlist[i]),
8680 optent_val(i) ? "on" : "off");
8682 for (i = 0; i < NOPTS; i++)
8683 if (equal(name, optent_name(optlist[i]))) {
8684 setoption(optent_letter(optlist[i]), val);
8687 error("Illegal option -o %s", name);
8692 static void options(int cmdline)
8700 while ((p = *argptr) != NULL) {
8702 if ((c = *p++) == '-') {
8704 if (p[0] == '\0' || (p[0] == '-' && p[1] == '\0')) {
8706 /* "-" means turn off -x and -v */
8709 /* "--" means reset params */
8710 else if (*argptr == NULL)
8713 break; /* "-" or "--" terminates options */
8715 } else if (c == '+') {
8721 while ((c = *p++) != '\0') {
8722 if (c == 'c' && cmdline) {
8725 #ifdef NOHACK /* removing this code allows sh -ce 'foo' for compat */
8729 if (q == NULL || minusc != NULL)
8730 error("Bad -c option");
8735 } else if (c == 'o') {
8736 minus_o(*argptr, val);
8739 } else if (cmdline && (c == '-')) { // long options
8740 if (strcmp(p, "login") == 0)
8751 static void setoption(int flag, int val)
8755 for (i = 0; i < NOPTS; i++)
8756 if (optent_letter(optlist[i]) == flag) {
8757 optent_val(i) = val;
8759 /* #%$ hack for ksh semantics */
8762 else if (flag == 'E')
8767 error("Illegal option -%c", flag);
8774 * Set the shell parameters.
8777 static void setparam(char **argv)
8783 for (nparam = 0; argv[nparam]; nparam++);
8784 ap = newparam = xmalloc((nparam + 1) * sizeof *ap);
8786 *ap++ = xstrdup(*argv++);
8789 freeparam(&shellparam);
8790 shellparam.malloc = 1;
8791 shellparam.nparam = nparam;
8792 shellparam.p = newparam;
8793 shellparam.optind = 1;
8794 shellparam.optoff = -1;
8799 * Free the list of positional parameters.
8802 static void freeparam(volatile struct shparam *param)
8806 if (param->malloc) {
8807 for (ap = param->p; *ap; ap++)
8816 * The shift builtin command.
8819 static int shiftcmd(int argc, char **argv)
8826 n = number(argv[1]);
8827 if (n > shellparam.nparam)
8828 error("can't shift that many");
8830 shellparam.nparam -= n;
8831 for (ap1 = shellparam.p; --n >= 0; ap1++) {
8832 if (shellparam.malloc)
8836 while ((*ap2++ = *ap1++) != NULL);
8837 shellparam.optind = 1;
8838 shellparam.optoff = -1;
8846 * The set command builtin.
8849 static int setcmd(int argc, char **argv)
8852 return showvarscmd(argc, argv);
8856 if (*argptr != NULL) {
8864 static void getoptsreset(const char *value)
8866 shellparam.optind = number(value);
8867 shellparam.optoff = -1;
8870 #ifdef CONFIG_LOCALE_SUPPORT
8871 static void change_lc_all(const char *value)
8873 if (value != 0 && *value != 0)
8874 setlocale(LC_ALL, value);
8877 static void change_lc_ctype(const char *value)
8879 if (value != 0 && *value != 0)
8880 setlocale(LC_CTYPE, value);
8885 #ifdef CONFIG_ASH_GETOPTS
8887 * The getopts builtin. Shellparam.optnext points to the next argument
8888 * to be processed. Shellparam.optptr points to the next character to
8889 * be processed in the current argument. If shellparam.optnext is NULL,
8890 * then it's the first time getopts has been called.
8893 static int getoptscmd(int argc, char **argv)
8898 error("Usage: getopts optstring var [arg]");
8899 else if (argc == 3) {
8900 optbase = shellparam.p;
8901 if (shellparam.optind > shellparam.nparam + 1) {
8902 shellparam.optind = 1;
8903 shellparam.optoff = -1;
8907 if (shellparam.optind > argc - 2) {
8908 shellparam.optind = 1;
8909 shellparam.optoff = -1;
8913 return getopts(argv[1], argv[2], optbase, &shellparam.optind,
8914 &shellparam.optoff);
8918 * Safe version of setvar, returns 1 on success 0 on failure.
8921 static int setvarsafe(const char *name, const char *val, int flags)
8923 struct jmploc jmploc;
8924 struct jmploc *volatile savehandler = handler;
8931 if (setjmp(jmploc.loc))
8935 setvar(name, val, flags);
8937 handler = savehandler;
8942 getopts(char *optstr, char *optvar, char **optfirst, int *myoptind,
8950 char **optnext = optfirst + *myoptind - 1;
8952 if (*myoptind <= 1 || *optoff < 0 || !(*(optnext - 1)) ||
8953 strlen(*(optnext - 1)) < *optoff)
8956 p = *(optnext - 1) + *optoff;
8957 if (p == NULL || *p == '\0') {
8958 /* Current word is done, advance */
8959 if (optnext == NULL)
8962 if (p == NULL || *p != '-' || *++p == '\0') {
8964 *myoptind = optnext - optfirst + 1;
8970 if (p[0] == '-' && p[1] == '\0') /* check for "--" */
8975 for (q = optstr; *q != c;) {
8977 if (optstr[0] == ':') {
8980 err |= setvarsafe("OPTARG", s, 0);
8982 out2fmt("Illegal option -%c\n", c);
8983 (void) unsetvar("OPTARG");
8993 if (*p == '\0' && (p = *optnext) == NULL) {
8994 if (optstr[0] == ':') {
8997 err |= setvarsafe("OPTARG", s, 0);
9000 out2fmt("No arg for -%c option\n", c);
9001 (void) unsetvar("OPTARG");
9009 setvarsafe("OPTARG", p, 0);
9012 setvarsafe("OPTARG", "", 0);
9013 *myoptind = optnext - optfirst + 1;
9020 *optoff = p ? p - *(optnext - 1) : -1;
9021 snprintf(s, sizeof(s), "%d", *myoptind);
9022 err |= setvarsafe("OPTIND", s, VNOFUNC);
9025 err |= setvarsafe(optvar, s, 0);
9036 * XXX - should get rid of. have all builtins use getopt(3). the
9037 * library getopt must have the BSD extension static variable "optreset"
9038 * otherwise it can't be used within the shell safely.
9040 * Standard option processing (a la getopt) for builtin routines. The
9041 * only argument that is passed to nextopt is the option string; the
9042 * other arguments are unnecessary. It return the character, or '\0' on
9046 static int nextopt(const char *optstring)
9052 if ((p = optptr) == NULL || *p == '\0') {
9054 if (p == NULL || *p != '-' || *++p == '\0')
9057 if (p[0] == '-' && p[1] == '\0') /* check for "--" */
9061 for (q = optstring; *q != c;) {
9063 error("Illegal option -%c", c);
9068 if (*p == '\0' && (p = *argptr++) == NULL)
9069 error("No arg for -%c option", c);
9077 static void flushall()
9085 static void out2fmt(const char *fmt, ...)
9090 vfprintf(stderr, fmt, ap);
9095 * Version of write which resumes after a signal is caught.
9098 static int xwrite(int fd, const char *buf, int nbytes)
9107 i = write(fd, buf, n);
9113 } else if (i == 0) {
9116 } else if (errno != EINTR) {
9124 * Shell command parser.
9127 #define EOFMARKLEN 79
9132 struct heredoc *next; /* next here document in list */
9133 union node *here; /* redirection node */
9134 char *eofmark; /* string indicating end of input */
9135 int striptabs; /* if set, strip leading tabs */
9138 static struct heredoc *heredoclist; /* list of here documents to read */
9139 static int parsebackquote; /* nonzero if we are inside backquotes */
9140 static int doprompt; /* if set, prompt the user */
9141 static int needprompt; /* true if interactive and at start of line */
9142 static int lasttoken; /* last token read */
9144 static char *wordtext; /* text of last word returned by readtoken */
9146 static struct nodelist *backquotelist;
9147 static union node *redirnode;
9148 static struct heredoc *heredoc;
9149 static int quoteflag; /* set if (part of) last token was quoted */
9150 static int startlinno; /* line # where last token started */
9153 static union node *list(int);
9154 static union node *andor(void);
9155 static union node *pipeline(void);
9156 static union node *command(void);
9157 static union node *simplecmd(union node **rpp, union node *redir);
9158 static void parsefname(void);
9159 static void parseheredoc(void);
9160 static char peektoken(void);
9161 static int readtoken(void);
9162 static int xxreadtoken(void);
9163 static int readtoken1(int, int, const char *, int);
9164 static int noexpand(char *);
9165 static void synexpect(int) __attribute__ ((noreturn));
9166 static void synerror(const char *) __attribute__ ((noreturn));
9167 static void setprompt(int);
9171 * Read and parse a command. Returns NEOF on end of file. (NULL is a
9172 * valid parse tree indicating a blank line.)
9175 static union node *parsecmd(int interact)
9180 doprompt = interact;
9196 static union node *list(int nlflag)
9198 union node *n1, *n2, *n3;
9202 if (nlflag == 0 && peektoken())
9208 if (tok == TBACKGND) {
9209 if (n2->type == NCMD || n2->type == NPIPE) {
9210 n2->ncmd.backgnd = 1;
9211 } else if (n2->type == NREDIR) {
9212 n2->type = NBACKGND;
9214 n3 = (union node *) stalloc(sizeof(struct nredir));
9215 n3->type = NBACKGND;
9217 n3->nredir.redirect = NULL;
9224 n3 = (union node *) stalloc(sizeof(struct nbinary));
9226 n3->nbinary.ch1 = n1;
9227 n3->nbinary.ch2 = n2;
9251 pungetc(); /* push back EOF on input */
9264 static union node *andor()
9266 union node *n1, *n2, *n3;
9272 if ((t = readtoken()) == TAND) {
9274 } else if (t == TOR) {
9282 n3 = (union node *) stalloc(sizeof(struct nbinary));
9284 n3->nbinary.ch1 = n1;
9285 n3->nbinary.ch2 = n2;
9292 static union node *pipeline()
9294 union node *n1, *n2, *pipenode;
9295 struct nodelist *lp, *prev;
9299 TRACE(("pipeline: entered\n"));
9300 if (readtoken() == TNOT) {
9306 if (readtoken() == TPIPE) {
9307 pipenode = (union node *) stalloc(sizeof(struct npipe));
9308 pipenode->type = NPIPE;
9309 pipenode->npipe.backgnd = 0;
9310 lp = (struct nodelist *) stalloc(sizeof(struct nodelist));
9311 pipenode->npipe.cmdlist = lp;
9315 lp = (struct nodelist *) stalloc(sizeof(struct nodelist));
9319 } while (readtoken() == TPIPE);
9325 n2 = (union node *) stalloc(sizeof(struct nnot));
9335 static union node *command(void)
9337 union node *n1, *n2;
9338 union node *ap, **app;
9339 union node *cp, **cpp;
9340 union node *redir, **rpp;
9347 /* Check for redirection which may precede command */
9348 while (readtoken() == TREDIR) {
9349 *rpp = n2 = redirnode;
9350 rpp = &n2->nfile.next;
9355 switch (readtoken()) {
9357 n1 = (union node *) stalloc(sizeof(struct nif));
9359 n1->nif.test = list(0);
9360 if (readtoken() != TTHEN)
9362 n1->nif.ifpart = list(0);
9364 while (readtoken() == TELIF) {
9365 n2->nif.elsepart = (union node *) stalloc(sizeof(struct nif));
9366 n2 = n2->nif.elsepart;
9368 n2->nif.test = list(0);
9369 if (readtoken() != TTHEN)
9371 n2->nif.ifpart = list(0);
9373 if (lasttoken == TELSE)
9374 n2->nif.elsepart = list(0);
9376 n2->nif.elsepart = NULL;
9379 if (readtoken() != TFI)
9386 n1 = (union node *) stalloc(sizeof(struct nbinary));
9387 n1->type = (lasttoken == TWHILE) ? NWHILE : NUNTIL;
9388 n1->nbinary.ch1 = list(0);
9389 if ((got = readtoken()) != TDO) {
9390 TRACE(("expecting DO got %s %s\n", tokname(got),
9391 got == TWORD ? wordtext : ""));
9394 n1->nbinary.ch2 = list(0);
9395 if (readtoken() != TDONE)
9401 if (readtoken() != TWORD || quoteflag || !goodname(wordtext))
9402 synerror("Bad for loop variable");
9403 n1 = (union node *) stalloc(sizeof(struct nfor));
9405 n1->nfor.var = wordtext;
9407 if (readtoken() == TIN) {
9409 while (readtoken() == TWORD) {
9410 n2 = (union node *) stalloc(sizeof(struct narg));
9412 n2->narg.text = wordtext;
9413 n2->narg.backquote = backquotelist;
9415 app = &n2->narg.next;
9419 if (lasttoken != TNL && lasttoken != TSEMI)
9422 static char argvars[5] = { CTLVAR, VSNORMAL | VSQUOTE,
9425 n2 = (union node *) stalloc(sizeof(struct narg));
9427 n2->narg.text = argvars;
9428 n2->narg.backquote = NULL;
9429 n2->narg.next = NULL;
9432 * Newline or semicolon here is optional (but note
9433 * that the original Bourne shell only allowed NL).
9435 if (lasttoken != TNL && lasttoken != TSEMI)
9439 if (readtoken() != TDO)
9441 n1->nfor.body = list(0);
9442 if (readtoken() != TDONE)
9447 n1 = (union node *) stalloc(sizeof(struct ncase));
9449 if (readtoken() != TWORD)
9451 n1->ncase.expr = n2 = (union node *) stalloc(sizeof(struct narg));
9453 n2->narg.text = wordtext;
9454 n2->narg.backquote = backquotelist;
9455 n2->narg.next = NULL;
9458 } while (readtoken() == TNL);
9459 if (lasttoken != TIN)
9460 synerror("expecting \"in\"");
9461 cpp = &n1->ncase.cases;
9462 checkkwd = 2, readtoken();
9464 if (lasttoken == TLP)
9466 *cpp = cp = (union node *) stalloc(sizeof(struct nclist));
9468 app = &cp->nclist.pattern;
9470 *app = ap = (union node *) stalloc(sizeof(struct narg));
9472 ap->narg.text = wordtext;
9473 ap->narg.backquote = backquotelist;
9474 if (checkkwd = 2, readtoken() != TPIPE)
9476 app = &ap->narg.next;
9479 ap->narg.next = NULL;
9480 if (lasttoken != TRP)
9482 cp->nclist.body = list(0);
9485 if ((t = readtoken()) != TESAC) {
9487 synexpect(TENDCASE);
9489 checkkwd = 2, readtoken();
9491 cpp = &cp->nclist.next;
9492 } while (lasttoken != TESAC);
9497 n1 = (union node *) stalloc(sizeof(struct nredir));
9498 n1->type = NSUBSHELL;
9499 n1->nredir.n = list(0);
9500 n1->nredir.redirect = NULL;
9501 if (readtoken() != TRP)
9507 if (readtoken() != TEND)
9511 /* Handle an empty command like other simple commands. */
9520 * An empty command before a ; doesn't make much sense, and
9521 * should certainly be disallowed in the case of `if ;'.
9527 n1 = simplecmd(rpp, redir);
9534 /* Now check for redirection which may follow command */
9535 while (readtoken() == TREDIR) {
9536 *rpp = n2 = redirnode;
9537 rpp = &n2->nfile.next;
9543 if (n1->type != NSUBSHELL) {
9544 n2 = (union node *) stalloc(sizeof(struct nredir));
9549 n1->nredir.redirect = redir;
9556 static union node *simplecmd(union node **rpp, union node *redir)
9558 union node *args, **app;
9559 union node *n = NULL;
9560 union node *vars, **vpp;
9561 union node **orig_rpp;
9568 /* If we don't have any redirections already, then we must reset
9569 rpp to be the address of the local redir variable. */
9572 /* We save the incoming value, because we need this for shell
9573 functions. There can not be a redirect or an argument between
9574 the function name and the open parenthesis. */
9579 switch (readtoken()) {
9582 n = (union node *) stalloc(sizeof(struct narg));
9584 n->narg.text = wordtext;
9585 n->narg.backquote = backquotelist;
9586 if (lasttoken == TWORD) {
9588 app = &n->narg.next;
9591 vpp = &n->narg.next;
9595 *rpp = n = redirnode;
9596 rpp = &n->nfile.next;
9597 parsefname(); /* read name of redirection file */
9600 if (args && app == &args->narg.next && !vars && rpp == orig_rpp) {
9601 /* We have a function */
9602 if (readtoken() != TRP)
9606 n->narg.next = command();
9619 n = (union node *) stalloc(sizeof(struct ncmd));
9621 n->ncmd.backgnd = 0;
9622 n->ncmd.args = args;
9623 n->ncmd.assign = vars;
9624 n->ncmd.redirect = redir;
9628 static union node *makename(void)
9632 n = (union node *) stalloc(sizeof(struct narg));
9634 n->narg.next = NULL;
9635 n->narg.text = wordtext;
9636 n->narg.backquote = backquotelist;
9640 static void fixredir(union node *n, const char *text, int err)
9642 TRACE(("Fix redir %s %d\n", text, err));
9644 n->ndup.vname = NULL;
9646 if (is_digit(text[0]) && text[1] == '\0')
9647 n->ndup.dupfd = digit_val(text[0]);
9648 else if (text[0] == '-' && text[1] == '\0')
9653 synerror("Bad fd number");
9655 n->ndup.vname = makename();
9660 static void parsefname(void)
9662 union node *n = redirnode;
9664 if (readtoken() != TWORD)
9666 if (n->type == NHERE) {
9667 struct heredoc *here = heredoc;
9673 TRACE(("Here document %d\n", n->type));
9674 if (here->striptabs) {
9675 while (*wordtext == '\t')
9678 if (!noexpand(wordtext) || (i = strlen(wordtext)) == 0
9680 synerror("Illegal eof marker for << redirection");
9681 rmescapes(wordtext);
9682 here->eofmark = wordtext;
9684 if (heredoclist == NULL)
9687 for (p = heredoclist; p->next; p = p->next);
9690 } else if (n->type == NTOFD || n->type == NFROMFD) {
9691 fixredir(n, wordtext, 0);
9693 n->nfile.fname = makename();
9699 * Input any here documents.
9702 static void parseheredoc()
9704 struct heredoc *here;
9707 while (heredoclist) {
9709 heredoclist = here->next;
9714 readtoken1(pgetc(), here->here->type == NHERE ? SQSYNTAX : DQSYNTAX,
9715 here->eofmark, here->striptabs);
9716 n = (union node *) stalloc(sizeof(struct narg));
9717 n->narg.type = NARG;
9718 n->narg.next = NULL;
9719 n->narg.text = wordtext;
9720 n->narg.backquote = backquotelist;
9721 here->here->nhere.doc = n;
9725 static char peektoken()
9731 return tokname_array[t][0];
9734 static int readtoken()
9738 int savecheckalias = checkalias;
9740 #ifdef CONFIG_ASH_ALIAS
9741 int savecheckkwd = checkkwd;
9746 int alreadyseen = tokpushback;
9749 #ifdef CONFIG_ASH_ALIAS
9755 checkalias = savecheckalias;
9761 if (checkkwd == 2) {
9770 * check for keywords
9772 if (t == TWORD && !quoteflag) {
9773 const char *const *pp;
9775 if ((pp = findkwd(wordtext))) {
9776 lasttoken = t = pp - tokname_array;
9777 TRACE(("keyword %s recognized\n", tokname(t)));
9788 } else if (checkalias == 2 && isassignment(wordtext)) {
9789 lasttoken = t = TASSIGN;
9790 } else if (checkalias) {
9791 #ifdef CONFIG_ASH_ALIAS
9792 if (!quoteflag && (ap = *__lookupalias(wordtext)) != NULL
9793 && !(ap->flag & ALIASINUSE)) {
9795 pushstring(ap->val, strlen(ap->val), ap);
9797 checkkwd = savecheckkwd;
9806 TRACE(("token %s %s\n", tokname(t), t == TWORD
9807 || t == TASSIGN ? wordtext : ""));
9809 TRACE(("reread token %s %s\n", tokname(t), t == TWORD
9810 || t == TASSIGN ? wordtext : ""));
9817 * Read the next input token.
9818 * If the token is a word, we set backquotelist to the list of cmds in
9819 * backquotes. We set quoteflag to true if any part of the word was
9821 * If the token is TREDIR, then we set redirnode to a structure containing
9823 * In all cases, the variable startlinno is set to the number of the line
9824 * on which the token starts.
9826 * [Change comment: here documents and internal procedures]
9827 * [Readtoken shouldn't have any arguments. Perhaps we should make the
9828 * word parsing code into a separate routine. In this case, readtoken
9829 * doesn't need to have any internal procedures, but parseword does.
9830 * We could also make parseoperator in essence the main routine, and
9831 * have parseword (readtoken1?) handle both words and redirection.]
9834 #define NEW_xxreadtoken
9835 #ifdef NEW_xxreadtoken
9837 static const char xxreadtoken_chars[] = "\n()&|;"; /* singles must be first! */
9838 static const char xxreadtoken_tokens[] = {
9839 TNL, TLP, TRP, /* only single occurrence allowed */
9840 TBACKGND, TPIPE, TSEMI, /* if single occurrence */
9841 TEOF, /* corresponds to trailing nul */
9842 TAND, TOR, TENDCASE, /* if double occurrence */
9845 #define xxreadtoken_doubles \
9846 (sizeof(xxreadtoken_tokens) - sizeof(xxreadtoken_chars))
9847 #define xxreadtoken_singles \
9848 (sizeof(xxreadtoken_chars) - xxreadtoken_doubles - 1)
9850 static int xxreadtoken()
9862 startlinno = plinno;
9863 for (;;) { /* until token or start of word found */
9866 if ((c != ' ') && (c != '\t')
9867 #ifdef CONFIG_ASH_ALIAS
9872 while ((c = pgetc()) != '\n' && c != PEOF);
9874 } else if (c == '\\') {
9875 if (pgetc() != '\n') {
9879 startlinno = ++plinno;
9880 setprompt(doprompt ? 2 : 0);
9883 = xxreadtoken_chars + sizeof(xxreadtoken_chars) - 1;
9888 needprompt = doprompt;
9891 p = strchr(xxreadtoken_chars, c);
9894 return readtoken1(c, BASESYNTAX, (char *) NULL, 0);
9897 if (p - xxreadtoken_chars >= xxreadtoken_singles) {
9898 if (pgetc() == *p) { /* double occurrence? */
9899 p += xxreadtoken_doubles + 1;
9906 return lasttoken = xxreadtoken_tokens[p - xxreadtoken_chars];
9914 #define RETURN(token) return lasttoken = token
9916 static int xxreadtoken()
9928 startlinno = plinno;
9929 for (;;) { /* until token or start of word found */
9934 #ifdef CONFIG_ASH_ALIAS
9939 while ((c = pgetc()) != '\n' && c != PEOF);
9943 if (pgetc() == '\n') {
9944 startlinno = ++plinno;
9955 needprompt = doprompt;
9983 return readtoken1(c, BASESYNTAX, (char *) NULL, 0);
9989 * If eofmark is NULL, read a word or a redirection symbol. If eofmark
9990 * is not NULL, read a here document. In the latter case, eofmark is the
9991 * word which marks the end of the document and striptabs is true if
9992 * leading tabs should be stripped from the document. The argument firstc
9993 * is the first character of the input token or document.
9995 * Because C does not have internal subroutines, I have simulated them
9996 * using goto's to implement the subroutine linkage. The following macros
9997 * will run code that appears at the end of readtoken1.
10000 #define CHECKEND() {goto checkend; checkend_return:;}
10001 #define PARSEREDIR() {goto parseredir; parseredir_return:;}
10002 #define PARSESUB() {goto parsesub; parsesub_return:;}
10003 #define PARSEBACKQOLD() {oldstyle = 1; goto parsebackq; parsebackq_oldreturn:;}
10004 #define PARSEBACKQNEW() {oldstyle = 0; goto parsebackq; parsebackq_newreturn:;}
10005 #define PARSEARITH() {goto parsearith; parsearith_return:;}
10008 readtoken1(int firstc, int syntax, const char *eofmark, int striptabs)
10013 char line[EOFMARKLEN + 1];
10014 struct nodelist *bqlist;
10017 int varnest; /* levels of variables expansion */
10018 int arinest; /* levels of arithmetic expansion */
10019 int parenlevel; /* levels of parens in arithmetic */
10020 int dqvarnest; /* levels of variables expansion within double quotes */
10022 int prevsyntax; /* syntax before arithmetic */
10025 /* Avoid longjmp clobbering */
10031 (void) &parenlevel;
10034 (void) &prevsyntax;
10038 startlinno = plinno;
10040 if (syntax == DQSYNTAX)
10049 STARTSTACKSTR(out);
10050 loop:{ /* for each line, until end of word */
10051 CHECKEND(); /* set c to PEOF if at end of here document */
10052 for (;;) { /* until end of line or end of word */
10053 CHECKSTRSPACE(3, out); /* permit 3 calls to USTPUTC */
10054 switch (SIT(c, syntax)) {
10055 case CNL: /* '\n' */
10056 if (syntax == BASESYNTAX)
10057 goto endword; /* exit outer loop */
10065 goto loop; /* continue outer loop */
10070 if ((eofmark == NULL || dblquote) && dqvarnest == 0)
10071 USTPUTC(CTLESC, out);
10074 case CBACK: /* backslash */
10077 USTPUTC('\\', out);
10079 } else if (c == '\n') {
10085 if (dblquote && c != '\\' && c != '`' && c != '$'
10086 && (c != '"' || eofmark != NULL))
10087 USTPUTC('\\', out);
10088 if (SIT(c, SQSYNTAX) == CCTL)
10089 USTPUTC(CTLESC, out);
10090 else if (eofmark == NULL)
10091 USTPUTC(CTLQUOTEMARK, out);
10097 if (eofmark == NULL)
10098 USTPUTC(CTLQUOTEMARK, out);
10102 if (eofmark == NULL)
10103 USTPUTC(CTLQUOTEMARK, out);
10108 if (eofmark != NULL && arinest == 0 && varnest == 0) {
10112 syntax = ARISYNTAX;
10114 } else if (eofmark == NULL && dqvarnest == 0) {
10115 syntax = BASESYNTAX;
10121 case CVAR: /* '$' */
10122 PARSESUB(); /* parse substitution */
10124 case CENDVAR: /* '}' */
10127 if (dqvarnest > 0) {
10130 USTPUTC(CTLENDVAR, out);
10135 #ifdef CONFIG_ASH_MATH_SUPPORT
10136 case CLP: /* '(' in arithmetic */
10140 case CRP: /* ')' in arithmetic */
10141 if (parenlevel > 0) {
10145 if (pgetc() == ')') {
10146 if (--arinest == 0) {
10147 USTPUTC(CTLENDARI, out);
10148 syntax = prevsyntax;
10149 if (syntax == DQSYNTAX)
10157 * unbalanced parens
10158 * (don't 2nd guess - no error)
10166 case CBQUOTE: /* '`' */
10170 goto endword; /* exit outer loop */
10175 goto endword; /* exit outer loop */
10176 #ifdef CONFIG_ASH_ALIAS
10186 if (syntax == ARISYNTAX)
10187 synerror("Missing '))'");
10188 if (syntax != BASESYNTAX && !parsebackquote && eofmark == NULL)
10189 synerror("Unterminated quoted string");
10190 if (varnest != 0) {
10191 startlinno = plinno;
10192 synerror("Missing '}'");
10194 USTPUTC('\0', out);
10195 len = out - stackblock();
10196 out = stackblock();
10197 if (eofmark == NULL) {
10198 if ((c == '>' || c == '<')
10199 && quotef == 0 && len <= 2 && (*out == '\0' || is_digit(*out))) {
10201 return lasttoken = TREDIR;
10206 quoteflag = quotef;
10207 backquotelist = bqlist;
10208 grabstackblock(len);
10210 return lasttoken = TWORD;
10211 /* end of readtoken routine */
10216 * Check to see whether we are at the end of the here document. When this
10217 * is called, c is set to the first character of the next input line. If
10218 * we are at the end of the here document, this routine sets the c to PEOF.
10223 #ifdef CONFIG_ASH_ALIAS
10229 while (c == '\t') {
10233 if (c == *eofmark) {
10234 if (pfgets(line, sizeof line) != NULL) {
10238 for (q = eofmark + 1; *q && *p == *q; p++, q++);
10239 if (*p == '\n' && *q == '\0') {
10242 needprompt = doprompt;
10244 pushstring(line, strlen(line), NULL);
10249 goto checkend_return;
10254 * Parse a redirection operator. The variable "out" points to a string
10255 * specifying the fd to be redirected. The variable "c" contains the
10256 * first character of the redirection operator.
10263 np = (union node *) stalloc(sizeof(struct nfile));
10268 np->type = NAPPEND;
10277 } else { /* c == '<' */
10279 switch (c = pgetc()) {
10281 if (sizeof(struct nfile) != sizeof(struct nhere)) {
10282 np = (union node *) stalloc(sizeof(struct nhere));
10286 heredoc = (struct heredoc *) stalloc(sizeof(struct heredoc));
10287 heredoc->here = np;
10288 if ((c = pgetc()) == '-') {
10289 heredoc->striptabs = 1;
10291 heredoc->striptabs = 0;
10297 np->type = NFROMFD;
10301 np->type = NFROMTO;
10311 np->nfile.fd = digit_val(fd);
10313 goto parseredir_return;
10318 * Parse a substitution. At this point, we have read the dollar sign
10319 * and nothing else.
10327 static const char types[] = "}-+?=";
10331 (c != '(' && c != '{' && !is_name(c) && !is_special(c))
10335 } else if (c == '(') { /* $(command) or $((arith)) */
10336 if (pgetc() == '(') {
10343 USTPUTC(CTLVAR, out);
10344 typeloc = out - stackblock();
10345 USTPUTC(VSNORMAL, out);
10346 subtype = VSNORMAL;
10350 if ((c = pgetc()) == '}')
10353 subtype = VSLENGTH;
10357 if (c > PEOA && is_name(c)) {
10361 } while (c > PEOA && is_in_name(c));
10362 } else if (is_digit(c)) {
10366 } while (is_digit(c));
10367 } else if (is_special(c)) {
10371 badsub:synerror("Bad substitution");
10375 if (subtype == 0) {
10380 /*FALLTHROUGH*/ default:
10381 p = strchr(types, c);
10384 subtype = p - types + VSNORMAL;
10391 subtype = c == '#' ? VSTRIMLEFT : VSTRIMRIGHT;
10403 if (dblquote || arinest)
10405 *(stackblock() + typeloc) = subtype | flags;
10406 if (subtype != VSNORMAL) {
10413 goto parsesub_return;
10418 * Called to parse command substitutions. Newstyle is set if the command
10419 * is enclosed inside $(...); nlpp is a pointer to the head of the linked
10420 * list of commands (passed by reference), and savelen is the number of
10421 * characters on the top of the stack which must be preserved.
10425 struct nodelist **nlpp;
10428 char *volatile str;
10429 struct jmploc jmploc;
10430 struct jmploc *volatile savehandler;
10435 (void) &saveprompt;
10438 savepbq = parsebackquote;
10439 if (setjmp(jmploc.loc)) {
10441 parsebackquote = 0;
10442 handler = savehandler;
10443 longjmp(handler->loc, 1);
10447 savelen = out - stackblock();
10449 str = xmalloc(savelen);
10450 memcpy(str, stackblock(), savelen);
10452 savehandler = handler;
10456 /* We must read until the closing backquote, giving special
10457 treatment to some slashes, and then push the string and
10458 reread it as input, interpreting it normally. */
10465 STARTSTACKSTR(pout);
10471 switch (pc = pgetc()) {
10476 if ((pc = pgetc()) == '\n') {
10483 * If eating a newline, avoid putting
10484 * the newline into the new character
10485 * stream (via the STPUTC after the
10490 if (pc != '\\' && pc != '`' && pc != '$'
10491 && (!dblquote || pc != '"'))
10492 STPUTC('\\', pout);
10499 #ifdef CONFIG_ASH_ALIAS
10502 startlinno = plinno;
10503 synerror("EOF in backquote substitution");
10507 needprompt = doprompt;
10516 STPUTC('\0', pout);
10517 psavelen = pout - stackblock();
10518 if (psavelen > 0) {
10519 pstr = grabstackstr(pout);
10520 setinputstring(pstr);
10525 nlpp = &(*nlpp)->next;
10526 *nlpp = (struct nodelist *) stalloc(sizeof(struct nodelist));
10527 (*nlpp)->next = NULL;
10528 parsebackquote = oldstyle;
10531 saveprompt = doprompt;
10538 doprompt = saveprompt;
10540 if (readtoken() != TRP)
10547 * Start reading from old file again, ignoring any pushed back
10548 * tokens left from the backquote parsing
10553 while (stackblocksize() <= savelen)
10555 STARTSTACKSTR(out);
10557 memcpy(out, str, savelen);
10558 STADJUST(savelen, out);
10564 parsebackquote = savepbq;
10565 handler = savehandler;
10566 if (arinest || dblquote)
10567 USTPUTC(CTLBACKQ | CTLQUOTE, out);
10569 USTPUTC(CTLBACKQ, out);
10571 goto parsebackq_oldreturn;
10573 goto parsebackq_newreturn;
10577 * Parse an arithmetic expansion (indicate start of one and set state)
10581 if (++arinest == 1) {
10582 prevsyntax = syntax;
10583 syntax = ARISYNTAX;
10584 USTPUTC(CTLARI, out);
10591 * we collapse embedded arithmetic expansion to
10592 * parenthesis, which should be equivalent
10596 goto parsearith_return;
10599 } /* end of readtoken */
10603 * Returns true if the text contains nothing to expand (no dollar signs
10607 static int noexpand(char *text)
10613 while ((c = *p++) != '\0') {
10614 if (c == CTLQUOTEMARK)
10618 else if (SIT(c, BASESYNTAX) == CCTL)
10626 * Return true if the argument is a legal variable name (a letter or
10627 * underscore followed by zero or more letters, underscores, and digits).
10630 static int goodname(const char *name)
10638 if (!is_in_name(*p))
10646 * Called when an unexpected token is read during the parse. The argument
10647 * is the token that is expected, or -1 if more than one type of token can
10648 * occur at this point.
10651 static void synexpect(int token)
10656 l = sprintf(msg, "%s unexpected", tokname(lasttoken));
10658 sprintf(msg + l, " (expecting %s)", tokname(token));
10664 static void synerror(const char *msg)
10667 out2fmt("%s: %d: ", commandname, startlinno);
10668 out2fmt("Syntax error: %s\n", msg);
10669 error((char *) NULL);
10675 * called by editline -- any expansions to the prompt
10676 * should be added here.
10678 static void setprompt(int whichprompt)
10682 switch (whichprompt) {
10697 * Code for dealing with input/output redirection.
10700 #define EMPTY -2 /* marks an unused slot in redirtab */
10702 # define PIPESIZE 4096 /* amount of buffering in a pipe */
10704 # define PIPESIZE PIPE_BUF
10709 * Open a file in noclobber mode.
10710 * The code was copied from bash.
10712 static inline int noclobberopen(const char *fname)
10715 struct stat finfo, finfo2;
10718 * If the file exists and is a regular file, return an error
10721 r = stat(fname, &finfo);
10722 if (r == 0 && S_ISREG(finfo.st_mode)) {
10728 * If the file was not present (r != 0), make sure we open it
10729 * exclusively so that if it is created before we open it, our open
10730 * will fail. Make sure that we do not truncate an existing file.
10731 * Note that we don't turn on O_EXCL unless the stat failed -- if the
10732 * file was not a regular file, we leave O_EXCL off.
10735 return open(fname, O_WRONLY | O_CREAT | O_EXCL, 0666);
10736 fd = open(fname, O_WRONLY | O_CREAT, 0666);
10738 /* If the open failed, return the file descriptor right away. */
10743 * OK, the open succeeded, but the file may have been changed from a
10744 * non-regular file to a regular file between the stat and the open.
10745 * We are assuming that the O_EXCL open handles the case where FILENAME
10746 * did not exist and is symlinked to an existing file between the stat
10751 * If we can open it and fstat the file descriptor, and neither check
10752 * revealed that it was a regular file, and the file has not been
10753 * replaced, return the file descriptor.
10755 if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode) &&
10756 finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino)
10759 /* The file has been replaced. badness. */
10766 * Handle here documents. Normally we fork off a process to write the
10767 * data to a pipe. If the document is short, we can stuff the data in
10768 * the pipe without forking.
10771 static inline int openhere(const union node *redir)
10777 error("Pipe call failed");
10778 if (redir->type == NHERE) {
10779 len = strlen(redir->nhere.doc->narg.text);
10780 if (len <= PIPESIZE) {
10781 xwrite(pip[1], redir->nhere.doc->narg.text, len);
10785 if (forkshell((struct job *) NULL, (union node *) NULL, FORK_NOJOB) == 0) {
10787 signal(SIGINT, SIG_IGN);
10788 signal(SIGQUIT, SIG_IGN);
10789 signal(SIGHUP, SIG_IGN);
10791 signal(SIGTSTP, SIG_IGN);
10793 signal(SIGPIPE, SIG_DFL);
10794 if (redir->type == NHERE)
10795 xwrite(pip[1], redir->nhere.doc->narg.text, len);
10797 expandhere(redir->nhere.doc, pip[1]);
10806 static inline int openredirect(const union node *redir)
10811 switch (redir->nfile.type) {
10813 fname = redir->nfile.expfname;
10814 if ((f = open(fname, O_RDONLY)) < 0)
10818 fname = redir->nfile.expfname;
10819 if ((f = open(fname, O_RDWR | O_CREAT | O_TRUNC, 0666)) < 0)
10823 /* Take care of noclobber mode. */
10825 fname = redir->nfile.expfname;
10826 if ((f = noclobberopen(fname)) < 0)
10831 fname = redir->nfile.expfname;
10833 if ((f = open(fname, O_WRONLY | O_CREAT | O_TRUNC, 0666)) < 0)
10836 if ((f = creat(fname, 0666)) < 0)
10841 fname = redir->nfile.expfname;
10843 if ((f = open(fname, O_WRONLY | O_CREAT | O_APPEND, 0666)) < 0)
10846 if ((f = open(fname, O_WRONLY)) < 0 && (f = creat(fname, 0666)) < 0)
10848 lseek(f, (off_t) 0, 2);
10855 /* Fall through to eliminate warning. */
10862 f = openhere(redir);
10868 error("cannot create %s: %s", fname, errmsg(errno, E_CREAT));
10870 error("cannot open %s: %s", fname, errmsg(errno, E_OPEN));
10875 * Process a list of redirection commands. If the REDIR_PUSH flag is set,
10876 * old file descriptors are stashed away so that the redirection can be
10877 * undone by calling popredir. If the REDIR_BACKQ flag is set, then the
10878 * standard output, and the standard error if it becomes a duplicate of
10882 static void redirect(union node *redir, int flags)
10885 struct redirtab *sv = NULL;
10890 int fd1dup = flags & REDIR_BACKQ;; /* stdout `cmd` redir to pipe */
10892 TRACE(("redirect(%s) called\n",
10893 flags & REDIR_PUSH ? "REDIR_PUSH" : "NO_REDIR_PUSH"));
10894 if (flags & REDIR_PUSH) {
10895 sv = xmalloc(sizeof(struct redirtab));
10896 for (i = 0; i < 10; i++)
10897 sv->renamed[i] = EMPTY;
10898 sv->next = redirlist;
10901 for (n = redir; n; n = n->nfile.next) {
10904 if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD) &&
10905 n->ndup.dupfd == fd)
10906 continue; /* redirect from/to same file descriptor */
10909 newfd = openredirect(n);
10910 if ((flags & REDIR_PUSH) && sv->renamed[fd] == EMPTY) {
10914 } else if ((i = fcntl(fd, F_DUPFD, 10)) == -1) {
10918 dupredirect(n, newfd, fd1dup);
10928 error("%d: %m", fd);
10934 if (flags & REDIR_PUSH) {
10935 sv->renamed[fd] = i;
10938 } else if (fd != newfd) {
10944 dupredirect(n, newfd, fd1dup);
10950 static void dupredirect(const union node *redir, int f, int fd1dup)
10952 int fd = redir->nfile.fd;
10956 if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) {
10957 if (redir->ndup.dupfd >= 0) { /* if not ">&-" */
10958 if (redir->ndup.dupfd != 1 || fd1dup != 1)
10959 dup_as_newfd(redir->ndup.dupfd, fd);
10965 dup_as_newfd(f, fd);
10974 * Undo the effects of the last redirection.
10977 static void popredir(void)
10979 struct redirtab *rp = redirlist;
10983 for (i = 0; i < 10; i++) {
10984 if (rp->renamed[i] != EMPTY) {
10988 if (rp->renamed[i] >= 0) {
10989 dup_as_newfd(rp->renamed[i], i);
10990 close(rp->renamed[i]);
10994 redirlist = rp->next;
11000 * Discard all saved file descriptors.
11003 static void clearredir(void)
11005 struct redirtab *rp;
11008 for (rp = redirlist; rp; rp = rp->next) {
11009 for (i = 0; i < 10; i++) {
11010 if (rp->renamed[i] >= 0) {
11011 close(rp->renamed[i]);
11013 rp->renamed[i] = EMPTY;
11020 * Copy a file descriptor to be >= to. Returns -1
11021 * if the source file descriptor is closed, EMPTY if there are no unused
11022 * file descriptors left.
11025 static int dup_as_newfd(int from, int to)
11029 newfd = fcntl(from, F_DUPFD, to);
11031 if (errno == EMFILE)
11034 error("%d: %m", from);
11044 static void shtree(union node *, int, char *, FILE *);
11045 static void shcmd(union node *, FILE *);
11046 static void sharg(union node *, FILE *);
11047 static void indent(int, char *, FILE *);
11048 static void trstring(char *);
11052 static void showtree(node * n)
11054 trputs("showtree called\n");
11055 shtree(n, 1, NULL, stdout);
11059 static void shtree(union node *n, int ind, char *pfx, FILE * fp)
11061 struct nodelist *lp;
11067 indent(ind, pfx, fp);
11078 shtree(n->nbinary.ch1, ind, NULL, fp);
11081 shtree(n->nbinary.ch2, ind, NULL, fp);
11089 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
11094 if (n->npipe.backgnd)
11100 fprintf(fp, "<node type %d>", n->type);
11108 static void shcmd(union node *cmd, FILE * fp)
11116 for (np = cmd->ncmd.args; np; np = np->narg.next) {
11122 for (np = cmd->ncmd.redirect; np; np = np->nfile.next) {
11128 if ((np->nfile.type <= NFROMFD) && (np->nfile.type >= NTO)) {
11129 s = redir_strings[np->nfile.type - NTO];
11135 switch (np->nfile.type) {
11170 if (np->nfile.fd != dftfd)
11171 fprintf(fp, "%d", np->nfile.fd);
11173 if (np->nfile.type == NTOFD || np->nfile.type == NFROMFD) {
11174 fprintf(fp, "%d", np->ndup.dupfd);
11176 sharg(np->nfile.fname, fp);
11183 static void sharg(union node *arg, FILE * fp)
11186 struct nodelist *bqlist;
11189 if (arg->type != NARG) {
11190 printf("<node type %d>\n", arg->type);
11194 bqlist = arg->narg.backquote;
11195 for (p = arg->narg.text; *p; p++) {
11204 if (subtype == VSLENGTH)
11210 if (subtype & VSNUL)
11213 switch (subtype & VSTYPE) {
11232 case VSTRIMLEFTMAX:
11239 case VSTRIMRIGHTMAX:
11246 printf("<subtype %d>", subtype);
11253 case CTLBACKQ | CTLQUOTE:
11256 shtree(bqlist->n, -1, NULL, fp);
11267 static void indent(int amount, char *pfx, FILE * fp)
11271 for (i = 0; i < amount; i++) {
11272 if (pfx && i == amount - 1)
11281 static int debug = 1;
11283 static int debug = 0;
11287 static void trputc(int c)
11289 if (tracefile == NULL)
11291 putc(c, tracefile);
11296 static void trace(const char *fmt, ...)
11301 if (tracefile != NULL) {
11302 (void) vfprintf(tracefile, fmt, va);
11303 if (strchr(fmt, '\n'))
11304 (void) fflush(tracefile);
11310 static void trputs(const char *s)
11312 if (tracefile == NULL)
11314 fputs(s, tracefile);
11315 if (strchr(s, '\n'))
11320 static void trstring(char *s)
11325 if (tracefile == NULL)
11327 putc('"', tracefile);
11328 for (p = s; *p; p++) {
11351 case CTLVAR + CTLQUOTE:
11357 case CTLBACKQ + CTLQUOTE:
11360 backslash:putc('\\', tracefile);
11361 putc(c, tracefile);
11364 if (*p >= ' ' && *p <= '~')
11365 putc(*p, tracefile);
11367 putc('\\', tracefile);
11368 putc(*p >> 6 & 03, tracefile);
11369 putc(*p >> 3 & 07, tracefile);
11370 putc(*p & 07, tracefile);
11375 putc('"', tracefile);
11379 static void trargs(char **ap)
11381 if (tracefile == NULL)
11386 putc(' ', tracefile);
11388 putc('\n', tracefile);
11394 static void opentrace()
11404 #ifdef not_this_way
11408 if ((p = getenv("HOME")) == NULL) {
11409 if (geteuid() == 0)
11415 strcat(s, "/trace");
11418 strcpy(s, "./trace");
11419 #endif /* not_this_way */
11420 if ((tracefile = wfopen(s, "a")) == NULL)
11423 if ((flags = fcntl(fileno(tracefile), F_GETFL, 0)) >= 0)
11424 fcntl(fileno(tracefile), F_SETFL, flags | O_APPEND);
11426 fputs("\nTracing started.\n", tracefile);
11433 * The trap builtin.
11436 static int trapcmd(int argc, char **argv)
11443 for (signo = 0; signo < NSIG; signo++) {
11444 if (trap[signo] != NULL) {
11448 p = single_quote(trap[signo]);
11449 sn = sys_siglist[signo];
11451 sn = u_signal_names(0, &signo, 0);
11454 printf("trap -- %s %s\n", p, sn);
11466 if ((signo = decode_signal(*ap, 0)) < 0)
11467 error("%s: bad trap", *ap);
11470 if (action[0] == '-' && action[1] == '\0')
11473 action = xstrdup(action);
11476 trap[signo] = action;
11487 * Set the signal handler for the specified signal. The routine figures
11488 * out what it should be set to.
11491 static void setsignal(int signo)
11495 struct sigaction act;
11497 if ((t = trap[signo]) == NULL)
11499 else if (*t != '\0')
11503 if (rootshell && action == S_DFL) {
11506 if (iflag || minusc || sflag == 0)
11522 #ifdef CONFIG_ASH_JOB_CONTROL
11532 t = &sigmode[signo - 1];
11535 * current setting unknown
11537 if (sigaction(signo, 0, &act) == -1) {
11539 * Pretend it worked; maybe we should give a warning
11540 * here, but other shells don't. We don't alter
11541 * sigmode, so that we retry every time.
11545 if (act.sa_handler == SIG_IGN) {
11546 if (mflag && (signo == SIGTSTP ||
11547 signo == SIGTTIN || signo == SIGTTOU)) {
11548 *t = S_IGN; /* don't hard ignore these */
11552 *t = S_RESET; /* force to be set */
11555 if (*t == S_HARD_IGN || *t == action)
11557 act.sa_handler = ((action == S_CATCH) ? onsig
11558 : ((action == S_IGN) ? SIG_IGN : SIG_DFL));
11561 sigemptyset(&act.sa_mask);
11562 sigaction(signo, &act, 0);
11569 static void ignoresig(int signo)
11571 if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
11572 signal(signo, SIG_IGN);
11574 sigmode[signo - 1] = S_HARD_IGN;
11582 static void onsig(int signo)
11584 if (signo == SIGINT && trap[SIGINT] == NULL) {
11588 gotsig[signo - 1] = 1;
11594 * Called to execute a trap. Perhaps we should avoid entering new trap
11595 * handlers while we are executing a trap handler.
11598 static void dotrap(void)
11604 for (i = 1;; i++) {
11611 savestatus = exitstatus;
11612 evalstring(trap[i], 0);
11613 exitstatus = savestatus;
11620 * Called to exit the shell.
11623 static void exitshell(int status)
11625 struct jmploc loc1, loc2;
11628 TRACE(("exitshell(%d) pid=%d\n", status, getpid()));
11629 if (setjmp(loc1.loc)) {
11632 if (setjmp(loc2.loc)) {
11636 if ((p = trap[0]) != NULL && *p != '\0') {
11641 handler = &loc2; /* probably unnecessary */
11643 #ifdef CONFIG_ASH_JOB_CONTROL
11646 #ifdef CONFIG_FEATURE_COMMAND_SAVEHISTORY
11647 if (iflag && rootshell) {
11648 const char *hp = lookupvar("HISTFILE");
11651 save_history ( hp );
11659 static int decode_signal(const char *string, int minsig)
11662 const char *name = u_signal_names(string, &signo, minsig);
11664 return name ? signo : -1;
11667 static struct var **hashvar(const char *);
11668 static void showvars(const char *, int, int);
11669 static struct var **findvar(struct var **, const char *);
11672 * Initialize the varable symbol tables and import the environment
11676 * This routine initializes the builtin variables. It is called when the
11677 * shell is initialized and again when a shell procedure is spawned.
11680 static void initvar()
11682 const struct varinit *ip;
11686 for (ip = varinit; (vp = ip->var) != NULL; ip++) {
11687 if ((vp->flags & VEXPORT) == 0) {
11688 vpp = hashvar(ip->text);
11691 vp->text = xstrdup(ip->text);
11692 vp->flags = ip->flags;
11693 vp->func = ip->func;
11696 #if !defined(CONFIG_FEATURE_COMMAND_EDITING) || !defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
11698 * PS1 depends on uid
11700 if ((vps1.flags & VEXPORT) == 0) {
11701 vpp = hashvar("PS1=$ ");
11704 vps1.text = xstrdup(geteuid()? "PS1=$ " : "PS1=# ");
11705 vps1.flags = VSTRFIXED | VTEXTFIXED;
11711 * Set the value of a variable. The flags argument is ored with the
11712 * flags of the variable. If val is NULL, the variable is unset.
11715 static void setvar(const char *name, const char *val, int flags)
11730 if (!is_in_name(*p)) {
11731 if (*p == '\0' || *p == '=')
11737 namelen = p - name;
11739 error("%.*s: bad variable name", namelen, name);
11740 len = namelen + 2; /* 2 is space for '=' and '\0' */
11744 len += vallen = strlen(val);
11747 nameeq = xmalloc(len);
11748 memcpy(nameeq, name, namelen);
11749 nameeq[namelen] = '=';
11751 memcpy(nameeq + namelen + 1, val, vallen + 1);
11753 nameeq[namelen + 1] = '\0';
11755 setvareq(nameeq, flags);
11762 * Same as setvar except that the variable and value are passed in
11763 * the first argument as name=value. Since the first argument will
11764 * be actually stored in the table, it should not be a string that
11768 static void setvareq(char *s, int flags)
11770 struct var *vp, **vpp;
11773 flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1));
11774 if ((vp = *findvar(vpp, s))) {
11775 if (vp->flags & VREADONLY) {
11776 size_t len = strchr(s, '=') - s;
11778 error("%.*s: is read only", len, s);
11782 if (vp->func && (flags & VNOFUNC) == 0)
11783 (*vp->func) (strchr(s, '=') + 1);
11785 if ((vp->flags & (VTEXTFIXED | VSTACK)) == 0)
11788 vp->flags &= ~(VTEXTFIXED | VSTACK | VUNSET);
11789 vp->flags |= flags;
11792 #ifdef CONFIG_ASH_MAIL
11794 * We could roll this to a function, to handle it as
11795 * a regular variable function callback, but why bother?
11797 if (iflag && (vp == &vmpath || (vp == &vmail && !mpathset())))
11804 vp = xmalloc(sizeof(*vp));
11815 * Process a linked list of variable assignments.
11818 static void listsetvar(struct strlist *mylist)
11820 struct strlist *lp;
11823 for (lp = mylist; lp; lp = lp->next) {
11824 setvareq(xstrdup(lp->text), 0);
11832 * Find the value of a variable. Returns NULL if not set.
11835 static const char *lookupvar(const char *name)
11839 if ((v = *findvar(hashvar(name), name)) && !(v->flags & VUNSET)) {
11840 return strchr(v->text, '=') + 1;
11848 * Search the environment of a builtin command.
11851 static const char *bltinlookup(const char *name)
11853 const struct strlist *sp;
11855 for (sp = cmdenviron; sp; sp = sp->next) {
11856 if (varequal(sp->text, name))
11857 return strchr(sp->text, '=') + 1;
11859 return lookupvar(name);
11865 * Generate a list of exported variables. This routine is used to construct
11866 * the third argument to execve when executing a program.
11869 static char **environment()
11878 for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
11879 for (vp = *vpp; vp; vp = vp->next)
11880 if (vp->flags & VEXPORT)
11883 ep = env = stalloc((nenv + 1) * sizeof *env);
11884 for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
11885 for (vp = *vpp; vp; vp = vp->next)
11886 if (vp->flags & VEXPORT)
11895 * Command to list all variables which are set. Currently this command
11896 * is invoked from the set command when the set command is called without
11900 static int showvarscmd(int argc, char **argv)
11902 showvars(nullstr, VUNSET, VUNSET);
11909 * The export and readonly commands.
11912 static int exportcmd(int argc, char **argv)
11917 int flag = argv[0][0] == 'r' ? VREADONLY : VEXPORT;
11920 listsetvar(cmdenviron);
11921 pflag = (nextopt("p") == 'p');
11922 if (argc > 1 && !pflag) {
11923 while ((name = *argptr++) != NULL) {
11924 if ((p = strchr(name, '=')) != NULL) {
11927 if ((vp = *findvar(hashvar(name), name))) {
11932 setvar(name, p, flag);
11936 showvars(argv[0], flag, 0);
11943 * The "local" command.
11946 /* funcnest nonzero if we are currently evaluating a function */
11948 static int localcmd(int argc, char **argv)
11953 error("Not in a function");
11954 while ((name = *argptr++) != NULL) {
11962 * Make a variable a local variable. When a variable is made local, it's
11963 * value and flags are saved in a localvar structure. The saved values
11964 * will be restored when the shell function returns. We handle the name
11965 * "-" as a special case.
11968 static void mklocal(char *name)
11970 struct localvar *lvp;
11975 lvp = xmalloc(sizeof(struct localvar));
11976 if (name[0] == '-' && name[1] == '\0') {
11979 p = xmalloc(sizeof optet_vals);
11980 lvp->text = memcpy(p, optet_vals, sizeof optet_vals);
11983 vpp = hashvar(name);
11984 vp = *findvar(vpp, name);
11986 if (strchr(name, '='))
11987 setvareq(xstrdup(name), VSTRFIXED);
11989 setvar(name, NULL, VSTRFIXED);
11990 vp = *vpp; /* the new variable */
11992 lvp->flags = VUNSET;
11994 lvp->text = vp->text;
11995 lvp->flags = vp->flags;
11996 vp->flags |= VSTRFIXED | VTEXTFIXED;
11997 if (strchr(name, '='))
11998 setvareq(xstrdup(name), 0);
12002 lvp->next = localvars;
12009 * Called after a function returns.
12012 static void poplocalvars()
12014 struct localvar *lvp;
12017 while ((lvp = localvars) != NULL) {
12018 localvars = lvp->next;
12020 if (vp == NULL) { /* $- saved */
12021 memcpy(optet_vals, lvp->text, sizeof optet_vals);
12023 } else if ((lvp->flags & (VUNSET | VSTRFIXED)) == VUNSET) {
12024 (void) unsetvar(vp->text);
12026 if ((vp->flags & VTEXTFIXED) == 0)
12028 vp->flags = lvp->flags;
12029 vp->text = lvp->text;
12036 static int setvarcmd(int argc, char **argv)
12039 return unsetcmd(argc, argv);
12040 else if (argc == 3)
12041 setvar(argv[1], argv[2], 0);
12043 error("List assignment not implemented");
12049 * The unset builtin command. We unset the function before we unset the
12050 * variable to allow a function to be unset when there is a readonly variable
12051 * with the same name.
12054 static int unsetcmd(int argc, char **argv)
12062 while ((i = nextopt("vf")) != '\0') {
12068 if (flg_func == 0 && flg_var == 0)
12071 for (ap = argptr; *ap; ap++) {
12075 ret |= unsetvar(*ap);
12082 * Unset the specified variable.
12085 static int unsetvar(const char *s)
12090 vpp = findvar(hashvar(s), s);
12093 if (vp->flags & VREADONLY)
12096 if (*(strchr(vp->text, '=') + 1) != '\0')
12097 setvar(s, nullstr, 0);
12098 vp->flags &= ~VEXPORT;
12099 vp->flags |= VUNSET;
12100 if ((vp->flags & VSTRFIXED) == 0) {
12101 if ((vp->flags & VTEXTFIXED) == 0)
12116 * Find the appropriate entry in the hash table from the name.
12119 static struct var **hashvar(const char *p)
12121 unsigned int hashval;
12123 hashval = ((unsigned char) *p) << 4;
12124 while (*p && *p != '=')
12125 hashval += (unsigned char) *p++;
12126 return &vartab[hashval % VTABSIZE];
12132 * Returns true if the two strings specify the same varable. The first
12133 * variable name is terminated by '='; the second may be terminated by
12134 * either '=' or '\0'.
12137 static int varequal(const char *p, const char *q)
12139 while (*p == *q++) {
12143 if (*p == '=' && *(q - 1) == '\0')
12148 static void showvars(const char *myprefix, int mask, int xor)
12152 const char *sep = myprefix == nullstr ? myprefix : spcstr;
12154 for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
12155 for (vp = *vpp; vp; vp = vp->next) {
12156 if ((vp->flags & mask) ^ xor) {
12160 p = strchr(vp->text, '=') + 1;
12161 len = p - vp->text;
12162 p = single_quote(p);
12164 printf("%s%s%.*s%s\n", myprefix, sep, len, vp->text, p);
12171 static struct var **findvar(struct var **vpp, const char *name)
12173 for (; *vpp; vpp = &(*vpp)->next) {
12174 if (varequal((*vpp)->text, name)) {
12182 * Copyright (c) 1999 Herbert Xu <herbert@debian.org>
12183 * This file contains code for the times builtin.
12185 static int timescmd(int argc, char **argv)
12188 long int clk_tck = sysconf(_SC_CLK_TCK);
12191 printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n",
12192 (int) (buf.tms_utime / clk_tck / 60),
12193 ((double) buf.tms_utime) / clk_tck,
12194 (int) (buf.tms_stime / clk_tck / 60),
12195 ((double) buf.tms_stime) / clk_tck,
12196 (int) (buf.tms_cutime / clk_tck / 60),
12197 ((double) buf.tms_cutime) / clk_tck,
12198 (int) (buf.tms_cstime / clk_tck / 60),
12199 ((double) buf.tms_cstime) / clk_tck);
12203 #ifdef CONFIG_ASH_MATH_SUPPORT
12204 /* The let builtin. */
12205 int letcmd(int argc, char **argv)
12211 char *tmp, *expression, p[13];
12213 expression = strchr(argv[1], '=');
12215 /* Cannot use 'error()' here, or the return code
12216 * will be incorrect */
12217 out2fmt("sh: let: syntax error: \"%s\"\n", argv[1]);
12220 *expression = '\0';
12221 tmp = ++expression;
12222 result = arith(tmp, &errcode);
12224 /* Cannot use 'error()' here, or the return code
12225 * will be incorrect */
12226 out2fmt("sh: let: ");
12228 out2fmt("divide by zero");
12230 out2fmt("syntax error: \"%s=%s\"\n", argv[1], expression);
12233 snprintf(p, 12, "%ld", result);
12234 setvar(argv[1], xstrdup(p), 0);
12235 } else if (argc >= 3)
12236 synerror("invalid operand");
12244 * Copyright (c) 1989, 1991, 1993, 1994
12245 * The Regents of the University of California. All rights reserved.
12247 * This code is derived from software contributed to Berkeley by
12248 * Kenneth Almquist.
12250 * Redistribution and use in source and binary forms, with or without
12251 * modification, are permitted provided that the following conditions
12253 * 1. Redistributions of source code must retain the above copyright
12254 * notice, this list of conditions and the following disclaimer.
12255 * 2. Redistributions in binary form must reproduce the above copyright
12256 * notice, this list of conditions and the following disclaimer in the
12257 * documentation and/or other materials provided with the distribution.
12259 * 3. <BSD Advertising Clause omitted per the July 22, 1999 licensing change
12260 * ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change>
12262 * 4. Neither the name of the University nor the names of its contributors
12263 * may be used to endorse or promote products derived from this software
12264 * without specific prior written permission.
12266 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
12267 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
12268 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
12269 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
12270 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
12271 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
12272 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
12273 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
12274 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
12275 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF