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;
1203 void (*func) (const char *);
1206 static const char defpathvar[] =
1207 "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
1208 #define defpath (defpathvar + 5)
1211 static const char defifsvar[] = "IFS= \t\n";
1213 #define defifs (defifsvar + 4)
1215 static const char defifs[] = " \t\n";
1218 static const struct varinit varinit[] = {
1220 {&vifs, VSTRFIXED | VTEXTFIXED, defifsvar,
1222 {&vifs, VSTRFIXED | VTEXTFIXED | VUNSET, "IFS=",
1225 {&vmail, VSTRFIXED | VTEXTFIXED | VUNSET, "MAIL=",
1227 {&vmpath, VSTRFIXED | VTEXTFIXED | VUNSET, "MAILPATH=",
1229 {&vpath, VSTRFIXED | VTEXTFIXED, defpathvar,
1231 #if defined(CONFIG_FEATURE_COMMAND_EDITING) && defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
1232 {&vps1, VSTRFIXED | VTEXTFIXED, "PS1=\\w \\$ ",
1234 #endif /* else vps1 depends on uid */
1235 {&vps2, VSTRFIXED | VTEXTFIXED, "PS2=> ",
1237 {&voptind, VSTRFIXED | VTEXTFIXED, "OPTIND=1",
1239 #ifdef CONFIG_LOCALE_SUPPORT
1240 {&vlc_all, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_ALL=",
1242 {&vlc_ctype, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_CTYPE=",
1251 static struct var *vartab[VTABSIZE];
1254 * The following macros access the values of the above variables.
1255 * They have to skip over the name. They return the null string
1256 * for unset variables.
1259 #define ifsval() (vifs.text + 4)
1260 #define ifsset() ((vifs.flags & VUNSET) == 0)
1261 #define mailval() (vmail.text + 5)
1262 #define mpathval() (vmpath.text + 9)
1263 #define pathval() (vpath.text + 5)
1264 #define ps1val() (vps1.text + 4)
1265 #define ps2val() (vps2.text + 4)
1266 #define optindval() (voptind.text + 7)
1268 #define mpathset() ((vmpath.flags & VUNSET) == 0)
1270 static void initvar(void);
1271 static void setvar(const char *, const char *, int);
1272 static void setvareq(char *, int);
1273 static void listsetvar(struct strlist *);
1274 static const char *lookupvar(const char *);
1275 static const char *bltinlookup(const char *);
1276 static char **environment(void);
1277 static int showvarscmd(int, char **);
1278 static void mklocal(char *);
1279 static void poplocalvars(void);
1280 static int unsetvar(const char *);
1281 static int varequal(const char *, const char *);
1284 static char *arg0; /* value of $0 */
1285 static struct shparam shellparam; /* current positional parameters */
1286 static char **argptr; /* argument list for builtin commands */
1287 static char *optionarg; /* set by nextopt (like getopt) */
1288 static char *optptr; /* used by nextopt */
1289 static char *minusc; /* argument to -c option */
1292 #ifdef CONFIG_ASH_ALIAS
1294 #define ALIASINUSE 1
1306 static struct alias *atab[ATABSIZE];
1308 static void setalias(char *, char *);
1309 static struct alias **hashalias(const char *);
1310 static struct alias *freealias(struct alias *);
1311 static struct alias **__lookupalias(const char *);
1313 static void setalias(char *name, char *val)
1315 struct alias *ap, **app;
1317 app = __lookupalias(name);
1321 if (!(ap->flag & ALIASINUSE)) {
1324 ap->val = xstrdup(val);
1325 ap->flag &= ~ALIASDEAD;
1328 ap = xmalloc(sizeof(struct alias));
1329 ap->name = xstrdup(name);
1330 ap->val = xstrdup(val);
1338 static int unalias(char *name)
1342 app = __lookupalias(name);
1346 *app = freealias(*app);
1354 static void rmaliases(void)
1356 struct alias *ap, **app;
1360 for (i = 0; i < ATABSIZE; i++) {
1362 for (ap = *app; ap; ap = *app) {
1363 *app = freealias(*app);
1372 static void printalias(const struct alias *ap)
1376 p = single_quote(ap->val);
1377 printf("alias %s=%s\n", ap->name, p);
1383 * TODO - sort output
1385 static int aliascmd(int argc, char **argv)
1394 for (i = 0; i < ATABSIZE; i++)
1395 for (ap = atab[i]; ap; ap = ap->next) {
1400 while ((n = *++argv) != NULL) {
1401 if ((v = strchr(n + 1, '=')) == NULL) { /* n+1: funny ksh stuff */
1402 if ((ap = *__lookupalias(n)) == NULL) {
1403 out2fmt("%s: %s not found\n", "alias", n);
1416 static int unaliascmd(int argc, char **argv)
1420 while ((i = nextopt("a")) != '\0') {
1426 for (i = 0; *argptr; argptr++) {
1427 if (unalias(*argptr)) {
1428 out2fmt("%s: %s not found\n", "unalias", *argptr);
1436 static struct alias **hashalias(const char *p)
1438 unsigned int hashval;
1443 return &atab[hashval % ATABSIZE];
1446 static struct alias *freealias(struct alias *ap)
1450 if (ap->flag & ALIASINUSE) {
1451 ap->flag |= ALIASDEAD;
1463 static struct alias **__lookupalias(const char *name)
1465 struct alias **app = hashalias(name);
1467 for (; *app; app = &(*app)->next) {
1468 if (equal(name, (*app)->name)) {
1477 #ifdef CONFIG_ASH_MATH_SUPPORT
1478 /* The generated file arith.c has been replaced with a custom hand
1479 * written implementation written by Aaron Lehmann <aaronl@vitelus.com>.
1480 * This is now part of libbb, so that it can be used by all the shells
1482 static void expari(int);
1485 static char *trap[NSIG]; /* trap handler commands */
1486 static char sigmode[NSIG - 1]; /* current value of signal */
1487 static char gotsig[NSIG - 1]; /* indicates specified signal received */
1488 static int pendingsigs; /* indicates some signal received */
1491 * This file was generated by the mkbuiltins program.
1494 #ifdef CONFIG_ASH_JOB_CONTROL
1495 static int bgcmd(int, char **);
1496 static int fgcmd(int, char **);
1497 static int killcmd(int, char **);
1499 static int bltincmd(int, char **);
1500 static int cdcmd(int, char **);
1501 static int breakcmd(int, char **);
1503 #ifdef CONFIG_ASH_CMDCMD
1504 static int commandcmd(int, char **);
1506 static int dotcmd(int, char **);
1507 static int evalcmd(int, char **);
1508 static int execcmd(int, char **);
1509 static int exitcmd(int, char **);
1510 static int exportcmd(int, char **);
1511 static int histcmd(int, char **);
1512 static int hashcmd(int, char **);
1513 static int helpcmd(int, char **);
1514 static int jobscmd(int, char **);
1515 static int localcmd(int, char **);
1516 static int pwdcmd(int, char **);
1517 static int readcmd(int, char **);
1518 static int returncmd(int, char **);
1519 static int setcmd(int, char **);
1520 static int setvarcmd(int, char **);
1521 static int shiftcmd(int, char **);
1522 static int trapcmd(int, char **);
1523 static int umaskcmd(int, char **);
1525 #ifdef CONFIG_ASH_ALIAS
1526 static int aliascmd(int, char **);
1527 static int unaliascmd(int, char **);
1529 static int unsetcmd(int, char **);
1530 static int waitcmd(int, char **);
1531 static int ulimitcmd(int, char **);
1532 static int timescmd(int, char **);
1534 #ifdef CONFIG_ASH_MATH_SUPPORT
1535 static int letcmd(int, char **);
1537 static int typecmd(int, char **);
1539 #ifdef CONFIG_ASH_GETOPTS
1540 static int getoptscmd(int, char **);
1544 static int true_main(int, char **);
1546 #ifndef CONFIG_FALSE
1547 static int false_main(int, char **);
1550 static void setpwd(const char *, int);
1553 #define BUILTIN_NOSPEC "0"
1554 #define BUILTIN_SPECIAL "1"
1555 #define BUILTIN_REGULAR "2"
1556 #define BUILTIN_ASSIGN "4"
1557 #define BUILTIN_SPEC_ASSG "5"
1558 #define BUILTIN_REG_ASSG "6"
1560 #define IS_BUILTIN_SPECIAL(builtincmd) ((builtincmd)->name[0] & 1)
1561 #define IS_BUILTIN_REGULAR(builtincmd) ((builtincmd)->name[0] & 2)
1562 #define IS_BUILTIN_ASSIGN(builtincmd) ((builtincmd)->name[0] & 4)
1566 int (*const builtinfunc) (int, char **);
1571 /* It is CRUCIAL that this listing be kept in ascii order, otherwise
1572 * the binary search in find_builtin() will stop working. If you value
1573 * your kneecaps, you'll be sure to *make sure* that any changes made
1574 * to this array result in the listing remaining in ascii order. You
1577 static const struct builtincmd builtincmds[] = {
1578 {BUILTIN_SPECIAL ".", dotcmd}, /* first, see declare DOTCMD */
1579 {BUILTIN_SPECIAL ":", true_main},
1580 #ifdef CONFIG_ASH_ALIAS
1581 {BUILTIN_REG_ASSG "alias", aliascmd},
1583 #ifdef CONFIG_ASH_JOB_CONTROL
1584 {BUILTIN_REGULAR "bg", bgcmd},
1586 {BUILTIN_SPECIAL "break", breakcmd},
1587 {BUILTIN_SPECIAL "builtin", bltincmd},
1588 {BUILTIN_REGULAR "cd", cdcmd},
1589 {BUILTIN_NOSPEC "chdir", cdcmd},
1590 #ifdef CONFIG_ASH_CMDCMD
1591 {BUILTIN_REGULAR "command", commandcmd},
1593 {BUILTIN_SPECIAL "continue", breakcmd},
1594 {BUILTIN_SPECIAL "eval", evalcmd},
1595 {BUILTIN_SPECIAL "exec", execcmd},
1596 {BUILTIN_SPECIAL "exit", exitcmd},
1597 {BUILTIN_SPEC_ASSG "export", exportcmd},
1598 {BUILTIN_REGULAR "false", false_main},
1599 {BUILTIN_REGULAR "fc", histcmd},
1600 #ifdef CONFIG_ASH_JOB_CONTROL
1601 {BUILTIN_REGULAR "fg", fgcmd},
1603 #ifdef CONFIG_ASH_GETOPTS
1604 {BUILTIN_REGULAR "getopts", getoptscmd},
1606 {BUILTIN_NOSPEC "hash", hashcmd},
1607 {BUILTIN_NOSPEC "help", helpcmd},
1608 {BUILTIN_REGULAR "jobs", jobscmd},
1609 #ifdef CONFIG_ASH_JOB_CONTROL
1610 {BUILTIN_REGULAR "kill", killcmd},
1612 #ifdef CONFIG_ASH_MATH_SUPPORT
1613 {BUILTIN_REGULAR "let", letcmd},
1615 {BUILTIN_ASSIGN "local", localcmd},
1616 {BUILTIN_NOSPEC "pwd", pwdcmd},
1617 {BUILTIN_REGULAR "read", readcmd},
1618 {BUILTIN_SPEC_ASSG "readonly", exportcmd},
1619 {BUILTIN_SPECIAL "return", returncmd},
1620 {BUILTIN_SPECIAL "set", setcmd},
1621 {BUILTIN_NOSPEC "setvar", setvarcmd},
1622 {BUILTIN_SPECIAL "shift", shiftcmd},
1623 {BUILTIN_SPECIAL "times", timescmd},
1624 {BUILTIN_SPECIAL "trap", trapcmd},
1625 {BUILTIN_REGULAR "true", true_main},
1626 {BUILTIN_NOSPEC "type", typecmd},
1627 {BUILTIN_NOSPEC "ulimit", ulimitcmd},
1628 {BUILTIN_REGULAR "umask", umaskcmd},
1629 #ifdef CONFIG_ASH_ALIAS
1630 {BUILTIN_REGULAR "unalias", unaliascmd},
1632 {BUILTIN_SPECIAL "unset", unsetcmd},
1633 {BUILTIN_REGULAR "wait", waitcmd},
1636 #define NUMBUILTINS (sizeof (builtincmds) / sizeof (struct builtincmd) )
1638 #define DOTCMD &builtincmds[0]
1639 static struct builtincmd *BLTINCMD;
1640 static struct builtincmd *EXECCMD;
1641 static struct builtincmd *EVALCMD;
1644 #define JOBSTOPPED 1 /* all procs are stopped */
1645 #define JOBDONE 2 /* all procs are completed */
1648 * A job structure contains information about a job. A job is either a
1649 * single process or a set of processes contained in a pipeline. In the
1650 * latter case, pidlist will be non-NULL, and will point to a -1 terminated
1655 pid_t pid; /* process id */
1656 int status; /* status flags (defined above) */
1657 char *cmd; /* text of command being run */
1661 static int job_warning; /* user was warned about stopped jobs */
1663 #ifdef CONFIG_ASH_JOB_CONTROL
1664 static void setjobctl(int enable);
1666 #define setjobctl(on) /* do nothing */
1671 struct procstat ps0; /* status of process */
1672 struct procstat *ps; /* status or processes when more than one */
1673 short nprocs; /* number of processes */
1674 short pgrp; /* process group of this job */
1675 char state; /* true if job is finished */
1676 char used; /* true if this entry is in used */
1677 char changed; /* true if status has changed */
1678 #ifdef CONFIG_ASH_JOB_CONTROL
1679 char jobctl; /* job running under job control */
1683 static struct job *jobtab; /* array of jobs */
1684 static int njobs; /* size of array */
1685 static int backgndpid = -1; /* pid of last background process */
1687 #ifdef CONFIG_ASH_JOB_CONTROL
1688 static int initialpgrp; /* pgrp of shell on invocation */
1689 static int curjob; /* current job */
1693 static struct job *makejob(const union node *, int);
1694 static int forkshell(struct job *, const union node *, int);
1695 static int waitforjob(struct job *);
1697 static int docd(char *, int);
1698 static void getpwd(void);
1700 static char *padvance(const char **, const char *);
1702 static char nullstr[1]; /* zero length string */
1703 static char *curdir = nullstr; /* current working directory */
1705 static int cdcmd(int argc, char **argv)
1714 if ((dest = *argptr) == NULL && (dest = bltinlookup("HOME")) == NULL)
1715 error("HOME not set");
1718 if (dest[0] == '-' && dest[1] == '\0') {
1719 dest = bltinlookup("OLDPWD");
1720 if (!dest || !*dest) {
1729 if (*dest == '/' || (path = bltinlookup("CDPATH")) == NULL)
1731 while ((p = padvance(&path, dest)) != NULL) {
1732 if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) {
1737 if (p[0] == '.' && p[1] == '/' && p[2] != '\0')
1739 print = strcmp(p, dest);
1741 if (docd(p, print) >= 0)
1746 error("can't cd to %s", dest);
1752 * Update curdir (the name of the current directory) in response to a
1753 * cd command. We also call hashcd to let the routines in exec.c know
1754 * that the current directory has changed.
1757 static void hashcd(void);
1759 static inline void updatepwd(const char *dir)
1761 hashcd(); /* update command hash table */
1764 * If our argument is NULL, we don't know the current directory
1766 if (dir == NULL || curdir == nullstr) {
1774 * Actually do the chdir. In an interactive shell, print the
1775 * directory name if "print" is nonzero.
1778 static int docd(char *dest, int print)
1780 TRACE(("docd(\"%s\", %d) called\n", dest, print));
1782 if (chdir(dest) < 0) {
1794 static int pwdcmd(int argc, char **argv)
1800 /* Ask system the current directory */
1801 static void getpwd(void)
1803 curdir = xgetcwd(0);
1808 static void setpwd(const char *val, int setold)
1813 setvar("OLDPWD", curdir, VEXPORT);
1816 if (curdir != nullstr) {
1817 if (val != NULL && *val != '/')
1818 val = cated = concat_path_file(curdir, val);
1824 curdir = simplify_path(val);
1827 setvar("PWD", curdir, VEXPORT);
1831 * Errors and exceptions.
1835 * Code to handle exceptions in C.
1839 * We enclose jmp_buf in a structure so that we can declare pointers to
1840 * jump locations. The global variable handler contains the location to
1841 * jump to when an exception occurs, and the global variable exception
1842 * contains a code identifying the exeception. To implement nested
1843 * exception handlers, the user should save the value of handler on entry
1844 * to an inner scope, set handler to point to a jmploc structure for the
1845 * inner scope, and restore handler on exit from the scope.
1853 #define EXINT 0 /* SIGINT received */
1854 #define EXERROR 1 /* a generic error */
1855 #define EXSHELLPROC 2 /* execute a shell procedure */
1856 #define EXEXEC 3 /* command execution failed */
1857 #define EXREDIR 4 /* redirection error */
1859 static struct jmploc *handler;
1860 static int exception;
1862 static void exverror(int, const char *, va_list)
1863 __attribute__ ((__noreturn__));
1866 * Called to raise an exception. Since C doesn't include exceptions, we
1867 * just do a longjmp to the exception handler. The type of exception is
1868 * stored in the global variable "exception".
1871 static void exraise(int) __attribute__ ((__noreturn__));
1873 static void exraise(int e)
1876 if (handler == NULL)
1881 longjmp(handler->loc, 1);
1886 * Called from trap.c when a SIGINT is received. (If the user specifies
1887 * that SIGINT is to be trapped or ignored using the trap builtin, then
1888 * this routine is not called.) Suppressint is nonzero when interrupts
1889 * are held using the INTOFF macro. The call to _exit is necessary because
1890 * there is a short period after a fork before the signal handlers are
1891 * set to the appropriate value for the child. (The test for iflag is
1892 * just defensive programming.)
1895 static void onint(void)
1904 sigemptyset(&mysigset);
1905 sigprocmask(SIG_SETMASK, &mysigset, NULL);
1906 if (!(rootshell && iflag)) {
1907 signal(SIGINT, SIG_DFL);
1915 static char *commandname; /* currently executing command */
1918 * Exverror is called to raise the error exception. If the first argument
1919 * is not NULL then error prints an error message using printf style
1920 * formatting. It then raises the error exception.
1922 static void exverror(int cond, const char *msg, va_list ap)
1929 TRACE(("exverror(%d, \"%s\") pid=%d\n", cond, msg, getpid()));
1931 TRACE(("exverror(%d, NULL) pid=%d\n", cond, getpid()));
1935 out2fmt("%s: ", commandname);
1936 vfprintf(stderr, msg, ap);
1944 static void error(const char *msg, ...)
1949 exverror(EXERROR, msg, ap);
1955 static void exerror(int cond, const char *msg, ...)
1960 exverror(cond, msg, ap);
1968 * Table of error messages.
1972 short errcode; /* error number */
1973 short action; /* operation which encountered the error */
1977 * Types of operations (passed to the errmsg routine).
1980 #define E_OPEN 01 /* opening a file */
1981 #define E_CREAT 02 /* creating a file */
1982 #define E_EXEC 04 /* executing a program */
1984 #define ALL (E_OPEN|E_CREAT|E_EXEC)
1986 static const struct errname errormsg[] = {
2040 #define ERRNAME_SIZE (sizeof(errormsg)/sizeof(struct errname))
2043 * Return a string describing an error. The returned string may be a
2044 * pointer to a static buffer that will be overwritten on the next call.
2045 * Action describes the operation that got the error.
2048 static const char *errmsg(int e, int action)
2050 struct errname const *ep;
2051 static char buf[12];
2053 for (ep = errormsg; ep < errormsg + ERRNAME_SIZE; ep++) {
2054 if (ep->errcode == e && (ep->action & action) != 0)
2058 snprintf(buf, sizeof buf, "error %d", e);
2063 #ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE
2064 static void __inton()
2066 if (--suppressint == 0 && intpending) {
2070 static void forceinton(void)
2078 /* flags in argument to evaltree */
2079 #define EV_EXIT 01 /* exit after evaluating tree */
2080 #define EV_TESTED 02 /* exit status is checked; ignore -e flag */
2081 #define EV_BACKCMD 04 /* command executing within back quotes */
2083 static int evalskip; /* set if we are skipping commands */
2084 static int skipcount; /* number of levels to skip */
2085 static int loopnest; /* current loop nesting level */
2086 static int funcnest; /* depth of function calls */
2089 static struct strlist *cmdenviron; /* environment for builtin command */
2090 static int exitstatus; /* exit status of last command */
2091 static int oexitstatus; /* saved exit status */
2093 static void evalsubshell(const union node *, int);
2094 static void expredir(union node *);
2095 static void prehash(union node *);
2096 static void eprintlist(struct strlist *);
2098 static union node *parsecmd(int);
2101 * Called to reset things after an exception.
2105 * The eval commmand.
2107 static void evalstring(char *, int);
2109 static int evalcmd(int argc, char **argv)
2118 STARTSTACKSTR(concat);
2122 STPUTC(*p++, concat);
2123 if ((p = *ap++) == NULL)
2125 STPUTC(' ', concat);
2127 STPUTC('\0', concat);
2128 p = grabstackstr(concat);
2130 evalstring(p, EV_TESTED);
2136 * Execute a command or commands contained in a string.
2139 static void evaltree(union node *, int);
2140 static void setinputstring(char *);
2141 static void popfile(void);
2142 static void setstackmark(struct stackmark *mark);
2143 static void popstackmark(struct stackmark *mark);
2146 static void evalstring(char *s, int flag)
2149 struct stackmark smark;
2151 setstackmark(&smark);
2153 while ((n = parsecmd(0)) != NEOF) {
2155 popstackmark(&smark);
2158 popstackmark(&smark);
2161 static struct builtincmd *find_builtin(const char *);
2162 static void expandarg(union node *, struct arglist *, int);
2163 static void calcsize(const union node *);
2164 static union node *copynode(const union node *);
2167 * Make a copy of a parse tree.
2170 static int funcblocksize; /* size of structures in function */
2171 static int funcstringsize; /* size of strings in node */
2172 static pointer funcblock; /* block to allocate function from */
2173 static char *funcstring; /* block to allocate strings from */
2176 static inline union node *copyfunc(union node *n)
2183 funcblock = xmalloc(funcblocksize + funcstringsize);
2184 funcstring = (char *) funcblock + funcblocksize;
2189 * Add a new command entry, replacing any existing command entry for
2193 static inline void addcmdentry(char *name, struct cmdentry *entry)
2195 struct tblentry *cmdp;
2198 cmdp = cmdlookup(name, 1);
2199 if (cmdp->cmdtype == CMDFUNCTION) {
2200 free(cmdp->param.func);
2202 cmdp->cmdtype = entry->cmdtype;
2203 cmdp->param = entry->u;
2207 static inline void evalloop(const union node *n, int flags)
2215 evaltree(n->nbinary.ch1, EV_TESTED);
2217 skipping:if (evalskip == SKIPCONT && --skipcount <= 0) {
2221 if (evalskip == SKIPBREAK && --skipcount <= 0)
2225 if (n->type == NWHILE) {
2226 if (exitstatus != 0)
2229 if (exitstatus == 0)
2232 evaltree(n->nbinary.ch2, flags);
2233 status = exitstatus;
2238 exitstatus = status;
2241 static void evalfor(const union node *n, int flags)
2243 struct arglist arglist;
2246 struct stackmark smark;
2248 setstackmark(&smark);
2249 arglist.lastp = &arglist.list;
2250 for (argp = n->nfor.args; argp; argp = argp->narg.next) {
2251 oexitstatus = exitstatus;
2252 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE | EXP_RECORD);
2256 *arglist.lastp = NULL;
2261 for (sp = arglist.list; sp; sp = sp->next) {
2262 setvar(n->nfor.var, sp->text, 0);
2263 evaltree(n->nfor.body, flags);
2265 if (evalskip == SKIPCONT && --skipcount <= 0) {
2269 if (evalskip == SKIPBREAK && --skipcount <= 0)
2276 popstackmark(&smark);
2279 static inline void evalcase(const union node *n, int flags)
2283 struct arglist arglist;
2284 struct stackmark smark;
2286 setstackmark(&smark);
2287 arglist.lastp = &arglist.list;
2288 oexitstatus = exitstatus;
2289 expandarg(n->ncase.expr, &arglist, EXP_TILDE);
2290 for (cp = n->ncase.cases; cp && evalskip == 0; cp = cp->nclist.next) {
2291 for (patp = cp->nclist.pattern; patp; patp = patp->narg.next) {
2292 if (casematch(patp, arglist.list->text)) {
2293 if (evalskip == 0) {
2294 evaltree(cp->nclist.body, flags);
2301 popstackmark(&smark);
2305 * Evaluate a pipeline. All the processes in the pipeline are children
2306 * of the process creating the pipeline. (This differs from some versions
2307 * of the shell, which make the last process in a pipeline the parent
2311 static inline void evalpipe(union node *n, int flags)
2314 struct nodelist *lp;
2319 TRACE(("evalpipe(0x%lx) called\n", (long) n));
2321 for (lp = n->npipe.cmdlist; lp; lp = lp->next)
2325 jp = makejob(n, pipelen);
2327 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
2331 if (pipe(pip) < 0) {
2333 error("Pipe call failed");
2336 if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) {
2349 evaltree(lp->n, flags);
2356 if (n->npipe.backgnd == 0) {
2357 exitstatus = waitforjob(jp);
2358 TRACE(("evalpipe: job done exit status %d\n", exitstatus));
2363 static void find_command(const char *, struct cmdentry *, int, const char *);
2365 static int isassignment(const char *word)
2367 if (!is_name(*word)) {
2372 } while (is_in_name(*word));
2373 return *word == '=';
2377 static void evalcommand(union node *cmd, int flags)
2379 struct stackmark smark;
2381 struct arglist arglist;
2382 struct arglist varlist;
2388 struct cmdentry cmdentry;
2390 char *volatile savecmdname;
2391 volatile struct shparam saveparam;
2392 struct localvar *volatile savelocalvars;
2397 struct jmploc *volatile savehandler;
2398 struct jmploc jmploc;
2401 /* Avoid longjmp clobbering */
2409 /* First expand the arguments. */
2410 TRACE(("evalcommand(0x%lx, %d) called\n", (long) cmd, flags));
2411 setstackmark(&smark);
2412 arglist.lastp = &arglist.list;
2413 varlist.lastp = &varlist.list;
2415 oexitstatus = exitstatus;
2418 for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
2419 expandarg(argp, &varlist, EXP_VARTILDE);
2421 for (argp = cmd->ncmd.args; argp; argp = argp->narg.next) {
2422 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
2424 *arglist.lastp = NULL;
2425 *varlist.lastp = NULL;
2426 expredir(cmd->ncmd.redirect);
2428 for (sp = arglist.list; sp; sp = sp->next)
2430 argv = stalloc(sizeof(char *) * (argc + 1));
2432 for (sp = arglist.list; sp; sp = sp->next) {
2433 TRACE(("evalcommand arg: %s\n", sp->text));
2438 if (iflag && funcnest == 0 && argc > 0)
2442 /* Print the command if xflag is set. */
2445 eprintlist(varlist.list);
2446 eprintlist(arglist.list);
2450 /* Now locate the command. */
2452 cmdentry.cmdtype = CMDBUILTIN;
2453 cmdentry.u.cmd = BLTINCMD;
2456 const char *oldpath;
2457 int findflag = DO_ERR;
2461 * Modify the command lookup path, if a PATH= assignment
2464 for (sp = varlist.list; sp; sp = sp->next)
2465 if (varequal(sp->text, defpathvar)) {
2466 path = sp->text + 5;
2467 findflag |= DO_BRUTE;
2470 oldfindflag = findflag;
2473 find_command(argv[0], &cmdentry, findflag, path);
2474 if (cmdentry.cmdtype == CMDUNKNOWN) { /* command not found */
2478 /* implement bltin and command here */
2479 if (cmdentry.cmdtype != CMDBUILTIN) {
2482 if (spclbltin < 0) {
2483 spclbltin = !!(IS_BUILTIN_SPECIAL(cmdentry.u.cmd)) * 2;
2485 if (cmdentry.u.cmd == BLTINCMD) {
2487 struct builtincmd *bcmd;
2492 if (!(bcmd = find_builtin(*argv))) {
2493 out2fmt("%s: not found\n", *argv);
2497 cmdentry.u.cmd = bcmd;
2498 if (bcmd != BLTINCMD)
2502 if (cmdentry.u.cmd == find_builtin("command")) {
2507 if (*argv[0] == '-') {
2508 if (!equal(argv[0], "-p")) {
2518 findflag |= DO_BRUTE;
2521 findflag = oldfindflag;
2523 findflag |= DO_NOFUN;
2531 /* Fork off a child process if necessary. */
2532 if (cmd->ncmd.backgnd
2533 || (cmdentry.cmdtype == CMDNORMAL && (!(flags & EV_EXIT) || trap[0]))
2536 jp = makejob(cmd, 1);
2537 mode = cmd->ncmd.backgnd;
2538 if (forkshell(jp, cmd, mode) != 0)
2539 goto parent; /* at end of routine */
2546 /* This is the child process if a fork occurred. */
2547 /* Execute the command. */
2548 if (cmdentry.cmdtype == CMDFUNCTION) {
2550 trputs("Shell function: ");
2553 exitstatus = oexitstatus;
2554 saveparam = shellparam;
2555 shellparam.malloc = 0;
2556 shellparam.nparam = argc - 1;
2557 shellparam.p = argv + 1;
2559 savelocalvars = localvars;
2562 if (setjmp(jmploc.loc)) {
2563 if (exception == EXREDIR) {
2567 saveparam.optind = shellparam.optind;
2568 saveparam.optoff = shellparam.optoff;
2569 freeparam(&shellparam);
2570 shellparam = saveparam;
2572 localvars = savelocalvars;
2573 handler = savehandler;
2574 longjmp(handler->loc, 1);
2576 savehandler = handler;
2578 redirect(cmd->ncmd.redirect, REDIR_PUSH);
2579 listsetvar(varlist.list);
2581 evaltree(cmdentry.u.func, flags & EV_TESTED);
2586 localvars = savelocalvars;
2587 saveparam.optind = shellparam.optind;
2588 saveparam.optoff = shellparam.optoff;
2589 freeparam(&shellparam);
2590 shellparam = saveparam;
2591 handler = savehandler;
2594 if (evalskip == SKIPFUNC) {
2598 } else if (cmdentry.cmdtype == CMDBUILTIN) {
2602 trputs("builtin command: ");
2605 redir = (cmdentry.u.cmd == EXECCMD) ? 0 : REDIR_PUSH;
2606 savecmdname = commandname;
2608 listsetvar(varlist.list);
2610 cmdenviron = varlist.list;
2613 if (setjmp(jmploc.loc)) {
2615 exitstatus = (e == EXINT) ? SIGINT + 128 : 2;
2618 savehandler = handler;
2620 redirect(cmd->ncmd.redirect, redir);
2621 commandname = argv[0];
2623 optptr = NULL; /* initialize nextopt */
2624 exitstatus = (*cmdentry.u.cmd->builtinfunc) (argc, argv);
2628 commandname = savecmdname;
2629 handler = savehandler;
2631 if (e == EXINT || spclbltin & 2) {
2637 if (cmdentry.u.cmd != EXECCMD)
2641 trputs("normal command: ");
2644 redirect(cmd->ncmd.redirect, 0);
2646 for (sp = varlist.list; sp; sp = sp->next)
2647 setvareq(sp->text, VEXPORT | VSTACK);
2648 envp = environment();
2649 shellexec(argv, envp, path, cmdentry.u.index);
2651 if (flags & EV_EXIT)
2652 exitshell(exitstatus);
2655 parent: /* parent process gets here (if we forked) */
2656 if (mode == 0) { /* argument to fork */
2657 exitstatus = waitforjob(jp);
2663 setvar("_", lastarg, 0);
2664 popstackmark(&smark);
2668 * Evaluate a parse tree. The value is left in the global variable
2671 static void evaltree(union node *n, int flags)
2676 TRACE(("evaltree(NULL) called\n"));
2679 TRACE(("evaltree(0x%lx: %d) called\n", (long) n, n->type));
2682 evaltree(n->nbinary.ch1, flags & EV_TESTED);
2685 evaltree(n->nbinary.ch2, flags);
2688 evaltree(n->nbinary.ch1, EV_TESTED);
2689 if (evalskip || exitstatus != 0)
2691 evaltree(n->nbinary.ch2, flags);
2694 evaltree(n->nbinary.ch1, EV_TESTED);
2695 if (evalskip || exitstatus == 0)
2697 evaltree(n->nbinary.ch2, flags);
2700 expredir(n->nredir.redirect);
2701 redirect(n->nredir.redirect, REDIR_PUSH);
2702 evaltree(n->nredir.n, flags);
2706 evalsubshell(n, flags);
2709 evalsubshell(n, flags);
2712 evaltree(n->nif.test, EV_TESTED);
2715 if (exitstatus == 0)
2716 evaltree(n->nif.ifpart, flags);
2717 else if (n->nif.elsepart)
2718 evaltree(n->nif.elsepart, flags);
2734 struct builtincmd *bcmd;
2735 struct cmdentry entry;
2737 if ((bcmd = find_builtin(n->narg.text)) && IS_BUILTIN_SPECIAL(bcmd)
2739 out2fmt("%s is a special built-in\n", n->narg.text);
2743 entry.cmdtype = CMDFUNCTION;
2744 entry.u.func = copyfunc(n->narg.next);
2745 addcmdentry(n->narg.text, &entry);
2750 evaltree(n->nnot.com, EV_TESTED);
2751 exitstatus = !exitstatus;
2759 evalcommand(n, flags);
2764 printf("Node type = %d\n", n->type);
2771 if (flags & EV_EXIT ||
2772 (checkexit && eflag && exitstatus && !(flags & EV_TESTED))
2774 exitshell(exitstatus);
2778 * Kick off a subshell to evaluate a tree.
2781 static void evalsubshell(const union node *n, int flags)
2784 int backgnd = (n->type == NBACKGND);
2786 expredir(n->nredir.redirect);
2787 if (!backgnd && flags & EV_EXIT && !trap[0])
2791 if (forkshell(jp, n, backgnd) == 0) {
2795 flags &= ~EV_TESTED;
2797 redirect(n->nredir.redirect, 0);
2798 evaltree(n->nredir.n, flags); /* never returns */
2801 exitstatus = waitforjob(jp);
2807 * Compute the names of the files in a redirection list.
2810 static void fixredir(union node *n, const char *text, int err);
2812 static void expredir(union node *n)
2816 for (redir = n; redir; redir = redir->nfile.next) {
2819 fn.lastp = &fn.list;
2820 oexitstatus = exitstatus;
2821 switch (redir->type) {
2827 expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
2828 redir->nfile.expfname = fn.list->text;
2832 if (redir->ndup.vname) {
2833 expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE);
2834 fixredir(redir, fn.list->text, 1);
2843 * Execute a command inside back quotes. If it's a builtin command, we
2844 * want to save its output in a block obtained from malloc. Otherwise
2845 * we fork off a subprocess and get the output of the command via a pipe.
2846 * Should be called with interrupts off.
2849 static void evalbackcmd(union node *n, struct backcmd *result)
2853 struct stackmark smark; /* unnecessary */
2855 setstackmark(&smark);
2866 error("Pipe call failed");
2868 if (forkshell(jp, n, FORK_NOJOB) == 0) {
2873 dup_as_newfd(pip[1], 1);
2877 evaltree(n, EV_EXIT);
2880 result->fd = pip[0];
2883 popstackmark(&smark);
2884 TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
2885 result->fd, result->buf, result->nleft, result->jp));
2890 * Execute a simple command.
2894 * Search for a command. This is called before we fork so that the
2895 * location of the command will be available in the parent as well as
2896 * the child. The check for "goodname" is an overly conservative
2897 * check that the name will not be subject to expansion.
2900 static void prehash(union node *n)
2902 struct cmdentry entry;
2904 if (n->type == NCMD && n->ncmd.args)
2905 if (goodname(n->ncmd.args->narg.text))
2906 find_command(n->ncmd.args->narg.text, &entry, 0, pathval());
2911 * Builtin commands. Builtin commands whose functions are closely
2912 * tied to evaluation are implemented here.
2916 * No command given, or a bltin command with no arguments. Set the
2917 * specified variables.
2920 int bltincmd(int argc, char **argv)
2923 * Preserve exitstatus of a previous possible redirection
2931 * Handle break and continue commands. Break, continue, and return are
2932 * all handled by setting the evalskip flag. The evaluation routines
2933 * above all check this flag, and if it is set they start skipping
2934 * commands rather than executing them. The variable skipcount is
2935 * the number of loops to break/continue, or the number of function
2936 * levels to return. (The latter is always 1.) It should probably
2937 * be an error to break out of more loops than exist, but it isn't
2938 * in the standard shell so we don't make it one here.
2941 static int breakcmd(int argc, char **argv)
2943 int n = argc > 1 ? number(argv[1]) : 1;
2946 error("Illegal number: %s", argv[1]);
2950 evalskip = (**argv == 'c') ? SKIPCONT : SKIPBREAK;
2958 * The return command.
2961 static int returncmd(int argc, char **argv)
2963 int ret = argc > 1 ? number(argv[1]) : oexitstatus;
2966 evalskip = SKIPFUNC;
2970 /* Do what ksh does; skip the rest of the file */
2971 evalskip = SKIPFILE;
2978 #ifndef CONFIG_FALSE
2979 static int false_main(int argc, char **argv)
2986 static int true_main(int argc, char **argv)
2993 * Controls whether the shell is interactive or not.
2996 static void setsignal(int signo);
2998 #ifdef CONFIG_ASH_MAIL
2999 static void chkmail(int silent);
3002 static void setinteractive(int on)
3004 static int is_interactive;
3005 static int do_banner = 0;
3007 if (on == is_interactive)
3012 #ifdef CONFIG_ASH_MAIL
3015 is_interactive = on;
3016 if (do_banner == 0 && is_interactive) {
3017 /* Looks like they want an interactive shell */
3018 #ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
3019 printf("\n\n" BB_BANNER " Built-in shell (ash)\n");
3020 printf("Enter 'help' for a list of built-in commands.\n\n");
3026 static void optschanged(void)
3028 setinteractive(iflag);
3033 static int execcmd(int argc, char **argv)
3038 iflag = 0; /* exit on error */
3041 for (sp = cmdenviron; sp; sp = sp->next)
3042 setvareq(sp->text, VEXPORT | VSTACK);
3043 shellexec(argv + 1, environment(), pathval(), 0);
3048 static void eprintlist(struct strlist *sp)
3050 for (; sp; sp = sp->next) {
3051 out2fmt(" %s", sp->text);
3056 * Exec a program. Never returns. If you change this routine, you may
3057 * have to change the find_command routine as well.
3060 static const char *pathopt; /* set by padvance */
3062 static void shellexec(char **argv, char **envp, const char *path, int idx)
3067 if (strchr(argv[0], '/') != NULL
3068 #ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
3069 || find_applet_by_name(argv[0])
3073 tryexec(argv[0], argv, envp);
3077 while ((cmdname = padvance(&path, argv[0])) != NULL) {
3078 if (--idx < 0 && pathopt == NULL) {
3079 tryexec(cmdname, argv, envp);
3080 if (errno != ENOENT && errno != ENOTDIR)
3087 /* Map to POSIX errors */
3099 exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC));
3104 * Clear traps on a fork.
3106 static void clear_traps(void)
3110 for (tp = trap; tp < &trap[NSIG]; tp++) {
3111 if (*tp && **tp) { /* trap not NULL or SIG_IGN */
3116 setsignal(tp - trap);
3123 static int preadbuffer(void);
3124 static void pushfile(void);
3127 * Read a character from the script, returning PEOF on end of file.
3128 * Nul characters in the input are silently discarded.
3131 #ifndef CONFIG_ASH_OPTIMIZE_FOR_SIZE
3132 #define pgetc_macro() (--parsenleft >= 0? *parsenextc++ : preadbuffer())
3133 static int pgetc(void)
3135 return pgetc_macro();
3138 static int pgetc_macro(void)
3140 return --parsenleft >= 0 ? *parsenextc++ : preadbuffer();
3143 static inline int pgetc(void)
3145 return pgetc_macro();
3151 * Undo the last call to pgetc. Only one character may be pushed back.
3152 * PEOF may be pushed back.
3155 static void pungetc(void)
3162 static void popfile(void)
3164 struct parsefile *pf = parsefile;
3172 parsefile = pf->prev;
3174 parsenleft = parsefile->nleft;
3175 parselleft = parsefile->lleft;
3176 parsenextc = parsefile->nextc;
3177 plinno = parsefile->linno;
3183 * Return to top level.
3186 static void popallfiles(void)
3188 while (parsefile != &basepf)
3193 * Close the file(s) that the shell is reading commands from. Called
3194 * after a fork is done.
3197 static void closescript(void)
3200 if (parsefile->fd > 0) {
3201 close(parsefile->fd);
3208 * Like setinputfile, but takes an open file descriptor. Call this with
3212 static void setinputfd(int fd, int push)
3214 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
3220 while (parsefile->strpush)
3224 if (parsefile->buf == NULL)
3225 parsefile->buf = xmalloc(BUFSIZ);
3226 parselleft = parsenleft = 0;
3232 * Set the input to take input from a file. If push is set, push the
3233 * old input onto the stack first.
3236 static void setinputfile(const char *fname, int push)
3242 if ((fd = open(fname, O_RDONLY)) < 0)
3243 error("Can't open %s", fname);
3245 myfileno2 = dup_as_newfd(fd, 10);
3248 error("Out of file descriptors");
3251 setinputfd(fd, push);
3256 static void tryexec(char *cmd, char **argv, char **envp)
3260 #ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
3262 char **argv_l = argv;
3265 #ifdef CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN
3266 name = get_last_path_component(name);
3269 for (argc_l = 0; *argv_l != NULL; argv_l++, argc_l++)
3272 for (argc_l = 0; *argv_l != NULL; argv_l++, argc_l++)
3274 run_applet_by_name(name, argc_l, argv);
3277 execve(cmd, argv, envp);
3280 } else if (errno == ENOEXEC) {
3284 for (ap = argv; *ap; ap++);
3285 ap = new = xmalloc((ap - argv + 2) * sizeof(char *));
3286 *ap++ = cmd = "/bin/sh";
3287 while ((*ap++ = *argv++));
3293 static char *commandtext(const union node *);
3296 * Do a path search. The variable path (passed by reference) should be
3297 * set to the start of the path before the first call; padvance will update
3298 * this value as it proceeds. Successive calls to padvance will return
3299 * the possible path expansions in sequence. If an option (indicated by
3300 * a percent sign) appears in the path entry then the global variable
3301 * pathopt will be set to point to it; otherwise pathopt will be set to
3305 static const char *pathopt;
3307 static void growstackblock(void);
3310 static char *padvance(const char **path, const char *name)
3320 for (p = start; *p && *p != ':' && *p != '%'; p++);
3321 len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */
3322 while (stackblocksize() < len)
3326 memcpy(q, start, p - start);
3334 while (*p && *p != ':')
3341 return stalloc(len);
3345 * Wrapper around strcmp for qsort/bsearch/...
3347 static int pstrcmp(const void *a, const void *b)
3349 return strcmp((const char *) a, (*(const char *const *) b) + 1);
3353 * Find a keyword is in a sorted array.
3356 static const char *const *findkwd(const char *s)
3358 return bsearch(s, tokname_array + KWDOFFSET,
3359 (sizeof(tokname_array) / sizeof(const char *)) - KWDOFFSET,
3360 sizeof(const char *), pstrcmp);
3364 /*** Command hashing code ***/
3366 static int hashcmd(int argc, char **argv)
3368 struct tblentry **pp;
3369 struct tblentry *cmdp;
3372 struct cmdentry entry;
3375 #ifdef CONFIG_ASH_ALIAS
3376 const struct alias *ap;
3380 while ((c = nextopt("rvV")) != '\0') {
3384 } else if (c == 'v' || c == 'V') {
3388 if (*argptr == NULL) {
3389 for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
3390 for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
3391 if (cmdp->cmdtype != CMDBUILTIN) {
3392 printentry(cmdp, verbose);
3399 while ((name = *argptr++) != NULL) {
3400 if ((cmdp = cmdlookup(name, 0)) != NULL
3401 && (cmdp->cmdtype == CMDNORMAL
3402 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
3404 #ifdef CONFIG_ASH_ALIAS
3405 /* Then look at the aliases */
3406 if ((ap = *__lookupalias(name)) != NULL) {
3408 printf("%s is an alias for %s\n", name, ap->val);
3414 /* First look at the keywords */
3415 if (findkwd(name) != 0) {
3417 printf("%s is a shell keyword\n", name);
3423 find_command(name, &entry, DO_ERR, pathval());
3424 if (entry.cmdtype == CMDUNKNOWN)
3427 cmdp = cmdlookup(name, 0);
3429 printentry(cmdp, verbose == 'v');
3436 static void printentry(struct tblentry *cmdp, int verbose)
3442 printf("%s%s", cmdp->cmdname, (verbose ? " is " : ""));
3443 if (cmdp->cmdtype == CMDNORMAL) {
3444 idx = cmdp->param.index;
3447 name = padvance(&path, cmdp->cmdname);
3449 } while (--idx >= 0);
3452 } else if (cmdp->cmdtype == CMDBUILTIN) {
3454 out1str("a shell builtin");
3455 } else if (cmdp->cmdtype == CMDFUNCTION) {
3458 out1str("a function\n");
3459 name = commandtext(cmdp->param.func);
3460 printf("%s() {\n %s\n}", cmdp->cmdname, name);
3466 error("internal error: cmdtype %d", cmdp->cmdtype);
3469 puts(cmdp->rehash ? "*" : nullstr);
3474 /*** List the available builtins ***/
3477 static int helpcmd(int argc, char **argv)
3481 printf("\nBuilt-in commands:\n-------------------\n");
3482 for (col = 0, i = 0; i < NUMBUILTINS; i++) {
3483 col += printf("%c%s", ((col == 0) ? '\t' : ' '),
3484 builtincmds[i].name + 1);
3490 #ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
3492 extern const struct BB_applet applets[];
3493 extern const size_t NUM_APPLETS;
3495 for (i = 0; i < NUM_APPLETS; i++) {
3497 col += printf("%c%s", ((col == 0) ? '\t' : ' '), applets[i].name);
3506 return EXIT_SUCCESS;
3510 * Resolve a command name. If you change this routine, you may have to
3511 * change the shellexec routine as well.
3514 static int prefix(const char *, const char *);
3517 find_command(const char *name, struct cmdentry *entry, int act,
3520 struct tblentry *cmdp;
3530 struct builtincmd *bcmd;
3532 /* If name contains a slash, don't use the hash table */
3533 if (strchr(name, '/') != NULL) {
3535 while (stat(name, &statb) < 0) {
3536 if (errno != ENOENT && errno != ENOTDIR)
3538 entry->cmdtype = CMDUNKNOWN;
3539 entry->u.index = -1;
3542 entry->cmdtype = CMDNORMAL;
3543 entry->u.index = -1;
3546 entry->cmdtype = CMDNORMAL;
3551 #ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
3552 if (find_applet_by_name(name)) {
3553 entry->cmdtype = CMDNORMAL;
3554 entry->u.index = -1;
3560 if (act & DO_BRUTE) {
3561 firstchange = path_change(path, &bltin);
3567 /* If name is in the table, and not invalidated by cd, we're done */
3568 if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0) {
3569 if (cmdp->cmdtype == CMDFUNCTION) {
3570 if (act & DO_NOFUN) {
3575 } else if (act & DO_BRUTE) {
3576 if ((cmdp->cmdtype == CMDNORMAL &&
3577 cmdp->param.index >= firstchange) ||
3578 (cmdp->cmdtype == CMDBUILTIN &&
3579 ((builtinloc < 0 && bltin >= 0) ?
3580 bltin : builtinloc) >= firstchange)) {
3581 /* need to recompute the entry */
3590 bcmd = find_builtin(name);
3591 regular = bcmd && IS_BUILTIN_REGULAR(bcmd);
3594 if (cmdp && (cmdp->cmdtype == CMDBUILTIN)) {
3597 } else if (act & DO_BRUTE) {
3598 if (firstchange == 0) {
3603 /* If %builtin not in path, check for builtin next */
3604 if (regular || (bltin < 0 && bcmd)) {
3607 entry->cmdtype = CMDBUILTIN;
3608 entry->u.cmd = bcmd;
3612 cmdp = cmdlookup(name, 1);
3613 cmdp->cmdtype = CMDBUILTIN;
3614 cmdp->param.cmd = bcmd;
3619 /* We have to search path. */
3620 prev = -1; /* where to start */
3621 if (cmdp && cmdp->rehash) { /* doing a rehash */
3622 if (cmdp->cmdtype == CMDBUILTIN)
3625 prev = cmdp->param.index;
3631 while ((fullname = padvance(&path, name)) != NULL) {
3632 stunalloc(fullname);
3634 if (idx >= firstchange) {
3638 if (prefix("builtin", pathopt)) {
3639 if ((bcmd = find_builtin(name))) {
3643 } else if (!(act & DO_NOFUN) && prefix("func", pathopt)) {
3646 continue; /* ignore unimplemented options */
3649 /* if rehash, don't redo absolute path names */
3650 if (fullname[0] == '/' && idx <= prev && idx < firstchange) {
3653 TRACE(("searchexec \"%s\": no change\n", name));
3656 while (stat(fullname, &statb) < 0) {
3657 if (errno != ENOENT && errno != ENOTDIR)
3661 e = EACCES; /* if we fail, this will be the error */
3662 if (!S_ISREG(statb.st_mode))
3664 if (pathopt) { /* this is a %func directory */
3665 stalloc(strlen(fullname) + 1);
3666 readcmdfile(fullname);
3667 if ((cmdp = cmdlookup(name, 0)) == NULL
3668 || cmdp->cmdtype != CMDFUNCTION)
3669 error("%s not defined in %s", name, fullname);
3670 stunalloc(fullname);
3673 TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
3674 /* If we aren't called with DO_BRUTE and cmdp is set, it must
3675 be a function and we're being called with DO_NOFUN */
3677 entry->cmdtype = CMDNORMAL;
3678 entry->u.index = idx;
3682 cmdp = cmdlookup(name, 1);
3683 cmdp->cmdtype = CMDNORMAL;
3684 cmdp->param.index = idx;
3689 /* We failed. If there was an entry for this command, delete it */
3690 if (cmdp && updatetbl)
3693 out2fmt("%s: %s\n", name, errmsg(e, E_EXEC));
3694 entry->cmdtype = CMDUNKNOWN;
3699 entry->cmdtype = cmdp->cmdtype;
3700 entry->u = cmdp->param;
3706 * Search the table of builtin commands.
3709 static struct builtincmd *find_builtin(const char *name)
3711 struct builtincmd *bp;
3713 bp = bsearch(name, builtincmds, NUMBUILTINS, sizeof(struct builtincmd),
3720 * Called when a cd is done. Marks all commands so the next time they
3721 * are executed they will be rehashed.
3724 static void hashcd(void)
3726 struct tblentry **pp;
3727 struct tblentry *cmdp;
3729 for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
3730 for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
3731 if (cmdp->cmdtype == CMDNORMAL
3732 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))
3741 * Called before PATH is changed. The argument is the new value of PATH;
3742 * pathval() still returns the old value at this point. Called with
3746 static void changepath(const char *newval)
3751 firstchange = path_change(newval, &bltin);
3752 if (builtinloc < 0 && bltin >= 0)
3753 builtinloc = bltin; /* zap builtins */
3754 clearcmdentry(firstchange);
3756 /* Ensure that getenv("PATH") stays current */
3757 setenv("PATH", newval, 1);
3762 * Clear out command entries. The argument specifies the first entry in
3763 * PATH which has changed.
3766 static void clearcmdentry(int firstchange)
3768 struct tblentry **tblp;
3769 struct tblentry **pp;
3770 struct tblentry *cmdp;
3773 for (tblp = cmdtable; tblp < &cmdtable[CMDTABLESIZE]; tblp++) {
3775 while ((cmdp = *pp) != NULL) {
3776 if ((cmdp->cmdtype == CMDNORMAL &&
3777 cmdp->param.index >= firstchange)
3778 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= firstchange)) {
3791 * Locate a command in the command hash table. If "add" is nonzero,
3792 * add the command to the table if it is not already present. The
3793 * variable "lastcmdentry" is set to point to the address of the link
3794 * pointing to the entry, so that delete_cmd_entry can delete the
3798 static struct tblentry **lastcmdentry;
3800 static struct tblentry *cmdlookup(const char *name, int add)
3804 struct tblentry *cmdp;
3805 struct tblentry **pp;
3812 pp = &cmdtable[hashval % CMDTABLESIZE];
3813 for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
3814 if (equal(cmdp->cmdname, name))
3818 if (add && cmdp == NULL) {
3820 cmdp = *pp = xmalloc(sizeof(struct tblentry) - ARB
3821 + strlen(name) + 1);
3823 cmdp->cmdtype = CMDUNKNOWN;
3825 strcpy(cmdp->cmdname, name);
3833 * Delete the command entry returned on the last lookup.
3836 static void delete_cmd_entry(void)
3838 struct tblentry *cmdp;
3841 cmdp = *lastcmdentry;
3842 *lastcmdentry = cmdp->next;
3851 static const unsigned char nodesize[26] = {
3852 ALIGN(sizeof(struct nbinary)),
3853 ALIGN(sizeof(struct ncmd)),
3854 ALIGN(sizeof(struct npipe)),
3855 ALIGN(sizeof(struct nredir)),
3856 ALIGN(sizeof(struct nredir)),
3857 ALIGN(sizeof(struct nredir)),
3858 ALIGN(sizeof(struct nbinary)),
3859 ALIGN(sizeof(struct nbinary)),
3860 ALIGN(sizeof(struct nif)),
3861 ALIGN(sizeof(struct nbinary)),
3862 ALIGN(sizeof(struct nbinary)),
3863 ALIGN(sizeof(struct nfor)),
3864 ALIGN(sizeof(struct ncase)),
3865 ALIGN(sizeof(struct nclist)),
3866 ALIGN(sizeof(struct narg)),
3867 ALIGN(sizeof(struct narg)),
3868 ALIGN(sizeof(struct nfile)),
3869 ALIGN(sizeof(struct nfile)),
3870 ALIGN(sizeof(struct nfile)),
3871 ALIGN(sizeof(struct nfile)),
3872 ALIGN(sizeof(struct nfile)),
3873 ALIGN(sizeof(struct ndup)),
3874 ALIGN(sizeof(struct ndup)),
3875 ALIGN(sizeof(struct nhere)),
3876 ALIGN(sizeof(struct nhere)),
3877 ALIGN(sizeof(struct nnot)),
3883 * Delete a function if it exists.
3886 static void unsetfunc(char *name)
3888 struct tblentry *cmdp;
3890 if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->cmdtype == CMDFUNCTION) {
3891 free(cmdp->param.func);
3898 * Locate and print what a word is...
3901 static int typecmd(int argc, char **argv)
3909 for (i = 1; i < argc; i++) {
3910 argv_a[0] = argv[i];
3913 err |= hashcmd(argc, argv);
3918 #ifdef CONFIG_ASH_CMDCMD
3919 static int commandcmd(int argc, char **argv)
3922 int default_path = 0;
3923 int verify_only = 0;
3924 int verbose_verify_only = 0;
3926 while ((c = nextopt("pvV")) != '\0')
3935 verbose_verify_only = 1;
3939 if (default_path + verify_only + verbose_verify_only > 1 || !*argptr) {
3940 out2str("command [-p] command [arg ...]\n"
3941 "command {-v|-V} command\n");
3945 if (verify_only || verbose_verify_only) {
3949 argv_a[0] = *argptr;
3951 optptr = verbose_verify_only ? "v" : "V"; /* reverse special */
3952 return hashcmd(argc, argv);
3959 static int path_change(const char *newval, int *bltin)
3961 const char *old, *new;
3967 firstchange = 9999; /* assume no change */
3973 if ((*old == '\0' && *new == ':')
3974 || (*old == ':' && *new == '\0'))
3976 old = new; /* ignore subsequent differences */
3980 if (*new == '%' && *bltin < 0 && prefix("builtin", new + 1))
3987 if (builtinloc >= 0 && *bltin < 0)
3993 * Routines to expand arguments to commands. We have to deal with
3994 * backquotes, shell variables, and file metacharacters.
3999 #define RMESCAPE_ALLOC 0x1 /* Allocate a new string */
4000 #define RMESCAPE_GLOB 0x2 /* Add backslashes for glob */
4003 * Structure specifying which parts of the string should be searched
4004 * for IFS characters.
4008 struct ifsregion *next; /* next region in list */
4009 int begoff; /* offset of start of region */
4010 int endoff; /* offset of end of region */
4011 int nulonly; /* search for nul bytes only */
4015 static char *expdest; /* output of current string */
4016 static struct nodelist *argbackq; /* list of back quote expressions */
4017 static struct ifsregion ifsfirst; /* first struct in list of ifs regions */
4018 static struct ifsregion *ifslastp; /* last struct in list */
4019 static struct arglist exparg; /* holds expanded arg list */
4021 static void argstr(char *, int);
4022 static char *exptilde(char *, int);
4023 static void expbackq(union node *, int, int);
4024 static int subevalvar(char *, char *, int, int, int, int, int);
4025 static int varisset(char *, int);
4026 static void strtodest(const char *, int, int);
4027 static void varvalue(char *, int, int);
4028 static void recordregion(int, int, int);
4029 static void removerecordregions(int);
4030 static void ifsbreakup(char *, struct arglist *);
4031 static void ifsfree(void);
4032 static void expandmeta(struct strlist *, int);
4034 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
4035 #define preglob(p) _rmescapes((p), RMESCAPE_ALLOC | RMESCAPE_GLOB)
4036 #if !defined(GLOB_BROKEN)
4037 static void addglob(const glob_t *);
4040 #if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
4041 static void expmeta(char *, char *);
4043 #if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
4044 static struct strlist *expsort(struct strlist *);
4045 static struct strlist *msort(struct strlist *, int);
4047 static int patmatch(char *, char *, int);
4049 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
4050 static int patmatch2(char *, char *, int);
4052 static int pmatch(char *, char *, int);
4054 #define patmatch2 patmatch
4056 static char *cvtnum(int, char *);
4059 * Expand shell variables and backquotes inside a here document.
4062 /* arg: the document, fd: where to write the expanded version */
4063 static inline void expandhere(union node *arg, int fd)
4066 expandarg(arg, (struct arglist *) NULL, 0);
4067 xwrite(fd, stackblock(), expdest - stackblock());
4072 * Perform variable substitution and command substitution on an argument,
4073 * placing the resulting list of arguments in arglist. If EXP_FULL is true,
4074 * perform splitting and file name expansion. When arglist is NULL, perform
4075 * here document expansion.
4078 static void expandarg(union node *arg, struct arglist *arglist, int flag)
4083 argbackq = arg->narg.backquote;
4084 STARTSTACKSTR(expdest);
4085 ifsfirst.next = NULL;
4087 argstr(arg->narg.text, flag);
4088 if (arglist == NULL) {
4089 return; /* here document expanded */
4091 STPUTC('\0', expdest);
4092 p = grabstackstr(expdest);
4093 exparg.lastp = &exparg.list;
4097 if (flag & EXP_FULL) {
4098 ifsbreakup(p, &exparg);
4099 *exparg.lastp = NULL;
4100 exparg.lastp = &exparg.list;
4101 expandmeta(exparg.list, flag);
4103 if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
4105 sp = (struct strlist *) stalloc(sizeof(struct strlist));
4108 exparg.lastp = &sp->next;
4111 *exparg.lastp = NULL;
4113 *arglist->lastp = exparg.list;
4114 arglist->lastp = exparg.lastp;
4120 * Expand a variable, and return a pointer to the next character in the
4124 static inline char *evalvar(char *p, int flag)
4137 int quotes = flag & (EXP_FULL | EXP_CASE);
4140 subtype = varflags & VSTYPE;
4145 p = strchr(p, '=') + 1;
4146 again: /* jump here after setting a variable with ${var=text} */
4148 set = varisset(var, varflags & VSNUL);
4151 val = lookupvar(var);
4152 if (val == NULL || ((varflags & VSNUL) && val[0] == '\0')) {
4159 startloc = expdest - stackblock();
4160 if (set && subtype != VSPLUS) {
4161 /* insert the value of the variable */
4163 varvalue(var, varflags & VSQUOTE, flag);
4164 if (subtype == VSLENGTH) {
4165 varlen = expdest - stackblock() - startloc;
4166 STADJUST(-varlen, expdest);
4169 if (subtype == VSLENGTH) {
4170 varlen = strlen(val);
4173 varflags & VSQUOTE ? DQSYNTAX : BASESYNTAX, quotes);
4178 if (subtype == VSPLUS)
4181 easy = ((varflags & VSQUOTE) == 0 ||
4182 (*var == '@' && shellparam.nparam != 1));
4187 expdest = cvtnum(varlen, expdest);
4194 recordregion(startloc, expdest - stackblock(), varflags & VSQUOTE);
4210 case VSTRIMRIGHTMAX:
4214 * Terminate the string and start recording the pattern
4217 STPUTC('\0', expdest);
4218 patloc = expdest - stackblock();
4219 if (subevalvar(p, NULL, patloc, subtype,
4220 startloc, varflags, quotes) == 0) {
4221 int amount = (expdest - stackblock() - patloc) + 1;
4223 STADJUST(-amount, expdest);
4225 /* Remove any recorded regions beyond start of variable */
4226 removerecordregions(startloc);
4232 if (subevalvar(p, var, 0, subtype, startloc, varflags, quotes)) {
4235 * Remove any recorded regions beyond
4238 removerecordregions(startloc);
4253 if (subtype != VSNORMAL) { /* skip to end of alternative */
4257 if ((c = *p++) == CTLESC)
4259 else if (c == CTLBACKQ || c == (CTLBACKQ | CTLQUOTE)) {
4261 argbackq = argbackq->next;
4262 } else if (c == CTLVAR) {
4263 if ((*p++ & VSTYPE) != VSNORMAL)
4265 } else if (c == CTLENDVAR) {
4276 * Perform variable and command substitution. If EXP_FULL is set, output CTLESC
4277 * characters to allow for further processing. Otherwise treat
4278 * $@ like $* since no splitting will be performed.
4281 static void argstr(char *p, int flag)
4284 int quotes = flag & (EXP_FULL | EXP_CASE); /* do CTLESC */
4287 if (*p == '~' && (flag & (EXP_TILDE | EXP_VARTILDE)))
4288 p = exptilde(p, flag);
4292 case CTLENDVAR: /* ??? */
4295 /* "$@" syntax adherence hack */
4296 if (p[0] == CTLVAR && p[2] == '@' && p[3] == '=')
4298 if ((flag & EXP_FULL) != 0)
4308 p = evalvar(p, flag);
4311 case CTLBACKQ | CTLQUOTE:
4312 expbackq(argbackq->n, c & CTLQUOTE, flag);
4313 argbackq = argbackq->next;
4315 #ifdef CONFIG_ASH_MATH_SUPPORT
4323 * sort of a hack - expand tildes in variable
4324 * assignments (after the first '=' and after ':'s).
4327 if (flag & EXP_VARTILDE && *p == '~') {
4334 p = exptilde(p, flag);
4343 static char *exptilde(char *p, int flag)
4345 char c, *startp = p;
4348 int quotes = flag & (EXP_FULL | EXP_CASE);
4350 while ((c = *p) != '\0') {
4357 if (flag & EXP_VARTILDE)
4367 if (*(startp + 1) == '\0') {
4368 if ((home = lookupvar("HOME")) == NULL)
4371 if ((pw = getpwnam(startp + 1)) == NULL)
4378 strtodest(home, SQSYNTAX, quotes);
4386 static void removerecordregions(int endoff)
4388 if (ifslastp == NULL)
4391 if (ifsfirst.endoff > endoff) {
4392 while (ifsfirst.next != NULL) {
4393 struct ifsregion *ifsp;
4396 ifsp = ifsfirst.next->next;
4397 free(ifsfirst.next);
4398 ifsfirst.next = ifsp;
4401 if (ifsfirst.begoff > endoff)
4404 ifslastp = &ifsfirst;
4405 ifsfirst.endoff = endoff;
4410 ifslastp = &ifsfirst;
4411 while (ifslastp->next && ifslastp->next->begoff < endoff)
4412 ifslastp = ifslastp->next;
4413 while (ifslastp->next != NULL) {
4414 struct ifsregion *ifsp;
4417 ifsp = ifslastp->next->next;
4418 free(ifslastp->next);
4419 ifslastp->next = ifsp;
4422 if (ifslastp->endoff > endoff)
4423 ifslastp->endoff = endoff;
4427 #ifdef CONFIG_ASH_MATH_SUPPORT
4429 * Expand arithmetic expression. Backup to start of expression,
4430 * evaluate, place result in (backed up) result, adjust string position.
4432 static void expari(int flag)
4438 int quotes = flag & (EXP_FULL | EXP_CASE);
4444 * This routine is slightly over-complicated for
4445 * efficiency. First we make sure there is
4446 * enough space for the result, which may be bigger
4447 * than the expression if we add exponentation. Next we
4448 * scan backwards looking for the start of arithmetic. If the
4449 * next previous character is a CTLESC character, then we
4450 * have to rescan starting from the beginning since CTLESC
4451 * characters have to be processed left to right.
4453 CHECKSTRSPACE(10, expdest);
4454 USTPUTC('\0', expdest);
4455 start = stackblock();
4457 while (*p != CTLARI && p >= start)
4460 error("missing CTLARI (shouldn't happen)");
4461 if (p > start && *(p - 1) == CTLESC)
4462 for (p = start; *p != CTLARI; p++)
4471 removerecordregions(begoff);
4474 result = arith(p + 2, &errcode);
4477 error("divide by zero");
4479 error("syntax error: \"%s\"\n", p + 2);
4481 snprintf(p, 12, "%d", result);
4485 recordregion(begoff, p - 1 - start, 0);
4486 result = expdest - p + 1;
4487 STADJUST(-result, expdest);
4492 * Expand stuff in backwards quotes.
4495 static void expbackq(union node *cmd, int quoted, int flag)
4497 volatile struct backcmd in;
4501 char *dest = expdest;
4502 volatile struct ifsregion saveifs;
4503 struct ifsregion *volatile savelastp;
4504 struct nodelist *volatile saveargbackq;
4506 int startloc = dest - stackblock();
4507 int syntax = quoted ? DQSYNTAX : BASESYNTAX;
4508 volatile int saveherefd;
4509 int quotes = flag & (EXP_FULL | EXP_CASE);
4510 struct jmploc jmploc;
4511 struct jmploc *volatile savehandler;
4515 /* Avoid longjmp clobbering */
4526 savelastp = ifslastp;
4527 saveargbackq = argbackq;
4528 saveherefd = herefd;
4530 if ((ex = setjmp(jmploc.loc))) {
4533 savehandler = handler;
4536 p = grabstackstr(dest);
4537 evalbackcmd(cmd, (struct backcmd *) &in);
4538 ungrabstackstr(p, dest);
4542 ifslastp = savelastp;
4543 argbackq = saveargbackq;
4544 herefd = saveherefd;
4552 if (--in.nleft < 0) {
4555 i = safe_read(in.fd, buf, sizeof buf);
4556 TRACE(("expbackq: read returns %d\n", i));
4563 if (lastc != '\0') {
4564 if (quotes && SIT(lastc, syntax) == CCTL)
4565 STPUTC(CTLESC, dest);
4566 STPUTC(lastc, dest);
4570 /* Eat all trailing newlines */
4571 for (; dest > stackblock() && dest[-1] == '\n';)
4579 exitstatus = waitforjob(in.jp);
4580 handler = savehandler;
4582 longjmp(handler->loc, 1);
4585 recordregion(startloc, dest - stackblock(), 0);
4586 TRACE(("evalbackq: size=%d: \"%.*s\"\n",
4587 (dest - stackblock()) - startloc,
4588 (dest - stackblock()) - startloc, stackblock() + startloc));
4594 subevalvar(char *p, char *str, int strloc, int subtype, int startloc,
4595 int varflags, int quotes)
4601 int saveherefd = herefd;
4602 struct nodelist *saveargbackq = argbackq;
4606 argstr(p, subtype != VSASSIGN && subtype != VSQUESTION ? EXP_CASE : 0);
4607 STACKSTRNUL(expdest);
4608 herefd = saveherefd;
4609 argbackq = saveargbackq;
4610 startp = stackblock() + startloc;
4612 str = stackblock() + strloc;
4616 setvar(str, startp, 0);
4617 amount = startp - expdest;
4618 STADJUST(amount, expdest);
4625 if (*p != CTLENDVAR) {
4626 out2fmt(snlfmt, startp);
4627 error((char *) NULL);
4629 error("%.*s: parameter %snot set", p - str - 1,
4630 str, (varflags & VSNUL) ? "null or " : nullstr);
4634 for (loc = startp; loc < str; loc++) {
4637 if (patmatch2(str, startp, quotes))
4640 if (quotes && *loc == CTLESC)
4646 for (loc = str - 1; loc >= startp;) {
4649 if (patmatch2(str, startp, quotes))
4653 if (quotes && loc > startp && *(loc - 1) == CTLESC) {
4654 for (q = startp; q < loc; q++)
4664 for (loc = str - 1; loc >= startp;) {
4665 if (patmatch2(str, loc, quotes))
4668 if (quotes && loc > startp && *(loc - 1) == CTLESC) {
4669 for (q = startp; q < loc; q++)
4678 case VSTRIMRIGHTMAX:
4679 for (loc = startp; loc < str - 1; loc++) {
4680 if (patmatch2(str, loc, quotes))
4682 if (quotes && *loc == CTLESC)
4695 amount = ((str - 1) - (loc - startp)) - expdest;
4696 STADJUST(amount, expdest);
4697 while (loc != str - 1)
4702 amount = loc - expdest;
4703 STADJUST(amount, expdest);
4704 STPUTC('\0', expdest);
4705 STADJUST(-1, expdest);
4711 * Test whether a specialized variable is set.
4714 static int varisset(char *name, int nulok)
4717 return backgndpid != -1;
4718 else if (*name == '@' || *name == '*') {
4719 if (*shellparam.p == NULL)
4725 for (av = shellparam.p; *av; av++)
4730 } else if (is_digit(*name)) {
4732 int num = atoi(name);
4734 if (num > shellparam.nparam)
4740 ap = shellparam.p[num - 1];
4742 if (nulok && (ap == NULL || *ap == '\0'))
4749 * Put a string on the stack.
4752 static void strtodest(const char *p, int syntax, int quotes)
4755 if (quotes && SIT(*p, syntax) == CCTL)
4756 STPUTC(CTLESC, expdest);
4757 STPUTC(*p++, expdest);
4762 * Add the value of a specialized variable to the stack string.
4765 static void varvalue(char *name, int quoted, int flags)
4774 int allow_split = flags & EXP_FULL;
4775 int quotes = flags & (EXP_FULL | EXP_CASE);
4777 syntax = quoted ? DQSYNTAX : BASESYNTAX;
4786 num = shellparam.nparam;
4791 expdest = cvtnum(num, expdest);
4794 for (i = 0; i < NOPTS; i++) {
4796 STPUTC(optent_letter(optlist[i]), expdest);
4800 if (allow_split && quoted) {
4801 sep = 1 << CHAR_BIT;
4806 sep = ifsset()? ifsval()[0] : ' ';
4808 sepq = SIT(sep, syntax) == CCTL;
4811 for (ap = shellparam.p; (p = *ap++) != NULL;) {
4812 strtodest(p, syntax, quotes);
4815 STPUTC(CTLESC, expdest);
4816 STPUTC(sep, expdest);
4821 strtodest(arg0, syntax, quotes);
4825 if (num > 0 && num <= shellparam.nparam) {
4826 strtodest(shellparam.p[num - 1], syntax, quotes);
4834 * Record the fact that we have to scan this region of the
4835 * string for IFS characters.
4838 static void recordregion(int start, int end, int nulonly)
4840 struct ifsregion *ifsp;
4842 if (ifslastp == NULL) {
4846 ifsp = (struct ifsregion *) xmalloc(sizeof(struct ifsregion));
4848 ifslastp->next = ifsp;
4852 ifslastp->begoff = start;
4853 ifslastp->endoff = end;
4854 ifslastp->nulonly = nulonly;
4860 * Break the argument string into pieces based upon IFS and add the
4861 * strings to the argument list. The regions of the string to be
4862 * searched for IFS characters have been stored by recordregion.
4864 static void ifsbreakup(char *string, struct arglist *arglist)
4866 struct ifsregion *ifsp;
4871 const char *ifs, *realifs;
4879 realifs = ifsset()? ifsval() : defifs;
4880 if (ifslastp != NULL) {
4883 p = string + ifsp->begoff;
4884 nulonly = ifsp->nulonly;
4885 ifs = nulonly ? nullstr : realifs;
4887 while (p < string + ifsp->endoff) {
4891 if (strchr(ifs, *p)) {
4893 ifsspc = (strchr(defifs, *p) != NULL);
4894 /* Ignore IFS whitespace at start */
4895 if (q == start && ifsspc) {
4901 sp = (struct strlist *) stalloc(sizeof *sp);
4903 *arglist->lastp = sp;
4904 arglist->lastp = &sp->next;
4908 if (p >= string + ifsp->endoff) {
4914 if (strchr(ifs, *p) == NULL) {
4917 } else if (strchr(defifs, *p) == NULL) {
4933 } while ((ifsp = ifsp->next) != NULL);
4934 if (!(*start || (!ifsspc && start > string && nulonly))) {
4939 sp = (struct strlist *) stalloc(sizeof *sp);
4941 *arglist->lastp = sp;
4942 arglist->lastp = &sp->next;
4945 static void ifsfree(void)
4947 while (ifsfirst.next != NULL) {
4948 struct ifsregion *ifsp;
4951 ifsp = ifsfirst.next->next;
4952 free(ifsfirst.next);
4953 ifsfirst.next = ifsp;
4957 ifsfirst.next = NULL;
4961 * Add a file name to the list.
4964 static void addfname(const char *name)
4967 size_t len = strlen(name) + 1;
4969 sp = (struct strlist *) stalloc(sizeof *sp);
4970 sp->text = memcpy(stalloc(len), name, len);
4972 exparg.lastp = &sp->next;
4976 * Expand shell metacharacters. At this point, the only control characters
4977 * should be escapes. The results are stored in the list exparg.
4980 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN)
4981 static void expandmeta(struct strlist *str, int flag)
4986 /* TODO - EXP_REDIR */
4991 p = preglob(str->text);
4993 switch (glob(p, 0, 0, &pglob)) {
4995 if (pglob.gl_pathv[1] == 0 && !strcmp(p, pglob.gl_pathv[0]))
5006 *exparg.lastp = str;
5007 rmescapes(str->text);
5008 exparg.lastp = &str->next;
5010 default: /* GLOB_NOSPACE */
5011 error("Out of space");
5019 * Add the result of glob(3) to the list.
5022 static void addglob(const glob_t * pglob)
5024 char **p = pglob->gl_pathv;
5032 #else /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
5033 static char *expdir;
5036 static void expandmeta(struct strlist *str, int flag)
5039 struct strlist **savelastp;
5043 /* TODO - EXP_REDIR */
5049 for (;;) { /* fast check for meta chars */
5050 if ((c = *p++) == '\0')
5052 if (c == '*' || c == '?' || c == '[' || c == '!')
5055 savelastp = exparg.lastp;
5057 if (expdir == NULL) {
5058 int i = strlen(str->text);
5060 expdir = xmalloc(i < 2048 ? 2048 : i); /* XXX */
5063 expmeta(expdir, str->text);
5067 if (exparg.lastp == savelastp) {
5072 *exparg.lastp = str;
5073 rmescapes(str->text);
5074 exparg.lastp = &str->next;
5076 *exparg.lastp = NULL;
5077 *savelastp = sp = expsort(*savelastp);
5078 while (sp->next != NULL)
5080 exparg.lastp = &sp->next;
5088 * Do metacharacter (i.e. *, ?, [...]) expansion.
5091 static void expmeta(char *enddir, char *name)
5107 for (p = name;; p++) {
5108 if (*p == '*' || *p == '?')
5110 else if (*p == '[') {
5115 while (*q == CTLQUOTEMARK)
5119 if (*q == '/' || *q == '\0')
5126 } else if (*p == '!' && p[1] == '!' && (p == name || p[-1] == '/')) {
5128 } else if (*p == '\0')
5130 else if (*p == CTLQUOTEMARK)
5132 else if (*p == CTLESC)
5140 if (metaflag == 0) { /* we've reached the end of the file name */
5141 if (enddir != expdir)
5143 for (p = name;; p++) {
5144 if (*p == CTLQUOTEMARK)
5152 if (metaflag == 0 || lstat(expdir, &statb) >= 0)
5157 if (start != name) {
5160 while (*p == CTLQUOTEMARK)
5167 if (enddir == expdir) {
5169 } else if (enddir == expdir + 1 && *expdir == '/') {
5175 if ((dirp = opendir(cp)) == NULL)
5177 if (enddir != expdir)
5179 if (*endname == 0) {
5187 while (*p == CTLQUOTEMARK)
5193 while (!int_pending() && (dp = readdir(dirp)) != NULL) {
5194 if (dp->d_name[0] == '.' && !matchdot)
5196 if (patmatch(start, dp->d_name, 0)) {
5198 strcpy(enddir, dp->d_name);
5201 for (p = enddir, cp = dp->d_name; (*p++ = *cp++) != '\0';)
5204 expmeta(p, endname);
5212 #endif /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
5216 #if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
5218 * Sort the results of file name expansion. It calculates the number of
5219 * strings to sort and then calls msort (short for merge sort) to do the
5223 static struct strlist *expsort(struct strlist *str)
5229 for (sp = str; sp; sp = sp->next)
5231 return msort(str, len);
5235 static struct strlist *msort(struct strlist *list, int len)
5237 struct strlist *p, *q = NULL;
5238 struct strlist **lpp;
5246 for (n = half; --n >= 0;) {
5250 q->next = NULL; /* terminate first half of list */
5251 q = msort(list, half); /* sort first half of list */
5252 p = msort(p, len - half); /* sort second half */
5255 if (strcmp(p->text, q->text) < 0) {
5258 if ((p = *lpp) == NULL) {
5265 if ((q = *lpp) == NULL) {
5278 * Returns true if the pattern matches the string.
5281 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
5282 /* squoted: string might have quote chars */
5283 static int patmatch(char *pattern, char *string, int squoted)
5288 p = preglob(pattern);
5289 q = squoted ? _rmescapes(string, RMESCAPE_ALLOC) : string;
5291 return !fnmatch(p, q, 0);
5295 static int patmatch2(char *pattern, char *string, int squoted)
5301 p = grabstackstr(expdest);
5302 res = patmatch(pattern, string, squoted);
5303 ungrabstackstr(p, expdest);
5307 static int patmatch(char *pattern, char *string, int squoted)
5309 return pmatch(pattern, string, squoted);
5313 static int pmatch(char *pattern, char *string, int squoted)
5325 if (squoted && *q == CTLESC)
5333 if (squoted && *q == CTLESC)
5340 while (c == CTLQUOTEMARK || c == '*')
5342 if (c != CTLESC && c != CTLQUOTEMARK &&
5343 c != '?' && c != '*' && c != '[') {
5345 if (squoted && *q == CTLESC && q[1] == c)
5349 if (squoted && *q == CTLESC)
5355 if (pmatch(p, q, squoted))
5357 if (squoted && *q == CTLESC)
5359 } while (*q++ != '\0');
5370 while (*endp == CTLQUOTEMARK)
5373 goto dft; /* no matching ] */
5374 if (*endp == CTLESC)
5386 if (squoted && chr == CTLESC)
5392 if (c == CTLQUOTEMARK)
5396 if (*p == '-' && p[1] != ']') {
5398 while (*p == CTLQUOTEMARK)
5402 if (chr >= c && chr <= *p)
5409 } while ((c = *p++) != ']');
5410 if (found == invert)
5415 if (squoted && *q == CTLESC)
5432 * Remove any CTLESC characters from a string.
5435 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
5436 static char *_rmescapes(char *str, int flag)
5439 static const char qchars[] = { CTLESC, CTLQUOTEMARK, 0 };
5441 p = strpbrk(str, qchars);
5447 if (flag & RMESCAPE_ALLOC) {
5448 size_t len = p - str;
5450 q = r = stalloc(strlen(p) + len + 1);
5452 memcpy(q, str, len);
5457 if (*p == CTLQUOTEMARK) {
5463 if (flag & RMESCAPE_GLOB && *p != '/') {
5473 static void rmescapes(char *str)
5478 while (*p != CTLESC && *p != CTLQUOTEMARK) {
5484 if (*p == CTLQUOTEMARK) {
5499 * See if a pattern matches in a case statement.
5502 static int casematch(union node *pattern, const char *val)
5504 struct stackmark smark;
5508 setstackmark(&smark);
5509 argbackq = pattern->narg.backquote;
5510 STARTSTACKSTR(expdest);
5512 argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
5513 STPUTC('\0', expdest);
5514 p = grabstackstr(expdest);
5515 result = patmatch(p, (char *) val, 0);
5516 popstackmark(&smark);
5524 static char *cvtnum(int num, char *buf)
5528 CHECKSTRSPACE(32, buf);
5529 len = sprintf(buf, "%d", num);
5535 * Editline and history functions (and glue).
5537 static int histcmd(int argc, char **argv)
5539 error("not compiled with history support");
5545 struct redirtab *next;
5546 short renamed[10]; /* Current ash support only 0-9 descriptors */
5547 /* char on arm (and others) can't be negative */
5550 static struct redirtab *redirlist;
5552 extern char **environ;
5557 * Initialization code.
5560 static void init(void)
5571 basepf.nextc = basepf.buf = basebuf;
5580 for (envp = environ; *envp; envp++) {
5581 if (strchr(*envp, '=')) {
5582 setvareq(*envp, VEXPORT | VTEXTFIXED);
5586 snprintf(ppid, sizeof(ppid), "%d", (int) getppid());
5587 setvar("PPID", ppid, 0);
5594 * This routine is called when an error or an interrupt occurs in an
5595 * interactive shell and control is returned to the main command loop.
5598 /* 1 == check for aliases, 2 == also check for assignments */
5599 static int checkalias; /* also used in no alias mode for check assignments */
5601 static void reset(void)
5613 parselleft = parsenleft = 0; /* clear input buffer */
5617 /* from parser.c: */
5635 * This file implements the input routines used by the parser.
5638 #ifdef CONFIG_FEATURE_COMMAND_EDITING
5639 static const char *cmdedit_prompt;
5640 static inline void putprompt(const char *s)
5645 static inline void putprompt(const char *s)
5651 #define EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */
5656 * Same as pgetc(), but ignores PEOA.
5659 #ifdef CONFIG_ASH_ALIAS
5660 static int pgetc2(void)
5666 } while (c == PEOA);
5670 static inline int pgetc2(void)
5672 return pgetc_macro();
5677 * Read a line from the script.
5680 static inline char *pfgets(char *line, int len)
5686 while (--nleft > 0) {
5701 static inline int preadfd(void)
5704 char *buf = parsefile->buf;
5709 #ifdef CONFIG_FEATURE_COMMAND_EDITING
5711 if (!iflag || parsefile->fd)
5712 nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
5714 nr = cmdedit_read_input((char *) cmdedit_prompt, buf);
5718 nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
5722 if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
5723 int flags = fcntl(0, F_GETFL, 0);
5725 if (flags >= 0 && flags & O_NONBLOCK) {
5726 flags &= ~O_NONBLOCK;
5727 if (fcntl(0, F_SETFL, flags) >= 0) {
5728 out2str("sh: turning off NDELAY mode\n");
5737 static void popstring(void)
5739 struct strpush *sp = parsefile->strpush;
5742 #ifdef CONFIG_ASH_ALIAS
5744 if (parsenextc[-1] == ' ' || parsenextc[-1] == '\t') {
5749 if (sp->string != sp->ap->val) {
5753 sp->ap->flag &= ~ALIASINUSE;
5754 if (sp->ap->flag & ALIASDEAD) {
5755 unalias(sp->ap->name);
5759 parsenextc = sp->prevstring;
5760 parsenleft = sp->prevnleft;
5761 /*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
5762 parsefile->strpush = sp->prev;
5763 if (sp != &(parsefile->basestrpush))
5770 * Refill the input buffer and return the next input character:
5772 * 1) If a string was pushed back on the input, pop it;
5773 * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
5774 * from a string so we can't refill the buffer, return EOF.
5775 * 3) If the is more stuff in this buffer, use it else call read to fill it.
5776 * 4) Process input up to the next newline, deleting nul characters.
5779 static int preadbuffer(void)
5785 while (parsefile->strpush) {
5786 #ifdef CONFIG_ASH_ALIAS
5787 if (parsenleft == -1 && parsefile->strpush->ap &&
5788 parsenextc[-1] != ' ' && parsenextc[-1] != '\t') {
5793 if (--parsenleft >= 0)
5794 return (*parsenextc++);
5796 if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
5801 if (parselleft <= 0) {
5802 if ((parselleft = preadfd()) <= 0) {
5803 parselleft = parsenleft = EOF_NLEFT;
5810 /* delete nul characters */
5811 for (more = 1; more;) {
5819 parsenleft = q - parsenextc;
5820 more = 0; /* Stop processing here */
5826 if (--parselleft <= 0 && more) {
5827 parsenleft = q - parsenextc - 1;
5838 out2str(parsenextc);
5843 return *parsenextc++;
5848 * Push a string back onto the input at this current parsefile level.
5849 * We handle aliases this way.
5851 static void pushstring(char *s, int len, void *ap)
5856 /*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
5857 if (parsefile->strpush) {
5858 sp = xmalloc(sizeof(struct strpush));
5859 sp->prev = parsefile->strpush;
5860 parsefile->strpush = sp;
5862 sp = parsefile->strpush = &(parsefile->basestrpush);
5863 sp->prevstring = parsenextc;
5864 sp->prevnleft = parsenleft;
5865 #ifdef CONFIG_ASH_ALIAS
5866 sp->ap = (struct alias *) ap;
5868 ((struct alias *) ap)->flag |= ALIASINUSE;
5879 * Like setinputfile, but takes input from a string.
5882 static void setinputstring(char *string)
5886 parsenextc = string;
5887 parsenleft = strlen(string);
5888 parsefile->buf = NULL;
5896 * To handle the "." command, a stack of input files is used. Pushfile
5897 * adds a new entry to the stack and popfile restores the previous level.
5900 static void pushfile(void)
5902 struct parsefile *pf;
5904 parsefile->nleft = parsenleft;
5905 parsefile->lleft = parselleft;
5906 parsefile->nextc = parsenextc;
5907 parsefile->linno = plinno;
5908 pf = (struct parsefile *) xmalloc(sizeof(struct parsefile));
5909 pf->prev = parsefile;
5912 pf->basestrpush.prev = NULL;
5916 #ifdef CONFIG_ASH_JOB_CONTROL
5917 static void restartjob(struct job *);
5919 static void freejob(struct job *);
5920 static struct job *getjob(const char *);
5921 static int dowait(int, struct job *);
5925 * We keep track of whether or not fd0 has been redirected. This is for
5926 * background commands, where we want to redirect fd0 to /dev/null only
5927 * if it hasn't already been redirected.
5929 static int fd0_redirected = 0;
5931 /* Return true if fd 0 has already been redirected at least once. */
5932 static inline int fd0_redirected_p(void)
5934 return fd0_redirected != 0;
5937 static void dupredirect(const union node *, int, int fd1dup);
5939 #ifdef CONFIG_ASH_JOB_CONTROL
5941 * Turn job control on and off.
5943 * Note: This code assumes that the third arg to ioctl is a character
5944 * pointer, which is true on Berkeley systems but not System V. Since
5945 * System V doesn't have job control yet, this isn't a problem now.
5950 static void setjobctl(int enable)
5952 if (enable == jobctl || rootshell == 0)
5955 do { /* while we are in the background */
5956 initialpgrp = tcgetpgrp(2);
5957 if (initialpgrp < 0) {
5958 out2str("sh: can't access tty; job control turned off\n");
5962 if (initialpgrp == -1)
5963 initialpgrp = getpgrp();
5964 else if (initialpgrp != getpgrp()) {
5965 killpg(initialpgrp, SIGTTIN);
5972 setpgid(0, rootpid);
5973 tcsetpgrp(2, rootpid);
5974 } else { /* turning job control off */
5975 setpgid(0, initialpgrp);
5976 tcsetpgrp(2, initialpgrp);
5986 #ifdef CONFIG_ASH_JOB_CONTROL
5987 static int killcmd(int argc, char **argv)
5998 ("Usage: kill [-s sigspec | -signum | -sigspec] [pid | job]... or\n"
5999 "kill -l [exitstatus]");
6002 if (*argv[1] == '-') {
6003 signo = decode_signal(argv[1] + 1, 1);
6007 while ((c = nextopt("ls:")) != '\0')
6013 signo = decode_signal(optionarg, 1);
6015 error("invalid signal number or name: %s", optionarg);
6020 error("nextopt returned character code 0%o", c);
6027 if (!list && signo < 0)
6030 if ((signo < 0 || !*argptr) ^ list) {
6039 for (i = 1; i < NSIG; i++) {
6040 name = u_signal_names(0, &i, 1);
6046 name = u_signal_names(*argptr, &signo, -1);
6050 error("invalid signal number or exit status: %s", *argptr);
6055 if (**argptr == '%') {
6056 jp = getjob(*argptr);
6057 if (jp->jobctl == 0)
6058 error("job %s not created under job control", *argptr);
6059 pid = -jp->ps[0].pid;
6061 pid = atoi(*argptr);
6062 if (kill(pid, signo) != 0)
6063 error("%s: %m", *argptr);
6064 } while (*++argptr);
6069 static int fgcmd(int argc, char **argv)
6075 jp = getjob(argv[1]);
6076 if (jp->jobctl == 0)
6077 error("job not created under job control");
6078 pgrp = jp->ps[0].pid;
6079 ioctl(2, TIOCSPGRP, (char *) &pgrp);
6081 status = waitforjob(jp);
6086 static int bgcmd(int argc, char **argv)
6091 jp = getjob(*++argv);
6092 if (jp->jobctl == 0)
6093 error("job not created under job control");
6095 } while (--argc > 1);
6100 static void restartjob(struct job *jp)
6102 struct procstat *ps;
6105 if (jp->state == JOBDONE)
6108 killpg(jp->ps[0].pid, SIGCONT);
6109 for (ps = jp->ps, i = jp->nprocs; --i >= 0; ps++) {
6110 if (WIFSTOPPED(ps->status)) {
6119 static void showjobs(int change);
6122 static int jobscmd(int argc, char **argv)
6130 * Print a list of jobs. If "change" is nonzero, only print jobs whose
6131 * statuses have changed since the last call to showjobs.
6133 * If the shell is interrupted in the process of creating a job, the
6134 * result may be a job structure containing zero processes. Such structures
6135 * will be freed here.
6138 static void showjobs(int change)
6144 struct procstat *ps;
6148 TRACE(("showjobs(%d) called\n", change));
6149 while (dowait(0, (struct job *) NULL) > 0);
6150 for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
6153 if (jp->nprocs == 0) {
6157 if (change && !jp->changed)
6159 procno = jp->nprocs;
6160 for (ps = jp->ps;; ps++) { /* for each process */
6162 snprintf(s, 64, "[%d] %ld ", jobno, (long) ps->pid);
6164 snprintf(s, 64, " %ld ", (long) ps->pid);
6168 if (ps->status == -1) {
6169 /* don't print anything */
6170 } else if (WIFEXITED(ps->status)) {
6171 snprintf(s, 64, "Exit %d", WEXITSTATUS(ps->status));
6173 #ifdef CONFIG_ASH_JOB_CONTROL
6174 if (WIFSTOPPED(ps->status))
6175 i = WSTOPSIG(ps->status);
6176 else /* WIFSIGNALED(ps->status) */
6178 i = WTERMSIG(ps->status);
6179 if ((i & 0x7F) < NSIG && sys_siglist[i & 0x7F])
6180 strcpy(s, sys_siglist[i & 0x7F]);
6182 snprintf(s, 64, "Signal %d", i & 0x7F);
6183 if (WCOREDUMP(ps->status))
6184 strcat(s, " (core dumped)");
6188 printf("%*c%s\n", 30 - col >= 0 ? 30 - col : 0, ' ', ps->cmd);
6193 if (jp->state == JOBDONE) {
6201 * Mark a job structure as unused.
6204 static void freejob(struct job *jp)
6206 const struct procstat *ps;
6210 for (i = jp->nprocs, ps = jp->ps; --i >= 0; ps++) {
6211 if (ps->cmd != nullstr)
6214 if (jp->ps != &jp->ps0)
6217 #ifdef CONFIG_ASH_JOB_CONTROL
6218 if (curjob == jp - jobtab + 1)
6226 static int waitcmd(int argc, char **argv)
6234 job = getjob(*++argv);
6238 for (;;) { /* loop until process terminated or stopped */
6241 status = job->ps[job->nprocs - 1].status;
6247 if (WIFEXITED(status))
6248 retval = WEXITSTATUS(status);
6249 #ifdef CONFIG_ASH_JOB_CONTROL
6250 else if (WIFSTOPPED(status))
6251 retval = WSTOPSIG(status) + 128;
6254 /* XXX: limits number of signals */
6255 retval = WTERMSIG(status) + 128;
6260 for (jp = jobtab;; jp++) {
6261 if (jp >= jobtab + njobs) { /* no running procs */
6264 if (jp->used && jp->state == 0)
6268 if (dowait(2, 0) < 0 && errno == EINTR) {
6277 * Convert a job name to a job structure.
6280 static struct job *getjob(const char *name)
6288 #ifdef CONFIG_ASH_JOB_CONTROL
6290 if ((jobno = curjob) == 0 || jobtab[jobno - 1].used == 0)
6291 error("No current job");
6292 return &jobtab[jobno - 1];
6294 error("No current job");
6296 } else if (name[0] == '%') {
6297 if (is_digit(name[1])) {
6298 jobno = number(name + 1);
6299 if (jobno > 0 && jobno <= njobs && jobtab[jobno - 1].used != 0)
6300 return &jobtab[jobno - 1];
6301 #ifdef CONFIG_ASH_JOB_CONTROL
6302 } else if (name[1] == '%' && name[2] == '\0') {
6306 struct job *found = NULL;
6308 for (jp = jobtab, i = njobs; --i >= 0; jp++) {
6309 if (jp->used && jp->nprocs > 0
6310 && prefix(name + 1, jp->ps[0].cmd)) {
6312 error("%s: ambiguous", name);
6319 } else if (is_number(name, &pid)) {
6320 for (jp = jobtab, i = njobs; --i >= 0; jp++) {
6321 if (jp->used && jp->nprocs > 0
6322 && jp->ps[jp->nprocs - 1].pid == pid)
6326 error("No such job: %s", name);
6333 * Return a new job structure,
6336 static struct job *makejob(const union node *node, int nprocs)
6341 for (i = njobs, jp = jobtab;; jp++) {
6345 jobtab = xmalloc(4 * sizeof jobtab[0]);
6347 jp = xmalloc((njobs + 4) * sizeof jobtab[0]);
6348 memcpy(jp, jobtab, njobs * sizeof jp[0]);
6349 /* Relocate `ps' pointers */
6350 for (i = 0; i < njobs; i++)
6351 if (jp[i].ps == &jobtab[i].ps0)
6352 jp[i].ps = &jp[i].ps0;
6356 jp = jobtab + njobs;
6357 for (i = 4; --i >= 0; jobtab[njobs++].used = 0);
6369 #ifdef CONFIG_ASH_JOB_CONTROL
6370 jp->jobctl = jobctl;
6373 jp->ps = xmalloc(nprocs * sizeof(struct procstat));
6378 TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long) node, nprocs,
6385 * Fork of a subshell. If we are doing job control, give the subshell its
6386 * own process group. Jp is a job structure that the job is to be added to.
6387 * N is the command that will be evaluated by the child. Both jp and n may
6388 * be NULL. The mode parameter can be one of the following:
6389 * FORK_FG - Fork off a foreground process.
6390 * FORK_BG - Fork off a background process.
6391 * FORK_NOJOB - Like FORK_FG, but don't give the process its own
6392 * process group even if job control is on.
6394 * When job control is turned off, background processes have their standard
6395 * input redirected to /dev/null (except for the second and later processes
6401 static int forkshell(struct job *jp, const union node *n, int mode)
6405 #ifdef CONFIG_ASH_JOB_CONTROL
6408 const char *devnull = _PATH_DEVNULL;
6409 const char *nullerr = "Can't open %s";
6411 TRACE(("forkshell(%%%d, 0x%lx, %d) called\n", jp - jobtab, (long) n,
6416 TRACE(("Fork failed, errno=%d\n", errno));
6418 error("Cannot fork");
6425 TRACE(("Child shell %d\n", getpid()));
6426 wasroot = rootshell;
6431 #ifdef CONFIG_ASH_JOB_CONTROL
6432 jobctl = 0; /* do job control only in root shell */
6433 if (wasroot && mode != FORK_NOJOB && mflag) {
6434 if (jp == NULL || jp->nprocs == 0)
6437 pgrp = jp->ps[0].pid;
6439 if (mode == FORK_FG) {
6440 /*** this causes superfluous TIOCSPGRPS ***/
6441 if (tcsetpgrp(2, pgrp) < 0)
6442 error("tcsetpgrp failed, errno=%d", errno);
6446 } else if (mode == FORK_BG) {
6448 if (mode == FORK_BG) {
6452 if ((jp == NULL || jp->nprocs == 0) && !fd0_redirected_p()) {
6454 if (open(devnull, O_RDONLY) != 0)
6455 error(nullerr, devnull);
6458 for (i = njobs, p = jobtab; --i >= 0; p++)
6461 if (wasroot && iflag) {
6468 #ifdef CONFIG_ASH_JOB_CONTROL
6469 if (rootshell && mode != FORK_NOJOB && mflag) {
6470 if (jp == NULL || jp->nprocs == 0)
6473 pgrp = jp->ps[0].pid;
6477 if (mode == FORK_BG)
6478 backgndpid = pid; /* set $! */
6480 struct procstat *ps = &jp->ps[jp->nprocs++];
6485 if (iflag && rootshell && n)
6486 ps->cmd = commandtext(n);
6489 TRACE(("In parent shell: child = %d\n", pid));
6496 * Wait for job to finish.
6498 * Under job control we have the problem that while a child process is
6499 * running interrupts generated by the user are sent to the child but not
6500 * to the shell. This means that an infinite loop started by an inter-
6501 * active user may be hard to kill. With job control turned off, an
6502 * interactive user may place an interactive program inside a loop. If
6503 * the interactive program catches interrupts, the user doesn't want
6504 * these interrupts to also abort the loop. The approach we take here
6505 * is to have the shell ignore interrupt signals while waiting for a
6506 * forground process to terminate, and then send itself an interrupt
6507 * signal if the child process was terminated by an interrupt signal.
6508 * Unfortunately, some programs want to do a bit of cleanup and then
6509 * exit on interrupt; unless these processes terminate themselves by
6510 * sending a signal to themselves (instead of calling exit) they will
6511 * confuse this approach.
6514 static int waitforjob(struct job *jp)
6516 #ifdef CONFIG_ASH_JOB_CONTROL
6517 int mypgrp = getpgrp();
6523 TRACE(("waitforjob(%%%d) called\n", jp - jobtab + 1));
6524 while (jp->state == 0) {
6527 #ifdef CONFIG_ASH_JOB_CONTROL
6529 if (tcsetpgrp(2, mypgrp) < 0)
6530 error("tcsetpgrp failed, errno=%d\n", errno);
6532 if (jp->state == JOBSTOPPED)
6533 curjob = jp - jobtab + 1;
6535 status = jp->ps[jp->nprocs - 1].status;
6536 /* convert to 8 bits */
6537 if (WIFEXITED(status))
6538 st = WEXITSTATUS(status);
6539 #ifdef CONFIG_ASH_JOB_CONTROL
6540 else if (WIFSTOPPED(status))
6541 st = WSTOPSIG(status) + 128;
6544 st = WTERMSIG(status) + 128;
6545 #ifdef CONFIG_ASH_JOB_CONTROL
6548 * This is truly gross.
6549 * If we're doing job control, then we did a TIOCSPGRP which
6550 * caused us (the shell) to no longer be in the controlling
6551 * session -- so we wouldn't have seen any ^C/SIGINT. So, we
6552 * intuit from the subprocess exit status whether a SIGINT
6553 * occured, and if so interrupt ourselves. Yuck. - mycroft
6555 if (WIFSIGNALED(status) && WTERMSIG(status) == SIGINT)
6558 if (jp->state == JOBDONE)
6568 * Wait for a process to terminate.
6572 * Do a wait system call. If job control is compiled in, we accept
6573 * stopped processes. If block is zero, we return a value of zero
6574 * rather than blocking.
6576 * System V doesn't have a non-blocking wait system call. It does
6577 * have a SIGCLD signal that is sent to a process when one of it's
6578 * children dies. The obvious way to use SIGCLD would be to install
6579 * a handler for SIGCLD which simply bumped a counter when a SIGCLD
6580 * was received, and have waitproc bump another counter when it got
6581 * the status of a process. Waitproc would then know that a wait
6582 * system call would not block if the two counters were different.
6583 * This approach doesn't work because if a process has children that
6584 * have not been waited for, System V will send it a SIGCLD when it
6585 * installs a signal handler for SIGCLD. What this means is that when
6586 * a child exits, the shell will be sent SIGCLD signals continuously
6587 * until is runs out of stack space, unless it does a wait call before
6588 * restoring the signal handler. The code below takes advantage of
6589 * this (mis)feature by installing a signal handler for SIGCLD and
6590 * then checking to see whether it was called. If there are any
6591 * children to be waited for, it will be.
6595 static inline int waitproc(int block, int *status)
6600 #ifdef CONFIG_ASH_JOB_CONTROL
6606 return wait3(status, flags, (struct rusage *) NULL);
6609 static int dowait(int block, struct job *job)
6613 struct procstat *sp;
6615 struct job *thisjob;
6621 TRACE(("dowait(%d) called\n", block));
6623 pid = waitproc(block, &status);
6624 TRACE(("wait returns %d, status=%d\n", pid, status));
6625 } while (!(block & 2) && pid == -1 && errno == EINTR);
6630 for (jp = jobtab; jp < jobtab + njobs; jp++) {
6634 for (sp = jp->ps; sp < jp->ps + jp->nprocs; sp++) {
6637 if (sp->pid == pid) {
6638 TRACE(("Changing status of proc %d from 0x%x to 0x%x\n",
6639 pid, sp->status, status));
6640 sp->status = status;
6643 if (sp->status == -1)
6645 else if (WIFSTOPPED(sp->status))
6648 if (stopped) { /* stopped or done */
6649 int state = done ? JOBDONE : JOBSTOPPED;
6651 if (jp->state != state) {
6652 TRACE(("Job %d: changing state from %d to %d\n",
6653 jp - jobtab + 1, jp->state, state));
6655 #ifdef CONFIG_ASH_JOB_CONTROL
6656 if (done && curjob == jp - jobtab + 1)
6657 curjob = 0; /* no current job */
6664 if (!rootshell || !iflag || (job && thisjob == job)) {
6665 core = WCOREDUMP(status);
6666 #ifdef CONFIG_ASH_JOB_CONTROL
6667 if (WIFSTOPPED(status))
6668 sig = WSTOPSIG(status);
6671 if (WIFEXITED(status))
6674 sig = WTERMSIG(status);
6676 if (sig != 0 && sig != SIGINT && sig != SIGPIPE) {
6678 out2fmt("%d: ", pid);
6679 #ifdef CONFIG_ASH_JOB_CONTROL
6680 if (sig == SIGTSTP && rootshell && iflag)
6681 out2fmt("%%%ld ", (long) (job - jobtab + 1));
6683 if (sig < NSIG && sys_siglist[sig])
6684 out2str(sys_siglist[sig]);
6686 out2fmt("Signal %d", sig);
6688 out2str(" - core dumped");
6691 TRACE(("Not printing status: status=%d, sig=%d\n", status, sig));
6694 TRACE(("Not printing status, rootshell=%d, job=0x%x\n", rootshell,
6697 thisjob->changed = 1;
6706 * return 1 if there are stopped jobs, otherwise 0
6708 static int stoppedjobs(void)
6715 for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
6718 if (jp->state == JOBSTOPPED) {
6719 out2str("You have stopped jobs.\n");
6729 * Return a string identifying a command (to be printed by the
6733 static char *cmdnextc;
6734 static int cmdnleft;
6736 #define MAXCMDTEXT 200
6738 static void cmdputs(const char *s)
6749 while ((c = *p++) != '\0') {
6752 else if (c == CTLVAR) {
6757 } else if (c == '=' && subtype != 0) {
6758 *q++ = "}-+?="[(subtype & VSTYPE) - VSNORMAL];
6760 } else if (c == CTLENDVAR) {
6762 } else if (c == CTLBACKQ || c == CTLBACKQ + CTLQUOTE)
6763 cmdnleft++; /* ignore it */
6766 if (--cmdnleft <= 0) {
6776 #define CMDTXT_TABLE
6779 * To collect a lot of redundant code in cmdtxt() case statements, we
6780 * implement a mini language here. Each type of node struct has an
6781 * associated instruction sequence that operates on its members via
6782 * their offsets. The instruction are pack in unsigned chars with
6783 * format IIDDDDDE where the bits are
6784 * I : part of the instruction opcode, which are
6785 * 00 : member is a pointer to another node -- process it recursively
6786 * 40 : member is a pointer to a char string -- output it
6787 * 80 : output the string whose index is stored in the data field
6788 * CC : flag signaling that this case needs external processing
6789 * D : data - either the (shifted) index of a fixed string to output or
6790 * the actual offset of the member to operate on in the struct
6791 * (since we assume bit 0 is set, the offset is not shifted)
6792 * E : flag signaling end of instruction sequence
6794 * WARNING: In order to handle larger offsets for 64bit archs, this code
6795 * assumes that no offset can be an odd number and stores the
6796 * end-of-instructions flag in bit 0.
6799 #define CMDTXT_NOMORE 0x01 /* NOTE: no offset should be odd */
6800 #define CMDTXT_CHARPTR 0x40
6801 #define CMDTXT_STRING 0x80
6802 #define CMDTXT_SPECIAL 0xC0
6803 #define CMDTXT_OFFSETMASK 0x3E
6805 static const char *const cmdtxt_strings[] = {
6806 /* 0 1 2 3 4 5 6 7 */
6807 "; ", "(", ")", " && ", " || ", "if ", "; then ", "...",
6808 /* 8 9 10 11 12 13 */
6809 "while ", "; do ", "; done", "until ", "for ", " in ...",
6811 "case ", "???", "() ...", "<<..."
6814 static const char *const redir_strings[] = {
6815 ">", "<", "<>", ">>", ">|", ">&", "<&"
6818 static const unsigned char cmdtxt_ops[] = {
6819 #define CMDTXT_NSEMI 0
6820 offsetof(union node, nbinary.ch1),
6822 offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE,
6823 #define CMDTXT_NCMD (CMDTXT_NSEMI + 3)
6824 #define CMDTXT_NPIPE (CMDTXT_NCMD)
6825 #define CMDTXT_NCASE (CMDTXT_NCMD)
6826 #define CMDTXT_NTO (CMDTXT_NCMD)
6827 #define CMDTXT_NFROM (CMDTXT_NCMD)
6828 #define CMDTXT_NFROMTO (CMDTXT_NCMD)
6829 #define CMDTXT_NAPPEND (CMDTXT_NCMD)
6830 #define CMDTXT_NTOOV (CMDTXT_NCMD)
6831 #define CMDTXT_NTOFD (CMDTXT_NCMD)
6832 #define CMDTXT_NFROMFD (CMDTXT_NCMD)
6834 #define CMDTXT_NREDIR (CMDTXT_NPIPE + 1)
6835 #define CMDTXT_NBACKGND (CMDTXT_NREDIR)
6836 offsetof(union node, nredir.n) | CMDTXT_NOMORE,
6837 #define CMDTXT_NSUBSHELL (CMDTXT_NBACKGND + 1)
6838 (1 * 2) | CMDTXT_STRING,
6839 offsetof(union node, nredir.n),
6840 (2 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6841 #define CMDTXT_NAND (CMDTXT_NSUBSHELL + 3)
6842 offsetof(union node, nbinary.ch1),
6843 (3 * 2) | CMDTXT_STRING,
6844 offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE,
6845 #define CMDTXT_NOR (CMDTXT_NAND + 3)
6846 offsetof(union node, nbinary.ch1),
6847 (4 * 2) | CMDTXT_STRING,
6848 offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE,
6849 #define CMDTXT_NIF (CMDTXT_NOR + 3)
6850 (5 * 2) | CMDTXT_STRING,
6851 offsetof(union node, nif.test),
6852 (6 * 2) | CMDTXT_STRING,
6853 offsetof(union node, nif.ifpart),
6854 (7 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6855 #define CMDTXT_NWHILE (CMDTXT_NIF + 5)
6856 (8 * 2) | CMDTXT_STRING,
6857 offsetof(union node, nbinary.ch1),
6858 (9 * 2) | CMDTXT_STRING,
6859 offsetof(union node, nbinary.ch2),
6860 (10 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6861 #define CMDTXT_NUNTIL (CMDTXT_NWHILE + 5)
6862 (11 * 2) | CMDTXT_STRING,
6863 offsetof(union node, nbinary.ch1),
6864 (9 * 2) | CMDTXT_STRING,
6865 offsetof(union node, nbinary.ch2),
6866 (10 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6867 #define CMDTXT_NFOR (CMDTXT_NUNTIL + 5)
6868 (12 * 2) | CMDTXT_STRING,
6869 offsetof(union node, nfor.var) | CMDTXT_CHARPTR,
6870 (13 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6871 #define CMDTXT_NCLIST (CMDTXT_NFOR + 3) /* TODO: IS THIS CORRECT??? */
6872 #define CMDTXT_NNOT (CMDTXT_NCLIST) /* TODO: IS THIS CORRECT??? */
6873 (15 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6874 #define CMDTXT_NDEFUN (CMDTXT_NCLIST + 1)
6875 offsetof(union node, narg.text) | CMDTXT_CHARPTR,
6876 (16 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6877 #define CMDTXT_NARG (CMDTXT_NDEFUN + 2)
6878 offsetof(union node, narg.text) | CMDTXT_CHARPTR | CMDTXT_NOMORE,
6879 #define CMDTXT_NHERE (CMDTXT_NARG + 1)
6880 #define CMDTXT_NXHERE (CMDTXT_NHERE)
6881 (17 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6884 #if CMDTXT_NXHERE != 36
6885 #error CMDTXT_NXHERE
6888 static const unsigned char cmdtxt_ops_index[26] = {
6917 static void cmdtxt(const union node *n)
6924 p = cmdtxt_ops + (int) cmdtxt_ops_index[n->type];
6925 if ((*p & CMDTXT_SPECIAL) != CMDTXT_SPECIAL) { /* normal case */
6927 if (*p & CMDTXT_STRING) { /* output fixed string */
6928 cmdputs(cmdtxt_strings
6929 [((int) (*p & CMDTXT_OFFSETMASK) >> 1)]);
6931 const char *pf = ((const char *) n)
6932 + ((int) (*p & CMDTXT_OFFSETMASK));
6934 if (*p & CMDTXT_CHARPTR) { /* output dynamic string */
6935 cmdputs(*((const char **) pf));
6936 } else { /* output field */
6937 cmdtxt(*((const union node **) pf));
6940 } while (!(*p++ & CMDTXT_NOMORE));
6941 } else if (n->type == NCMD) {
6944 for (np = n->ncmd.args; np; np = np->narg.next) {
6949 for (np = n->ncmd.redirect; np; np = np->nfile.next) {
6953 } else if (n->type == NPIPE) {
6954 struct nodelist *lp;
6956 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
6961 } else if (n->type == NCASE) {
6962 cmdputs(cmdtxt_strings[14]);
6963 cmdputs(n->ncase.expr->narg.text);
6964 cmdputs(cmdtxt_strings[13]);
6966 #if (NTO != 16) || (NFROM != 17) || (NFROMTO != 18) || (NAPPEND != 19) || (NTOOV != 20) || (NTOFD != 21) || (NFROMFD != 22)
6967 #error Assumption violated regarding range and ordering of NTO ... NFROMFD!
6972 assert((n->type >= NTO) && (n->type <= NFROMFD));
6975 p = redir_strings[n->type - NTO];
6976 if (n->nfile.fd != ('>' == *p)) {
6977 s[0] = n->nfile.fd + '0';
6982 if (n->type >= NTOFD) {
6983 s[0] = n->ndup.dupfd + '0';
6987 cmdtxt(n->nfile.fname);
6991 #else /* CMDTXT_TABLE */
6992 static void cmdtxt(const union node *n)
6995 struct nodelist *lp;
7004 cmdtxt(n->nbinary.ch1);
7006 cmdtxt(n->nbinary.ch2);
7009 cmdtxt(n->nbinary.ch1);
7011 cmdtxt(n->nbinary.ch2);
7014 cmdtxt(n->nbinary.ch1);
7016 cmdtxt(n->nbinary.ch2);
7019 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
7027 cmdtxt(n->nredir.n);
7032 cmdtxt(n->nredir.n);
7036 cmdtxt(n->nif.test);
7038 cmdtxt(n->nif.ifpart);
7047 cmdtxt(n->nbinary.ch1);
7049 cmdtxt(n->nbinary.ch2);
7054 cmdputs(n->nfor.var);
7059 cmdputs(n->ncase.expr->narg.text);
7063 cmdputs(n->narg.text);
7067 for (np = n->ncmd.args; np; np = np->narg.next) {
7072 for (np = n->ncmd.redirect; np; np = np->nfile.next) {
7078 cmdputs(n->narg.text);
7109 if (n->nfile.fd != i) {
7110 s[0] = n->nfile.fd + '0';
7115 if (n->type == NTOFD || n->type == NFROMFD) {
7116 s[0] = n->ndup.dupfd + '0';
7120 cmdtxt(n->nfile.fname);
7132 #endif /* CMDTXT_TABLE */
7134 static char *commandtext(const union node *n)
7138 cmdnextc = name = xmalloc(MAXCMDTEXT);
7139 cmdnleft = MAXCMDTEXT - 4;
7146 #ifdef CONFIG_ASH_MAIL
7149 * Routines to check for mail.
7153 #define MAXMBOXES 10
7156 static int nmboxes; /* number of mailboxes */
7157 static time_t mailtime[MAXMBOXES]; /* times of mailboxes */
7162 * Print appropriate message(s) if mail has arrived. If the argument is
7163 * nozero, then the value of MAIL has changed, so we just update the
7167 static void chkmail(int silent)
7173 struct stackmark smark;
7180 setstackmark(&smark);
7181 mpath = mpathset()? mpathval() : mailval();
7182 for (i = 0; i < nmboxes; i++) {
7183 p = padvance(&mpath, nullstr);
7188 for (q = p; *q; q++);
7193 q[-1] = '\0'; /* delete trailing '/' */
7194 if (stat(p, &statb) < 0)
7196 if (statb.st_size > mailtime[i] && !silent) {
7197 out2fmt(snlfmt, pathopt ? pathopt : "you have mail");
7199 mailtime[i] = statb.st_size;
7202 popstackmark(&smark);
7205 #endif /* CONFIG_ASH_MAIL */
7210 static short profile_buf[16384];
7214 static int isloginsh = 0;
7216 static void read_profile(const char *);
7217 static void cmdloop(int);
7218 static void options(int);
7219 static void setoption(int, int);
7220 static void procargs(int, char **);
7224 * Main routine. We initialize things, parse the arguments, execute
7225 * profiles if we're a login shell, and then call cmdloop to execute
7226 * commands. The setjmp call sets up the location to jump to when an
7227 * exception occurs. When an exception occurs the variable "state"
7228 * is used to figure out how far we had gotten.
7231 int ash_main(int argc, char **argv)
7233 struct jmploc jmploc;
7234 struct stackmark smark;
7238 BLTINCMD = find_builtin("builtin");
7239 EXECCMD = find_builtin("exec");
7240 EVALCMD = find_builtin("eval");
7242 #ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
7248 monitor(4, etext, profile_buf, sizeof profile_buf, 50);
7250 #if defined(linux) || defined(__GNU__)
7251 signal(SIGCHLD, SIG_DFL);
7254 if (setjmp(jmploc.loc)) {
7257 * When a shell procedure is executed, we raise the
7258 * exception EXSHELLPROC to clean up before executing
7259 * the shell procedure.
7261 if (exception == EXSHELLPROC) {
7267 if (exception == EXEXEC) {
7268 exitstatus = exerrno;
7269 } else if (exception == EXERROR) {
7272 if (state == 0 || iflag == 0 || !rootshell)
7273 exitshell(exitstatus);
7276 if (exception == EXINT) {
7279 popstackmark(&smark);
7280 FORCEINTON; /* enable interrupts */
7283 else if (state == 2)
7285 else if (state == 3)
7293 trputs("Shell args: ");
7299 setstackmark(&smark);
7300 procargs(argc, argv);
7301 if (argv[0] && argv[0][0] == '-')
7305 read_profile("/etc/profile");
7308 read_profile(".profile");
7313 if (getuid() == geteuid() && getgid() == getegid()) {
7315 if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
7317 read_profile(shinit);
7324 if (sflag == 0 || minusc) {
7325 static const char sigs[] = {
7326 SIGINT, SIGQUIT, SIGHUP,
7333 #define SIGSSIZE ((sizeof(sigs)/sizeof(sigs[0])))
7336 for (i = 0; i < SIGSSIZE; i++)
7341 evalstring(minusc, 0);
7343 if (sflag || minusc == NULL) {
7344 state4: /* XXX ??? - why isn't this before the "if" statement */
7350 exitshell(exitstatus);
7356 * Read and execute commands. "Top" is nonzero for the top level command
7357 * loop; it turns on prompting if the shell is interactive.
7360 static void cmdloop(int top)
7363 struct stackmark smark;
7367 TRACE(("cmdloop(%d) called\n", top));
7368 setstackmark(&smark);
7376 #ifdef CONFIG_ASH_MAIL
7381 n = parsecmd(inter);
7382 /* showtree(n); DEBUG */
7384 if (!top || numeof >= 50)
7386 if (!stoppedjobs()) {
7389 out2str("\nUse \"exit\" to leave shell.\n");
7392 } else if (n != NULL && nflag == 0) {
7393 job_warning = (job_warning == 2) ? 1 : 0;
7397 popstackmark(&smark);
7398 setstackmark(&smark);
7399 if (evalskip == SKIPFILE) {
7404 popstackmark(&smark);
7410 * Read /etc/profile or .profile. Return on error.
7413 static void read_profile(const char *name)
7420 if ((fd = open(name, O_RDONLY)) >= 0)
7425 /* -q turns off -x and -v just when executing init files */
7426 /* Note: Might do a little redundant work, but reduces code size. */
7441 * Read a file containing shell functions.
7444 static void readcmdfile(const char *name)
7449 if ((fd = open(name, O_RDONLY)) >= 0)
7452 error("Can't open %s", name);
7461 * Take commands from a file. To be compatable we should do a path
7462 * search for the file, which is necessary to find sub-commands.
7465 static inline char *find_dot_file(char *mybasename)
7468 const char *path = pathval();
7471 /* don't try this for absolute or relative paths */
7472 if (strchr(mybasename, '/'))
7475 while ((fullname = padvance(&path, mybasename)) != NULL) {
7476 if ((stat(fullname, &statb) == 0) && S_ISREG(statb.st_mode)) {
7478 * Don't bother freeing here, since it will
7479 * be freed by the caller.
7483 stunalloc(fullname);
7486 /* not found in the PATH */
7487 error("%s: not found", mybasename);
7491 static int dotcmd(int argc, char **argv)
7494 volatile struct shparam saveparam;
7498 for (sp = cmdenviron; sp; sp = sp->next)
7499 setvareq(xstrdup(sp->text), VSTRFIXED | VTEXTFIXED);
7501 if (argc >= 2) { /* That's what SVR2 does */
7503 struct stackmark smark;
7505 setstackmark(&smark);
7506 fullname = find_dot_file(argv[1]);
7509 saveparam = shellparam;
7510 shellparam.malloc = 0;
7511 shellparam.nparam = argc - 2;
7512 shellparam.p = argv + 2;
7515 setinputfile(fullname, 1);
7516 commandname = fullname;
7521 freeparam(&shellparam);
7522 shellparam = saveparam;
7525 popstackmark(&smark);
7531 static int exitcmd(int argc, char **argv)
7536 exitstatus = number(argv[1]);
7538 exitstatus = oexitstatus;
7539 exitshell(exitstatus);
7543 static pointer stalloc(int nbytes)
7547 nbytes = ALIGN(nbytes);
7548 if (nbytes > stacknleft) {
7550 struct stack_block *sp;
7553 if (blocksize < MINSIZE)
7554 blocksize = MINSIZE;
7556 sp = xmalloc(sizeof(struct stack_block) - MINSIZE + blocksize);
7558 stacknxt = sp->space;
7559 stacknleft = blocksize;
7565 stacknleft -= nbytes;
7570 static void stunalloc(pointer p)
7573 if (p == NULL) { /*DEBUG */
7574 write(2, "stunalloc\n", 10);
7578 if (!(stacknxt >= (char *) p && (char *) p >= stackp->space)) {
7581 stacknleft += stacknxt - (char *) p;
7586 static void setstackmark(struct stackmark *mark)
7588 mark->stackp = stackp;
7589 mark->stacknxt = stacknxt;
7590 mark->stacknleft = stacknleft;
7591 mark->marknext = markp;
7596 static void popstackmark(struct stackmark *mark)
7598 struct stack_block *sp;
7601 markp = mark->marknext;
7602 while (stackp != mark->stackp) {
7607 stacknxt = mark->stacknxt;
7608 stacknleft = mark->stacknleft;
7614 * When the parser reads in a string, it wants to stick the string on the
7615 * stack and only adjust the stack pointer when it knows how big the
7616 * string is. Stackblock (defined in stack.h) returns a pointer to a block
7617 * of space on top of the stack and stackblocklen returns the length of
7618 * this block. Growstackblock will grow this space by at least one byte,
7619 * possibly moving it (like realloc). Grabstackblock actually allocates the
7620 * part of the block that has been used.
7623 static void growstackblock(void)
7626 int newlen = ALIGN(stacknleft * 2 + 100);
7627 char *oldspace = stacknxt;
7628 int oldlen = stacknleft;
7629 struct stack_block *sp;
7630 struct stack_block *oldstackp;
7632 if (stacknxt == stackp->space && stackp != &stackbase) {
7637 sp = xrealloc((pointer) sp,
7638 sizeof(struct stack_block) - MINSIZE + newlen);
7641 stacknxt = sp->space;
7642 stacknleft = newlen;
7644 /* Stack marks pointing to the start of the old block
7645 * must be relocated to point to the new block
7647 struct stackmark *xmark;
7650 while (xmark != NULL && xmark->stackp == oldstackp) {
7651 xmark->stackp = stackp;
7652 xmark->stacknxt = stacknxt;
7653 xmark->stacknleft = stacknleft;
7654 xmark = xmark->marknext;
7659 p = stalloc(newlen);
7660 memcpy(p, oldspace, oldlen);
7661 stacknxt = p; /* free the space */
7662 stacknleft += newlen; /* we just allocated */
7668 static inline void grabstackblock(int len)
7678 * The following routines are somewhat easier to use that the above.
7679 * The user declares a variable of type STACKSTR, which may be declared
7680 * to be a register. The macro STARTSTACKSTR initializes things. Then
7681 * the user uses the macro STPUTC to add characters to the string. In
7682 * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is
7683 * grown as necessary. When the user is done, she can just leave the
7684 * string there and refer to it using stackblock(). Or she can allocate
7685 * the space for it using grabstackstr(). If it is necessary to allow
7686 * someone else to use the stack temporarily and then continue to grow
7687 * the string, the user should use grabstack to allocate the space, and
7688 * then call ungrabstr(p) to return to the previous mode of operation.
7690 * USTPUTC is like STPUTC except that it doesn't check for overflow.
7691 * CHECKSTACKSPACE can be called before USTPUTC to ensure that there
7692 * is space for at least one character.
7696 static char *growstackstr(void)
7698 int len = stackblocksize();
7700 if (herefd >= 0 && len >= 1024) {
7701 xwrite(herefd, stackblock(), len);
7702 sstrnleft = len - 1;
7703 return stackblock();
7706 sstrnleft = stackblocksize() - len - 1;
7707 return stackblock() + len;
7712 * Called from CHECKSTRSPACE.
7715 static char *makestrspace(size_t newlen)
7717 int len = stackblocksize() - sstrnleft;
7721 sstrnleft = stackblocksize() - len;
7722 } while (sstrnleft < newlen);
7723 return stackblock() + len;
7728 static void ungrabstackstr(char *s, char *p)
7730 stacknleft += stacknxt - s;
7732 sstrnleft = stacknleft - (p - s);
7736 * Miscelaneous builtins.
7742 #if !defined(__GLIBC__) || __GLIBC__ == 2 && __GLIBC_MINOR__ < 1
7743 typedef long rlim_t;
7749 * The read builtin. The -e option causes backslashes to escape the
7750 * following character.
7752 * This uses unbuffered input, which may be avoidable in some cases.
7755 static int readcmd(int argc, char **argv)
7770 while ((i = nextopt("p:r")) != '\0') {
7776 if (prompt && isatty(0)) {
7777 out2str(prompt); /* read without cmdedit */
7780 if (*(ap = argptr) == NULL)
7782 if ((ifs = bltinlookup("IFS")) == NULL)
7789 if (read(0, &c, 1) != 1) {
7801 if (!rflag && c == '\\') {
7807 if (startword && *ifs == ' ' && strchr(ifs, c)) {
7811 if (backslash && c == '\\') {
7812 if (read(0, &c, 1) != 1) {
7817 } else if (ap[1] != NULL && strchr(ifs, c) != NULL) {
7819 setvar(*ap, stackblock(), 0);
7828 /* Remove trailing blanks */
7829 while (stackblock() <= --p && strchr(ifs, *p) != NULL)
7831 setvar(*ap, stackblock(), 0);
7832 while (*++ap != NULL)
7833 setvar(*ap, nullstr, 0);
7839 static int umaskcmd(int argc, char **argv)
7841 static const char permuser[3] = "ugo";
7842 static const char permmode[3] = "rwx";
7843 static const short int permmask[] = {
7844 S_IRUSR, S_IWUSR, S_IXUSR,
7845 S_IRGRP, S_IWGRP, S_IXGRP,
7846 S_IROTH, S_IWOTH, S_IXOTH
7852 int symbolic_mode = 0;
7854 while (nextopt("S") != '\0') {
7863 if ((ap = *argptr) == NULL) {
7864 if (symbolic_mode) {
7868 for (i = 0; i < 3; i++) {
7873 for (j = 0; j < 3; j++) {
7874 if ((mask & permmask[3 * i + j]) == 0) {
7883 printf("%.4o\n", mask);
7886 if (is_digit((unsigned char) *ap)) {
7889 if (*ap >= '8' || *ap < '0')
7890 error("Illegal number: %s", argv[1]);
7891 mask = (mask << 3) + (*ap - '0');
7892 } while (*++ap != '\0');
7895 mask = ~mask & 0777;
7896 if (!parse_mode(ap, &mask)) {
7897 error("Illegal mode: %s", ap);
7899 umask(~mask & 0777);
7908 * This code, originally by Doug Gwyn, Doug Kingston, Eric Gisin, and
7909 * Michael Rendell was ripped from pdksh 5.0.8 and hacked for use with
7910 * ash by J.T. Conklin.
7918 short factor; /* multiply by to get rlim_{cur,max} values */
7921 static const struct limits limits[] = {
7923 {"time(seconds)", RLIMIT_CPU, 1},
7926 {"file(blocks)", RLIMIT_FSIZE, 512},
7929 {"data(kbytes)", RLIMIT_DATA, 1024},
7932 {"stack(kbytes)", RLIMIT_STACK, 1024},
7935 {"coredump(blocks)", RLIMIT_CORE, 512},
7938 {"memory(kbytes)", RLIMIT_RSS, 1024},
7940 #ifdef RLIMIT_MEMLOCK
7941 {"locked memory(kbytes)", RLIMIT_MEMLOCK, 1024},
7944 {"process(processes)", RLIMIT_NPROC, 1},
7946 #ifdef RLIMIT_NOFILE
7947 {"nofiles(descriptors)", RLIMIT_NOFILE, 1},
7950 {"vmemory(kbytes)", RLIMIT_VMEM, 1024},
7953 {"swap(kbytes)", RLIMIT_SWAP, 1024},
7958 static int ulimitcmd(int argc, char **argv)
7960 static const char unlimited_string[] = "unlimited";
7963 enum { SOFT = 0x1, HARD = 0x2 } how = SOFT | HARD;
7964 const struct limits *l;
7967 struct rlimit limit;
7971 while ((optc = nextopt("HSa"
7990 #ifdef RLIMIT_MEMLOCK
7996 #ifdef RLIMIT_NOFILE
8008 } else if (optc == 'S') {
8010 } else if (optc == 'a') {
8017 for (l = limits; l->name; l++) {
8018 if (l->name[0] == what)
8020 if (l->name[1] == 'w' && what == 'w')
8024 set = *argptr ? 1 : 0;
8028 if (all || argptr[1])
8029 error("too many arguments");
8030 if (strcmp(p, unlimited_string) == 0)
8031 val = RLIM_INFINITY;
8035 while ((c = *p++) >= '0' && c <= '9') {
8036 val = (val * 10) + (long) (c - '0');
8037 if (val < (rlim_t) 0)
8041 error("bad number");
8047 for (l = limits; l->name; l++) {
8048 printf("%-20s ", l->name);
8049 getrlimit(l->cmd, &limit);
8052 val = limit.rlim_cur;
8053 else if (how & HARD)
8054 val = limit.rlim_max;
8056 if (val == RLIM_INFINITY)
8057 puts(unlimited_string);
8060 printf("%lld\n", (long long) val);
8073 getrlimit(l->cmd, &limit);
8075 limit.rlim_max = val;
8077 limit.rlim_cur = val;
8078 if (setrlimit(l->cmd, &limit) < 0)
8079 error("error setting limit (%m)");
8084 * prefix -- see if pfx is a prefix of string.
8087 static int prefix(char const *pfx, char const *string)
8090 if (*pfx++ != *string++)
8097 * Return true if s is a string of digits, and save munber in intptr
8101 static int is_number(const char *p, int *intptr)
8109 ret += digit_val(*p);
8111 } while (*p != '\0');
8118 * Convert a string of digits to an integer, printing an error message on
8122 static int number(const char *s)
8126 if (!is_number(s, &i))
8127 error("Illegal number: %s", s);
8132 * Produce a possibly single quoted string suitable as input to the shell.
8133 * The return string is allocated on the stack.
8136 static char *single_quote(const char *s)
8144 size_t len1, len1p, len2, len2p;
8146 len1 = strcspn(s, "'");
8147 len2 = strspn(s + len1, "'");
8149 len1p = len1 ? len1 + 2 : len1;
8150 len2p = len2 + ((len2 < 2) ? len2 : 2);
8152 CHECKSTRSPACE(len1p + len2p + 1, p);
8157 memcpy(p + 1, s, len1);
8165 memcpy(q + 1, s, len2);
8168 } else if (len2 == 1) {
8174 STADJUST(len1p + len2p, p);
8179 return grabstackstr(p);
8183 * Routine for dealing with parsed shell commands.
8187 static void sizenodelist(const struct nodelist *);
8188 static struct nodelist *copynodelist(const struct nodelist *);
8189 static char *nodesavestr(const char *);
8191 #define CALCSIZE_TABLE
8192 #define COPYNODE_TABLE
8193 #if defined(CALCSIZE_TABLE) || defined(COPYNODE_TABLE)
8195 * To collect a lot of redundant code in case statements for copynode()
8196 * and calcsize(), we implement a mini language here. Each type of node
8197 * struct has an associated instruction sequence that operates on its
8198 * members via their offsets. The instruction are pack in unsigned chars
8199 * with format IIDDDDDE where the bits are
8200 * I : part of the instruction opcode, which are
8201 * 00 : member is a pointer to another node
8202 * 40 : member is an integer
8203 * 80 : member is a pointer to a nodelist
8204 * CC : member is a pointer to a char string
8205 * D : data - the actual offset of the member to operate on in the struct
8206 * (since we assume bit 0 is set, it is not shifted)
8207 * E : flag signaling end of instruction sequence
8209 * WARNING: In order to handle larger offsets for 64bit archs, this code
8210 * assumes that no offset can be an odd number and stores the
8211 * end-of-instructions flag in bit 0.
8214 #define NODE_INTEGER 0x40
8215 #define NODE_NODELIST 0x80
8216 #define NODE_CHARPTR 0xC0
8217 #define NODE_NOMORE 0x01 /* Note: no offset should be odd (aligned) */
8218 #define NODE_MBRMASK 0xC0
8219 #define NODE_OFFSETMASK 0x3E
8221 static const unsigned char copynode_ops[35] = {
8222 #define COPYNODE_OPS0 0
8223 offsetof(union node, nbinary.ch2),
8224 offsetof(union node, nbinary.ch1) | NODE_NOMORE,
8225 #define COPYNODE_OPS1 (COPYNODE_OPS0 + 2)
8226 offsetof(union node, ncmd.redirect),
8227 offsetof(union node, ncmd.args),
8228 offsetof(union node, ncmd.assign),
8229 offsetof(union node, ncmd.backgnd) | NODE_INTEGER | NODE_NOMORE,
8230 #define COPYNODE_OPS2 (COPYNODE_OPS1 + 4)
8231 offsetof(union node, npipe.cmdlist) | NODE_NODELIST,
8232 offsetof(union node, npipe.backgnd) | NODE_INTEGER | NODE_NOMORE,
8233 #define COPYNODE_OPS3 (COPYNODE_OPS2 + 2)
8234 offsetof(union node, nredir.redirect),
8235 offsetof(union node, nredir.n) | NODE_NOMORE,
8236 #define COPYNODE_OPS4 (COPYNODE_OPS3 + 2)
8237 offsetof(union node, nif.elsepart),
8238 offsetof(union node, nif.ifpart),
8239 offsetof(union node, nif.test) | NODE_NOMORE,
8240 #define COPYNODE_OPS5 (COPYNODE_OPS4 + 3)
8241 offsetof(union node, nfor.var) | NODE_CHARPTR,
8242 offsetof(union node, nfor.body),
8243 offsetof(union node, nfor.args) | NODE_NOMORE,
8244 #define COPYNODE_OPS6 (COPYNODE_OPS5 + 3)
8245 offsetof(union node, ncase.cases),
8246 offsetof(union node, ncase.expr) | NODE_NOMORE,
8247 #define COPYNODE_OPS7 (COPYNODE_OPS6 + 2)
8248 offsetof(union node, nclist.body),
8249 offsetof(union node, nclist.pattern),
8250 offsetof(union node, nclist.next) | NODE_NOMORE,
8251 #define COPYNODE_OPS8 (COPYNODE_OPS7 + 3)
8252 offsetof(union node, narg.backquote) | NODE_NODELIST,
8253 offsetof(union node, narg.text) | NODE_CHARPTR,
8254 offsetof(union node, narg.next) | NODE_NOMORE,
8255 #define COPYNODE_OPS9 (COPYNODE_OPS8 + 3)
8256 offsetof(union node, nfile.fname),
8257 offsetof(union node, nfile.fd) | NODE_INTEGER,
8258 offsetof(union node, nfile.next) | NODE_NOMORE,
8259 #define COPYNODE_OPS10 (COPYNODE_OPS9 + 3)
8260 offsetof(union node, ndup.vname),
8261 offsetof(union node, ndup.dupfd) | NODE_INTEGER,
8262 offsetof(union node, ndup.fd) | NODE_INTEGER,
8263 offsetof(union node, ndup.next) | NODE_NOMORE,
8264 #define COPYNODE_OPS11 (COPYNODE_OPS10 + 4)
8265 offsetof(union node, nhere.doc),
8266 offsetof(union node, nhere.fd) | NODE_INTEGER,
8267 offsetof(union node, nhere.next) | NODE_NOMORE,
8268 #define COPYNODE_OPS12 (COPYNODE_OPS11 + 3)
8269 offsetof(union node, nnot.com) | NODE_NOMORE,
8272 #if COPYNODE_OPS12 != 34
8273 #error COPYNODE_OPS12 is incorrect
8276 static const unsigned char copynode_ops_index[26] = {
8277 COPYNODE_OPS0, /* NSEMI */
8278 COPYNODE_OPS1, /* NCMD */
8279 COPYNODE_OPS2, /* NPIPE */
8280 COPYNODE_OPS3, /* NREDIR */
8281 COPYNODE_OPS3, /* NBACKGND */
8282 COPYNODE_OPS3, /* NSUBSHELL */
8283 COPYNODE_OPS0, /* NAND */
8284 COPYNODE_OPS0, /* NOR */
8285 COPYNODE_OPS4, /* NIF */
8286 COPYNODE_OPS0, /* NWHILE */
8287 COPYNODE_OPS0, /* NUNTIL */
8288 COPYNODE_OPS5, /* NFOR */
8289 COPYNODE_OPS6, /* NCASE */
8290 COPYNODE_OPS7, /* NCLIST */
8291 COPYNODE_OPS8, /* NDEFUN */
8292 COPYNODE_OPS8, /* NARG */
8293 COPYNODE_OPS9, /* NTO */
8294 COPYNODE_OPS9, /* NFROM */
8295 COPYNODE_OPS9, /* NFROMTO */
8296 COPYNODE_OPS9, /* NAPPEND */
8297 COPYNODE_OPS9, /* NTOOV */
8298 COPYNODE_OPS10, /* NTOFD */
8299 COPYNODE_OPS10, /* NFROMFD */
8300 COPYNODE_OPS11, /* NHERE */
8301 COPYNODE_OPS11, /* NXHERE */
8302 COPYNODE_OPS12, /* NNOT */
8305 #if NODE_CHARPTR != NODE_MBRMASK
8306 #error NODE_CHARPTR != NODE_MBRMASK!!!
8308 #endif /* defined(CALCSIZE_TABLE) || defined(COPYNODE_TABLE) */
8310 #ifdef COPYNODE_TABLE
8311 static union node *copynode(const union node *n)
8314 const unsigned char *p;
8320 new->type = n->type;
8321 funcblock = (char *) funcblock + (int) nodesize[n->type];
8322 p = copynode_ops + (int) copynode_ops_index[n->type];
8324 char *nn = ((char *) new) + ((int) (*p & NODE_OFFSETMASK));
8325 const char *no = ((const char *) n) + ((int) (*p & NODE_OFFSETMASK));
8327 if (!(*p & NODE_MBRMASK)) { /* standard node */
8328 *((union node **) nn) = copynode(*((const union node **) no));
8329 } else if ((*p & NODE_MBRMASK) == NODE_CHARPTR) { /* string */
8330 *((const char **) nn) = nodesavestr(*((const char **) no));
8331 } else if (*p & NODE_NODELIST) { /* nodelist */
8332 *((struct nodelist **) nn)
8333 = copynodelist(*((const struct nodelist **) no));
8334 } else { /* integer */
8335 *((int *) nn) = *((int *) no);
8337 } while (!(*p++ & NODE_NOMORE));
8340 #else /* COPYNODE_TABLE */
8341 static union node *copynode(const union node *n)
8348 funcblock = (char *) funcblock + nodesize[n->type];
8355 new->nbinary.ch2 = copynode(n->nbinary.ch2);
8356 new->nbinary.ch1 = copynode(n->nbinary.ch1);
8359 new->ncmd.redirect = copynode(n->ncmd.redirect);
8360 new->ncmd.args = copynode(n->ncmd.args);
8361 new->ncmd.assign = copynode(n->ncmd.assign);
8362 new->ncmd.backgnd = n->ncmd.backgnd;
8365 new->npipe.cmdlist = copynodelist(n->npipe.cmdlist);
8366 new->npipe.backgnd = n->npipe.backgnd;
8371 new->nredir.redirect = copynode(n->nredir.redirect);
8372 new->nredir.n = copynode(n->nredir.n);
8375 new->nif.elsepart = copynode(n->nif.elsepart);
8376 new->nif.ifpart = copynode(n->nif.ifpart);
8377 new->nif.test = copynode(n->nif.test);
8380 new->nfor.var = nodesavestr(n->nfor.var);
8381 new->nfor.body = copynode(n->nfor.body);
8382 new->nfor.args = copynode(n->nfor.args);
8385 new->ncase.cases = copynode(n->ncase.cases);
8386 new->ncase.expr = copynode(n->ncase.expr);
8389 new->nclist.body = copynode(n->nclist.body);
8390 new->nclist.pattern = copynode(n->nclist.pattern);
8391 new->nclist.next = copynode(n->nclist.next);
8395 new->narg.backquote = copynodelist(n->narg.backquote);
8396 new->narg.text = nodesavestr(n->narg.text);
8397 new->narg.next = copynode(n->narg.next);
8404 new->nfile.fname = copynode(n->nfile.fname);
8405 new->nfile.fd = n->nfile.fd;
8406 new->nfile.next = copynode(n->nfile.next);
8410 new->ndup.vname = copynode(n->ndup.vname);
8411 new->ndup.dupfd = n->ndup.dupfd;
8412 new->ndup.fd = n->ndup.fd;
8413 new->ndup.next = copynode(n->ndup.next);
8417 new->nhere.doc = copynode(n->nhere.doc);
8418 new->nhere.fd = n->nhere.fd;
8419 new->nhere.next = copynode(n->nhere.next);
8422 new->nnot.com = copynode(n->nnot.com);
8425 new->type = n->type;
8428 #endif /* COPYNODE_TABLE */
8430 #ifdef CALCSIZE_TABLE
8431 static void calcsize(const union node *n)
8433 const unsigned char *p;
8437 funcblocksize += (int) nodesize[n->type];
8439 p = copynode_ops + (int) copynode_ops_index[n->type];
8441 const char *no = ((const char *) n) + ((int) (*p & NODE_OFFSETMASK));
8443 if (!(*p & NODE_MBRMASK)) { /* standard node */
8444 calcsize(*((const union node **) no));
8445 } else if ((*p & NODE_MBRMASK) == NODE_CHARPTR) { /* string */
8446 funcstringsize += strlen(*((const char **) no)) + 1;
8447 } else if (*p & NODE_NODELIST) { /* nodelist */
8448 sizenodelist(*((const struct nodelist **) no));
8449 } /* else integer -- ignore */
8450 } while (!(*p++ & NODE_NOMORE));
8452 #else /* CALCSIZE_TABLE */
8453 static void calcsize(const union node *n)
8457 funcblocksize += nodesize[n->type];
8464 calcsize(n->nbinary.ch2);
8465 calcsize(n->nbinary.ch1);
8468 calcsize(n->ncmd.redirect);
8469 calcsize(n->ncmd.args);
8470 calcsize(n->ncmd.assign);
8473 sizenodelist(n->npipe.cmdlist);
8478 calcsize(n->nredir.redirect);
8479 calcsize(n->nredir.n);
8482 calcsize(n->nif.elsepart);
8483 calcsize(n->nif.ifpart);
8484 calcsize(n->nif.test);
8487 funcstringsize += strlen(n->nfor.var) + 1;
8488 calcsize(n->nfor.body);
8489 calcsize(n->nfor.args);
8492 calcsize(n->ncase.cases);
8493 calcsize(n->ncase.expr);
8496 calcsize(n->nclist.body);
8497 calcsize(n->nclist.pattern);
8498 calcsize(n->nclist.next);
8502 sizenodelist(n->narg.backquote);
8503 funcstringsize += strlen(n->narg.text) + 1;
8504 calcsize(n->narg.next);
8511 calcsize(n->nfile.fname);
8512 calcsize(n->nfile.next);
8516 calcsize(n->ndup.vname);
8517 calcsize(n->ndup.next);
8521 calcsize(n->nhere.doc);
8522 calcsize(n->nhere.next);
8525 calcsize(n->nnot.com);
8529 #endif /* CALCSIZE_TABLE */
8531 static void sizenodelist(const struct nodelist *lp)
8534 funcblocksize += ALIGN(sizeof(struct nodelist));
8541 static struct nodelist *copynodelist(const struct nodelist *lp)
8543 struct nodelist *start;
8544 struct nodelist **lpp;
8549 funcblock = (char *) funcblock + ALIGN(sizeof(struct nodelist));
8550 (*lpp)->n = copynode(lp->n);
8552 lpp = &(*lpp)->next;
8559 static char *nodesavestr(const char *s)
8562 char *q = funcstring;
8563 char *rtn = funcstring;
8565 while ((*q++ = *p++) != '\0')
8571 #ifdef CONFIG_ASH_GETOPTS
8572 static int getopts(char *, char *, char **, int *, int *);
8576 * Process the shell command line arguments.
8579 static void procargs(int argc, char **argv)
8586 for (i = 0; i < NOPTS; i++)
8589 if (*argptr == NULL && minusc == NULL)
8591 if (iflag == 2 && sflag == 1 && isatty(0) && isatty(1))
8595 for (i = 0; i < NOPTS; i++)
8596 if (optent_val(i) == 2)
8599 if (sflag == 0 && minusc == NULL) {
8600 commandname = argv[0];
8602 setinputfile(arg0, 0);
8605 /* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
8606 if (argptr && minusc && *argptr)
8609 shellparam.p = argptr;
8610 shellparam.optind = 1;
8611 shellparam.optoff = -1;
8612 /* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
8614 shellparam.nparam++;
8623 * Process shell options. The global variable argptr contains a pointer
8624 * to the argument list; we advance it past the options.
8627 static inline void minus_o(const char *name, int val)
8632 out1str("Current option settings\n");
8633 for (i = 0; i < NOPTS; i++)
8634 printf("%-16s%s\n", optent_name(optlist[i]),
8635 optent_val(i) ? "on" : "off");
8637 for (i = 0; i < NOPTS; i++)
8638 if (equal(name, optent_name(optlist[i]))) {
8639 setoption(optent_letter(optlist[i]), val);
8642 error("Illegal option -o %s", name);
8647 static void options(int cmdline)
8655 while ((p = *argptr) != NULL) {
8657 if ((c = *p++) == '-') {
8659 if (p[0] == '\0' || (p[0] == '-' && p[1] == '\0')) {
8661 /* "-" means turn off -x and -v */
8664 /* "--" means reset params */
8665 else if (*argptr == NULL)
8668 break; /* "-" or "--" terminates options */
8670 } else if (c == '+') {
8676 while ((c = *p++) != '\0') {
8677 if (c == 'c' && cmdline) {
8680 #ifdef NOHACK /* removing this code allows sh -ce 'foo' for compat */
8684 if (q == NULL || minusc != NULL)
8685 error("Bad -c option");
8690 } else if (c == 'o') {
8691 minus_o(*argptr, val);
8694 } else if (cmdline && (c == '-')) { // long options
8695 if (strcmp(p, "login") == 0)
8706 static void setoption(int flag, int val)
8710 for (i = 0; i < NOPTS; i++)
8711 if (optent_letter(optlist[i]) == flag) {
8712 optent_val(i) = val;
8714 /* #%$ hack for ksh semantics */
8717 else if (flag == 'E')
8722 error("Illegal option -%c", flag);
8729 * Set the shell parameters.
8732 static void setparam(char **argv)
8738 for (nparam = 0; argv[nparam]; nparam++);
8739 ap = newparam = xmalloc((nparam + 1) * sizeof *ap);
8741 *ap++ = xstrdup(*argv++);
8744 freeparam(&shellparam);
8745 shellparam.malloc = 1;
8746 shellparam.nparam = nparam;
8747 shellparam.p = newparam;
8748 shellparam.optind = 1;
8749 shellparam.optoff = -1;
8754 * Free the list of positional parameters.
8757 static void freeparam(volatile struct shparam *param)
8761 if (param->malloc) {
8762 for (ap = param->p; *ap; ap++)
8771 * The shift builtin command.
8774 static int shiftcmd(int argc, char **argv)
8781 n = number(argv[1]);
8782 if (n > shellparam.nparam)
8783 error("can't shift that many");
8785 shellparam.nparam -= n;
8786 for (ap1 = shellparam.p; --n >= 0; ap1++) {
8787 if (shellparam.malloc)
8791 while ((*ap2++ = *ap1++) != NULL);
8792 shellparam.optind = 1;
8793 shellparam.optoff = -1;
8801 * The set command builtin.
8804 static int setcmd(int argc, char **argv)
8807 return showvarscmd(argc, argv);
8811 if (*argptr != NULL) {
8819 static void getoptsreset(const char *value)
8821 shellparam.optind = number(value);
8822 shellparam.optoff = -1;
8825 #ifdef CONFIG_LOCALE_SUPPORT
8826 static void change_lc_all(const char *value)
8828 if (value != 0 && *value != 0)
8829 setlocale(LC_ALL, value);
8832 static void change_lc_ctype(const char *value)
8834 if (value != 0 && *value != 0)
8835 setlocale(LC_CTYPE, value);
8840 #ifdef CONFIG_ASH_GETOPTS
8842 * The getopts builtin. Shellparam.optnext points to the next argument
8843 * to be processed. Shellparam.optptr points to the next character to
8844 * be processed in the current argument. If shellparam.optnext is NULL,
8845 * then it's the first time getopts has been called.
8848 static int getoptscmd(int argc, char **argv)
8853 error("Usage: getopts optstring var [arg]");
8854 else if (argc == 3) {
8855 optbase = shellparam.p;
8856 if (shellparam.optind > shellparam.nparam + 1) {
8857 shellparam.optind = 1;
8858 shellparam.optoff = -1;
8862 if (shellparam.optind > argc - 2) {
8863 shellparam.optind = 1;
8864 shellparam.optoff = -1;
8868 return getopts(argv[1], argv[2], optbase, &shellparam.optind,
8869 &shellparam.optoff);
8873 * Safe version of setvar, returns 1 on success 0 on failure.
8876 static int setvarsafe(const char *name, const char *val, int flags)
8878 struct jmploc jmploc;
8879 struct jmploc *volatile savehandler = handler;
8886 if (setjmp(jmploc.loc))
8890 setvar(name, val, flags);
8892 handler = savehandler;
8897 getopts(char *optstr, char *optvar, char **optfirst, int *myoptind,
8905 char **optnext = optfirst + *myoptind - 1;
8907 if (*myoptind <= 1 || *optoff < 0 || !(*(optnext - 1)) ||
8908 strlen(*(optnext - 1)) < *optoff)
8911 p = *(optnext - 1) + *optoff;
8912 if (p == NULL || *p == '\0') {
8913 /* Current word is done, advance */
8914 if (optnext == NULL)
8917 if (p == NULL || *p != '-' || *++p == '\0') {
8919 *myoptind = optnext - optfirst + 1;
8925 if (p[0] == '-' && p[1] == '\0') /* check for "--" */
8930 for (q = optstr; *q != c;) {
8932 if (optstr[0] == ':') {
8935 err |= setvarsafe("OPTARG", s, 0);
8937 out2fmt("Illegal option -%c\n", c);
8938 (void) unsetvar("OPTARG");
8948 if (*p == '\0' && (p = *optnext) == NULL) {
8949 if (optstr[0] == ':') {
8952 err |= setvarsafe("OPTARG", s, 0);
8955 out2fmt("No arg for -%c option\n", c);
8956 (void) unsetvar("OPTARG");
8964 setvarsafe("OPTARG", p, 0);
8967 setvarsafe("OPTARG", "", 0);
8968 *myoptind = optnext - optfirst + 1;
8975 *optoff = p ? p - *(optnext - 1) : -1;
8976 snprintf(s, sizeof(s), "%d", *myoptind);
8977 err |= setvarsafe("OPTIND", s, VNOFUNC);
8980 err |= setvarsafe(optvar, s, 0);
8991 * XXX - should get rid of. have all builtins use getopt(3). the
8992 * library getopt must have the BSD extension static variable "optreset"
8993 * otherwise it can't be used within the shell safely.
8995 * Standard option processing (a la getopt) for builtin routines. The
8996 * only argument that is passed to nextopt is the option string; the
8997 * other arguments are unnecessary. It return the character, or '\0' on
9001 static int nextopt(const char *optstring)
9007 if ((p = optptr) == NULL || *p == '\0') {
9009 if (p == NULL || *p != '-' || *++p == '\0')
9012 if (p[0] == '-' && p[1] == '\0') /* check for "--" */
9016 for (q = optstring; *q != c;) {
9018 error("Illegal option -%c", c);
9023 if (*p == '\0' && (p = *argptr++) == NULL)
9024 error("No arg for -%c option", c);
9032 static void flushall()
9040 static void out2fmt(const char *fmt, ...)
9045 vfprintf(stderr, fmt, ap);
9050 * Version of write which resumes after a signal is caught.
9053 static int xwrite(int fd, const char *buf, int nbytes)
9062 i = write(fd, buf, n);
9068 } else if (i == 0) {
9071 } else if (errno != EINTR) {
9079 * Shell command parser.
9082 #define EOFMARKLEN 79
9087 struct heredoc *next; /* next here document in list */
9088 union node *here; /* redirection node */
9089 char *eofmark; /* string indicating end of input */
9090 int striptabs; /* if set, strip leading tabs */
9093 static struct heredoc *heredoclist; /* list of here documents to read */
9094 static int parsebackquote; /* nonzero if we are inside backquotes */
9095 static int doprompt; /* if set, prompt the user */
9096 static int needprompt; /* true if interactive and at start of line */
9097 static int lasttoken; /* last token read */
9099 static char *wordtext; /* text of last word returned by readtoken */
9101 static struct nodelist *backquotelist;
9102 static union node *redirnode;
9103 static struct heredoc *heredoc;
9104 static int quoteflag; /* set if (part of) last token was quoted */
9105 static int startlinno; /* line # where last token started */
9108 static union node *list(int);
9109 static union node *andor(void);
9110 static union node *pipeline(void);
9111 static union node *command(void);
9112 static union node *simplecmd(union node **rpp, union node *redir);
9113 static void parsefname(void);
9114 static void parseheredoc(void);
9115 static char peektoken(void);
9116 static int readtoken(void);
9117 static int xxreadtoken(void);
9118 static int readtoken1(int, int, const char *, int);
9119 static int noexpand(char *);
9120 static void synexpect(int) __attribute__ ((noreturn));
9121 static void synerror(const char *) __attribute__ ((noreturn));
9122 static void setprompt(int);
9126 * Read and parse a command. Returns NEOF on end of file. (NULL is a
9127 * valid parse tree indicating a blank line.)
9130 static union node *parsecmd(int interact)
9135 doprompt = interact;
9151 static union node *list(int nlflag)
9153 union node *n1, *n2, *n3;
9157 if (nlflag == 0 && peektoken())
9163 if (tok == TBACKGND) {
9164 if (n2->type == NCMD || n2->type == NPIPE) {
9165 n2->ncmd.backgnd = 1;
9166 } else if (n2->type == NREDIR) {
9167 n2->type = NBACKGND;
9169 n3 = (union node *) stalloc(sizeof(struct nredir));
9170 n3->type = NBACKGND;
9172 n3->nredir.redirect = NULL;
9179 n3 = (union node *) stalloc(sizeof(struct nbinary));
9181 n3->nbinary.ch1 = n1;
9182 n3->nbinary.ch2 = n2;
9206 pungetc(); /* push back EOF on input */
9219 static union node *andor()
9221 union node *n1, *n2, *n3;
9227 if ((t = readtoken()) == TAND) {
9229 } else if (t == TOR) {
9237 n3 = (union node *) stalloc(sizeof(struct nbinary));
9239 n3->nbinary.ch1 = n1;
9240 n3->nbinary.ch2 = n2;
9247 static union node *pipeline()
9249 union node *n1, *n2, *pipenode;
9250 struct nodelist *lp, *prev;
9254 TRACE(("pipeline: entered\n"));
9255 if (readtoken() == TNOT) {
9261 if (readtoken() == TPIPE) {
9262 pipenode = (union node *) stalloc(sizeof(struct npipe));
9263 pipenode->type = NPIPE;
9264 pipenode->npipe.backgnd = 0;
9265 lp = (struct nodelist *) stalloc(sizeof(struct nodelist));
9266 pipenode->npipe.cmdlist = lp;
9270 lp = (struct nodelist *) stalloc(sizeof(struct nodelist));
9274 } while (readtoken() == TPIPE);
9280 n2 = (union node *) stalloc(sizeof(struct nnot));
9290 static union node *command(void)
9292 union node *n1, *n2;
9293 union node *ap, **app;
9294 union node *cp, **cpp;
9295 union node *redir, **rpp;
9302 /* Check for redirection which may precede command */
9303 while (readtoken() == TREDIR) {
9304 *rpp = n2 = redirnode;
9305 rpp = &n2->nfile.next;
9310 switch (readtoken()) {
9312 n1 = (union node *) stalloc(sizeof(struct nif));
9314 n1->nif.test = list(0);
9315 if (readtoken() != TTHEN)
9317 n1->nif.ifpart = list(0);
9319 while (readtoken() == TELIF) {
9320 n2->nif.elsepart = (union node *) stalloc(sizeof(struct nif));
9321 n2 = n2->nif.elsepart;
9323 n2->nif.test = list(0);
9324 if (readtoken() != TTHEN)
9326 n2->nif.ifpart = list(0);
9328 if (lasttoken == TELSE)
9329 n2->nif.elsepart = list(0);
9331 n2->nif.elsepart = NULL;
9334 if (readtoken() != TFI)
9341 n1 = (union node *) stalloc(sizeof(struct nbinary));
9342 n1->type = (lasttoken == TWHILE) ? NWHILE : NUNTIL;
9343 n1->nbinary.ch1 = list(0);
9344 if ((got = readtoken()) != TDO) {
9345 TRACE(("expecting DO got %s %s\n", tokname(got),
9346 got == TWORD ? wordtext : ""));
9349 n1->nbinary.ch2 = list(0);
9350 if (readtoken() != TDONE)
9356 if (readtoken() != TWORD || quoteflag || !goodname(wordtext))
9357 synerror("Bad for loop variable");
9358 n1 = (union node *) stalloc(sizeof(struct nfor));
9360 n1->nfor.var = wordtext;
9362 if (readtoken() == TIN) {
9364 while (readtoken() == TWORD) {
9365 n2 = (union node *) stalloc(sizeof(struct narg));
9367 n2->narg.text = wordtext;
9368 n2->narg.backquote = backquotelist;
9370 app = &n2->narg.next;
9374 if (lasttoken != TNL && lasttoken != TSEMI)
9377 static char argvars[5] = { CTLVAR, VSNORMAL | VSQUOTE,
9380 n2 = (union node *) stalloc(sizeof(struct narg));
9382 n2->narg.text = argvars;
9383 n2->narg.backquote = NULL;
9384 n2->narg.next = NULL;
9387 * Newline or semicolon here is optional (but note
9388 * that the original Bourne shell only allowed NL).
9390 if (lasttoken != TNL && lasttoken != TSEMI)
9394 if (readtoken() != TDO)
9396 n1->nfor.body = list(0);
9397 if (readtoken() != TDONE)
9402 n1 = (union node *) stalloc(sizeof(struct ncase));
9404 if (readtoken() != TWORD)
9406 n1->ncase.expr = n2 = (union node *) stalloc(sizeof(struct narg));
9408 n2->narg.text = wordtext;
9409 n2->narg.backquote = backquotelist;
9410 n2->narg.next = NULL;
9413 } while (readtoken() == TNL);
9414 if (lasttoken != TIN)
9415 synerror("expecting \"in\"");
9416 cpp = &n1->ncase.cases;
9417 checkkwd = 2, readtoken();
9419 if (lasttoken == TLP)
9421 *cpp = cp = (union node *) stalloc(sizeof(struct nclist));
9423 app = &cp->nclist.pattern;
9425 *app = ap = (union node *) stalloc(sizeof(struct narg));
9427 ap->narg.text = wordtext;
9428 ap->narg.backquote = backquotelist;
9429 if (checkkwd = 2, readtoken() != TPIPE)
9431 app = &ap->narg.next;
9434 ap->narg.next = NULL;
9435 if (lasttoken != TRP)
9437 cp->nclist.body = list(0);
9440 if ((t = readtoken()) != TESAC) {
9442 synexpect(TENDCASE);
9444 checkkwd = 2, readtoken();
9446 cpp = &cp->nclist.next;
9447 } while (lasttoken != TESAC);
9452 n1 = (union node *) stalloc(sizeof(struct nredir));
9453 n1->type = NSUBSHELL;
9454 n1->nredir.n = list(0);
9455 n1->nredir.redirect = NULL;
9456 if (readtoken() != TRP)
9462 if (readtoken() != TEND)
9466 /* Handle an empty command like other simple commands. */
9475 * An empty command before a ; doesn't make much sense, and
9476 * should certainly be disallowed in the case of `if ;'.
9482 n1 = simplecmd(rpp, redir);
9489 /* Now check for redirection which may follow command */
9490 while (readtoken() == TREDIR) {
9491 *rpp = n2 = redirnode;
9492 rpp = &n2->nfile.next;
9498 if (n1->type != NSUBSHELL) {
9499 n2 = (union node *) stalloc(sizeof(struct nredir));
9504 n1->nredir.redirect = redir;
9511 static union node *simplecmd(union node **rpp, union node *redir)
9513 union node *args, **app;
9514 union node *n = NULL;
9515 union node *vars, **vpp;
9516 union node **orig_rpp;
9523 /* If we don't have any redirections already, then we must reset
9524 rpp to be the address of the local redir variable. */
9527 /* We save the incoming value, because we need this for shell
9528 functions. There can not be a redirect or an argument between
9529 the function name and the open parenthesis. */
9534 switch (readtoken()) {
9537 n = (union node *) stalloc(sizeof(struct narg));
9539 n->narg.text = wordtext;
9540 n->narg.backquote = backquotelist;
9541 if (lasttoken == TWORD) {
9543 app = &n->narg.next;
9546 vpp = &n->narg.next;
9550 *rpp = n = redirnode;
9551 rpp = &n->nfile.next;
9552 parsefname(); /* read name of redirection file */
9555 if (args && app == &args->narg.next && !vars && rpp == orig_rpp) {
9556 /* We have a function */
9557 if (readtoken() != TRP)
9561 n->narg.next = command();
9574 n = (union node *) stalloc(sizeof(struct ncmd));
9576 n->ncmd.backgnd = 0;
9577 n->ncmd.args = args;
9578 n->ncmd.assign = vars;
9579 n->ncmd.redirect = redir;
9583 static union node *makename(void)
9587 n = (union node *) stalloc(sizeof(struct narg));
9589 n->narg.next = NULL;
9590 n->narg.text = wordtext;
9591 n->narg.backquote = backquotelist;
9595 static void fixredir(union node *n, const char *text, int err)
9597 TRACE(("Fix redir %s %d\n", text, err));
9599 n->ndup.vname = NULL;
9601 if (is_digit(text[0]) && text[1] == '\0')
9602 n->ndup.dupfd = digit_val(text[0]);
9603 else if (text[0] == '-' && text[1] == '\0')
9608 synerror("Bad fd number");
9610 n->ndup.vname = makename();
9615 static void parsefname(void)
9617 union node *n = redirnode;
9619 if (readtoken() != TWORD)
9621 if (n->type == NHERE) {
9622 struct heredoc *here = heredoc;
9628 TRACE(("Here document %d\n", n->type));
9629 if (here->striptabs) {
9630 while (*wordtext == '\t')
9633 if (!noexpand(wordtext) || (i = strlen(wordtext)) == 0
9635 synerror("Illegal eof marker for << redirection");
9636 rmescapes(wordtext);
9637 here->eofmark = wordtext;
9639 if (heredoclist == NULL)
9642 for (p = heredoclist; p->next; p = p->next);
9645 } else if (n->type == NTOFD || n->type == NFROMFD) {
9646 fixredir(n, wordtext, 0);
9648 n->nfile.fname = makename();
9654 * Input any here documents.
9657 static void parseheredoc()
9659 struct heredoc *here;
9662 while (heredoclist) {
9664 heredoclist = here->next;
9669 readtoken1(pgetc(), here->here->type == NHERE ? SQSYNTAX : DQSYNTAX,
9670 here->eofmark, here->striptabs);
9671 n = (union node *) stalloc(sizeof(struct narg));
9672 n->narg.type = NARG;
9673 n->narg.next = NULL;
9674 n->narg.text = wordtext;
9675 n->narg.backquote = backquotelist;
9676 here->here->nhere.doc = n;
9680 static char peektoken()
9686 return tokname_array[t][0];
9689 static int readtoken()
9693 int savecheckalias = checkalias;
9695 #ifdef CONFIG_ASH_ALIAS
9696 int savecheckkwd = checkkwd;
9701 int alreadyseen = tokpushback;
9704 #ifdef CONFIG_ASH_ALIAS
9710 checkalias = savecheckalias;
9716 if (checkkwd == 2) {
9725 * check for keywords
9727 if (t == TWORD && !quoteflag) {
9728 const char *const *pp;
9730 if ((pp = findkwd(wordtext))) {
9731 lasttoken = t = pp - tokname_array;
9732 TRACE(("keyword %s recognized\n", tokname(t)));
9743 } else if (checkalias == 2 && isassignment(wordtext)) {
9744 lasttoken = t = TASSIGN;
9745 } else if (checkalias) {
9746 #ifdef CONFIG_ASH_ALIAS
9747 if (!quoteflag && (ap = *__lookupalias(wordtext)) != NULL
9748 && !(ap->flag & ALIASINUSE)) {
9750 pushstring(ap->val, strlen(ap->val), ap);
9752 checkkwd = savecheckkwd;
9761 TRACE(("token %s %s\n", tokname(t), t == TWORD
9762 || t == TASSIGN ? wordtext : ""));
9764 TRACE(("reread token %s %s\n", tokname(t), t == TWORD
9765 || t == TASSIGN ? wordtext : ""));
9772 * Read the next input token.
9773 * If the token is a word, we set backquotelist to the list of cmds in
9774 * backquotes. We set quoteflag to true if any part of the word was
9776 * If the token is TREDIR, then we set redirnode to a structure containing
9778 * In all cases, the variable startlinno is set to the number of the line
9779 * on which the token starts.
9781 * [Change comment: here documents and internal procedures]
9782 * [Readtoken shouldn't have any arguments. Perhaps we should make the
9783 * word parsing code into a separate routine. In this case, readtoken
9784 * doesn't need to have any internal procedures, but parseword does.
9785 * We could also make parseoperator in essence the main routine, and
9786 * have parseword (readtoken1?) handle both words and redirection.]
9789 #define NEW_xxreadtoken
9790 #ifdef NEW_xxreadtoken
9792 static const char xxreadtoken_chars[] = "\n()&|;"; /* singles must be first! */
9793 static const char xxreadtoken_tokens[] = {
9794 TNL, TLP, TRP, /* only single occurrence allowed */
9795 TBACKGND, TPIPE, TSEMI, /* if single occurrence */
9796 TEOF, /* corresponds to trailing nul */
9797 TAND, TOR, TENDCASE, /* if double occurrence */
9800 #define xxreadtoken_doubles \
9801 (sizeof(xxreadtoken_tokens) - sizeof(xxreadtoken_chars))
9802 #define xxreadtoken_singles \
9803 (sizeof(xxreadtoken_chars) - xxreadtoken_doubles - 1)
9805 static int xxreadtoken()
9817 startlinno = plinno;
9818 for (;;) { /* until token or start of word found */
9821 if ((c != ' ') && (c != '\t')
9822 #ifdef CONFIG_ASH_ALIAS
9827 while ((c = pgetc()) != '\n' && c != PEOF);
9829 } else if (c == '\\') {
9830 if (pgetc() != '\n') {
9834 startlinno = ++plinno;
9835 setprompt(doprompt ? 2 : 0);
9838 = xxreadtoken_chars + sizeof(xxreadtoken_chars) - 1;
9843 needprompt = doprompt;
9846 p = strchr(xxreadtoken_chars, c);
9849 return readtoken1(c, BASESYNTAX, (char *) NULL, 0);
9852 if (p - xxreadtoken_chars >= xxreadtoken_singles) {
9853 if (pgetc() == *p) { /* double occurrence? */
9854 p += xxreadtoken_doubles + 1;
9861 return lasttoken = xxreadtoken_tokens[p - xxreadtoken_chars];
9869 #define RETURN(token) return lasttoken = token
9871 static int xxreadtoken()
9883 startlinno = plinno;
9884 for (;;) { /* until token or start of word found */
9889 #ifdef CONFIG_ASH_ALIAS
9894 while ((c = pgetc()) != '\n' && c != PEOF);
9898 if (pgetc() == '\n') {
9899 startlinno = ++plinno;
9910 needprompt = doprompt;
9938 return readtoken1(c, BASESYNTAX, (char *) NULL, 0);
9944 * If eofmark is NULL, read a word or a redirection symbol. If eofmark
9945 * is not NULL, read a here document. In the latter case, eofmark is the
9946 * word which marks the end of the document and striptabs is true if
9947 * leading tabs should be stripped from the document. The argument firstc
9948 * is the first character of the input token or document.
9950 * Because C does not have internal subroutines, I have simulated them
9951 * using goto's to implement the subroutine linkage. The following macros
9952 * will run code that appears at the end of readtoken1.
9955 #define CHECKEND() {goto checkend; checkend_return:;}
9956 #define PARSEREDIR() {goto parseredir; parseredir_return:;}
9957 #define PARSESUB() {goto parsesub; parsesub_return:;}
9958 #define PARSEBACKQOLD() {oldstyle = 1; goto parsebackq; parsebackq_oldreturn:;}
9959 #define PARSEBACKQNEW() {oldstyle = 0; goto parsebackq; parsebackq_newreturn:;}
9960 #define PARSEARITH() {goto parsearith; parsearith_return:;}
9963 readtoken1(int firstc, int syntax, const char *eofmark, int striptabs)
9968 char line[EOFMARKLEN + 1];
9969 struct nodelist *bqlist;
9972 int varnest; /* levels of variables expansion */
9973 int arinest; /* levels of arithmetic expansion */
9974 int parenlevel; /* levels of parens in arithmetic */
9975 int dqvarnest; /* levels of variables expansion within double quotes */
9977 int prevsyntax; /* syntax before arithmetic */
9980 /* Avoid longjmp clobbering */
9993 startlinno = plinno;
9995 if (syntax == DQSYNTAX)
10004 STARTSTACKSTR(out);
10005 loop:{ /* for each line, until end of word */
10006 CHECKEND(); /* set c to PEOF if at end of here document */
10007 for (;;) { /* until end of line or end of word */
10008 CHECKSTRSPACE(3, out); /* permit 3 calls to USTPUTC */
10009 switch (SIT(c, syntax)) {
10010 case CNL: /* '\n' */
10011 if (syntax == BASESYNTAX)
10012 goto endword; /* exit outer loop */
10020 goto loop; /* continue outer loop */
10025 if ((eofmark == NULL || dblquote) && dqvarnest == 0)
10026 USTPUTC(CTLESC, out);
10029 case CBACK: /* backslash */
10032 USTPUTC('\\', out);
10034 } else if (c == '\n') {
10040 if (dblquote && c != '\\' && c != '`' && c != '$'
10041 && (c != '"' || eofmark != NULL))
10042 USTPUTC('\\', out);
10043 if (SIT(c, SQSYNTAX) == CCTL)
10044 USTPUTC(CTLESC, out);
10045 else if (eofmark == NULL)
10046 USTPUTC(CTLQUOTEMARK, out);
10052 if (eofmark == NULL)
10053 USTPUTC(CTLQUOTEMARK, out);
10057 if (eofmark == NULL)
10058 USTPUTC(CTLQUOTEMARK, out);
10063 if (eofmark != NULL && arinest == 0 && varnest == 0) {
10067 syntax = ARISYNTAX;
10069 } else if (eofmark == NULL && dqvarnest == 0) {
10070 syntax = BASESYNTAX;
10076 case CVAR: /* '$' */
10077 PARSESUB(); /* parse substitution */
10079 case CENDVAR: /* '}' */
10082 if (dqvarnest > 0) {
10085 USTPUTC(CTLENDVAR, out);
10090 #ifdef CONFIG_ASH_MATH_SUPPORT
10091 case CLP: /* '(' in arithmetic */
10095 case CRP: /* ')' in arithmetic */
10096 if (parenlevel > 0) {
10100 if (pgetc() == ')') {
10101 if (--arinest == 0) {
10102 USTPUTC(CTLENDARI, out);
10103 syntax = prevsyntax;
10104 if (syntax == DQSYNTAX)
10112 * unbalanced parens
10113 * (don't 2nd guess - no error)
10121 case CBQUOTE: /* '`' */
10125 goto endword; /* exit outer loop */
10130 goto endword; /* exit outer loop */
10131 #ifdef CONFIG_ASH_ALIAS
10141 if (syntax == ARISYNTAX)
10142 synerror("Missing '))'");
10143 if (syntax != BASESYNTAX && !parsebackquote && eofmark == NULL)
10144 synerror("Unterminated quoted string");
10145 if (varnest != 0) {
10146 startlinno = plinno;
10147 synerror("Missing '}'");
10149 USTPUTC('\0', out);
10150 len = out - stackblock();
10151 out = stackblock();
10152 if (eofmark == NULL) {
10153 if ((c == '>' || c == '<')
10154 && quotef == 0 && len <= 2 && (*out == '\0' || is_digit(*out))) {
10156 return lasttoken = TREDIR;
10161 quoteflag = quotef;
10162 backquotelist = bqlist;
10163 grabstackblock(len);
10165 return lasttoken = TWORD;
10166 /* end of readtoken routine */
10171 * Check to see whether we are at the end of the here document. When this
10172 * is called, c is set to the first character of the next input line. If
10173 * we are at the end of the here document, this routine sets the c to PEOF.
10178 #ifdef CONFIG_ASH_ALIAS
10184 while (c == '\t') {
10188 if (c == *eofmark) {
10189 if (pfgets(line, sizeof line) != NULL) {
10193 for (q = eofmark + 1; *q && *p == *q; p++, q++);
10194 if (*p == '\n' && *q == '\0') {
10197 needprompt = doprompt;
10199 pushstring(line, strlen(line), NULL);
10204 goto checkend_return;
10209 * Parse a redirection operator. The variable "out" points to a string
10210 * specifying the fd to be redirected. The variable "c" contains the
10211 * first character of the redirection operator.
10218 np = (union node *) stalloc(sizeof(struct nfile));
10223 np->type = NAPPEND;
10232 } else { /* c == '<' */
10234 switch (c = pgetc()) {
10236 if (sizeof(struct nfile) != sizeof(struct nhere)) {
10237 np = (union node *) stalloc(sizeof(struct nhere));
10241 heredoc = (struct heredoc *) stalloc(sizeof(struct heredoc));
10242 heredoc->here = np;
10243 if ((c = pgetc()) == '-') {
10244 heredoc->striptabs = 1;
10246 heredoc->striptabs = 0;
10252 np->type = NFROMFD;
10256 np->type = NFROMTO;
10266 np->nfile.fd = digit_val(fd);
10268 goto parseredir_return;
10273 * Parse a substitution. At this point, we have read the dollar sign
10274 * and nothing else.
10282 static const char types[] = "}-+?=";
10286 (c != '(' && c != '{' && !is_name(c) && !is_special(c))
10290 } else if (c == '(') { /* $(command) or $((arith)) */
10291 if (pgetc() == '(') {
10298 USTPUTC(CTLVAR, out);
10299 typeloc = out - stackblock();
10300 USTPUTC(VSNORMAL, out);
10301 subtype = VSNORMAL;
10305 if ((c = pgetc()) == '}')
10308 subtype = VSLENGTH;
10312 if (c > PEOA && is_name(c)) {
10316 } while (c > PEOA && is_in_name(c));
10317 } else if (is_digit(c)) {
10321 } while (is_digit(c));
10322 } else if (is_special(c)) {
10326 badsub:synerror("Bad substitution");
10330 if (subtype == 0) {
10335 /*FALLTHROUGH*/ default:
10336 p = strchr(types, c);
10339 subtype = p - types + VSNORMAL;
10346 subtype = c == '#' ? VSTRIMLEFT : VSTRIMRIGHT;
10358 if (dblquote || arinest)
10360 *(stackblock() + typeloc) = subtype | flags;
10361 if (subtype != VSNORMAL) {
10368 goto parsesub_return;
10373 * Called to parse command substitutions. Newstyle is set if the command
10374 * is enclosed inside $(...); nlpp is a pointer to the head of the linked
10375 * list of commands (passed by reference), and savelen is the number of
10376 * characters on the top of the stack which must be preserved.
10380 struct nodelist **nlpp;
10383 char *volatile str;
10384 struct jmploc jmploc;
10385 struct jmploc *volatile savehandler;
10390 (void) &saveprompt;
10393 savepbq = parsebackquote;
10394 if (setjmp(jmploc.loc)) {
10396 parsebackquote = 0;
10397 handler = savehandler;
10398 longjmp(handler->loc, 1);
10402 savelen = out - stackblock();
10404 str = xmalloc(savelen);
10405 memcpy(str, stackblock(), savelen);
10407 savehandler = handler;
10411 /* We must read until the closing backquote, giving special
10412 treatment to some slashes, and then push the string and
10413 reread it as input, interpreting it normally. */
10420 STARTSTACKSTR(pout);
10426 switch (pc = pgetc()) {
10431 if ((pc = pgetc()) == '\n') {
10438 * If eating a newline, avoid putting
10439 * the newline into the new character
10440 * stream (via the STPUTC after the
10445 if (pc != '\\' && pc != '`' && pc != '$'
10446 && (!dblquote || pc != '"'))
10447 STPUTC('\\', pout);
10454 #ifdef CONFIG_ASH_ALIAS
10457 startlinno = plinno;
10458 synerror("EOF in backquote substitution");
10462 needprompt = doprompt;
10471 STPUTC('\0', pout);
10472 psavelen = pout - stackblock();
10473 if (psavelen > 0) {
10474 pstr = grabstackstr(pout);
10475 setinputstring(pstr);
10480 nlpp = &(*nlpp)->next;
10481 *nlpp = (struct nodelist *) stalloc(sizeof(struct nodelist));
10482 (*nlpp)->next = NULL;
10483 parsebackquote = oldstyle;
10486 saveprompt = doprompt;
10493 doprompt = saveprompt;
10495 if (readtoken() != TRP)
10502 * Start reading from old file again, ignoring any pushed back
10503 * tokens left from the backquote parsing
10508 while (stackblocksize() <= savelen)
10510 STARTSTACKSTR(out);
10512 memcpy(out, str, savelen);
10513 STADJUST(savelen, out);
10519 parsebackquote = savepbq;
10520 handler = savehandler;
10521 if (arinest || dblquote)
10522 USTPUTC(CTLBACKQ | CTLQUOTE, out);
10524 USTPUTC(CTLBACKQ, out);
10526 goto parsebackq_oldreturn;
10528 goto parsebackq_newreturn;
10532 * Parse an arithmetic expansion (indicate start of one and set state)
10536 if (++arinest == 1) {
10537 prevsyntax = syntax;
10538 syntax = ARISYNTAX;
10539 USTPUTC(CTLARI, out);
10546 * we collapse embedded arithmetic expansion to
10547 * parenthesis, which should be equivalent
10551 goto parsearith_return;
10554 } /* end of readtoken */
10558 * Returns true if the text contains nothing to expand (no dollar signs
10562 static int noexpand(char *text)
10568 while ((c = *p++) != '\0') {
10569 if (c == CTLQUOTEMARK)
10573 else if (SIT(c, BASESYNTAX) == CCTL)
10581 * Return true if the argument is a legal variable name (a letter or
10582 * underscore followed by zero or more letters, underscores, and digits).
10585 static int goodname(const char *name)
10593 if (!is_in_name(*p))
10601 * Called when an unexpected token is read during the parse. The argument
10602 * is the token that is expected, or -1 if more than one type of token can
10603 * occur at this point.
10606 static void synexpect(int token)
10611 l = sprintf(msg, "%s unexpected", tokname(lasttoken));
10613 sprintf(msg + l, " (expecting %s)", tokname(token));
10619 static void synerror(const char *msg)
10622 out2fmt("%s: %d: ", commandname, startlinno);
10623 out2fmt("Syntax error: %s\n", msg);
10624 error((char *) NULL);
10630 * called by editline -- any expansions to the prompt
10631 * should be added here.
10633 static void setprompt(int whichprompt)
10637 switch (whichprompt) {
10652 * Code for dealing with input/output redirection.
10655 #define EMPTY -2 /* marks an unused slot in redirtab */
10657 # define PIPESIZE 4096 /* amount of buffering in a pipe */
10659 # define PIPESIZE PIPE_BUF
10664 * Open a file in noclobber mode.
10665 * The code was copied from bash.
10667 static inline int noclobberopen(const char *fname)
10670 struct stat finfo, finfo2;
10673 * If the file exists and is a regular file, return an error
10676 r = stat(fname, &finfo);
10677 if (r == 0 && S_ISREG(finfo.st_mode)) {
10683 * If the file was not present (r != 0), make sure we open it
10684 * exclusively so that if it is created before we open it, our open
10685 * will fail. Make sure that we do not truncate an existing file.
10686 * Note that we don't turn on O_EXCL unless the stat failed -- if the
10687 * file was not a regular file, we leave O_EXCL off.
10690 return open(fname, O_WRONLY | O_CREAT | O_EXCL, 0666);
10691 fd = open(fname, O_WRONLY | O_CREAT, 0666);
10693 /* If the open failed, return the file descriptor right away. */
10698 * OK, the open succeeded, but the file may have been changed from a
10699 * non-regular file to a regular file between the stat and the open.
10700 * We are assuming that the O_EXCL open handles the case where FILENAME
10701 * did not exist and is symlinked to an existing file between the stat
10706 * If we can open it and fstat the file descriptor, and neither check
10707 * revealed that it was a regular file, and the file has not been
10708 * replaced, return the file descriptor.
10710 if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode) &&
10711 finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino)
10714 /* The file has been replaced. badness. */
10721 * Handle here documents. Normally we fork off a process to write the
10722 * data to a pipe. If the document is short, we can stuff the data in
10723 * the pipe without forking.
10726 static inline int openhere(const union node *redir)
10732 error("Pipe call failed");
10733 if (redir->type == NHERE) {
10734 len = strlen(redir->nhere.doc->narg.text);
10735 if (len <= PIPESIZE) {
10736 xwrite(pip[1], redir->nhere.doc->narg.text, len);
10740 if (forkshell((struct job *) NULL, (union node *) NULL, FORK_NOJOB) == 0) {
10742 signal(SIGINT, SIG_IGN);
10743 signal(SIGQUIT, SIG_IGN);
10744 signal(SIGHUP, SIG_IGN);
10746 signal(SIGTSTP, SIG_IGN);
10748 signal(SIGPIPE, SIG_DFL);
10749 if (redir->type == NHERE)
10750 xwrite(pip[1], redir->nhere.doc->narg.text, len);
10752 expandhere(redir->nhere.doc, pip[1]);
10761 static inline int openredirect(const union node *redir)
10766 switch (redir->nfile.type) {
10768 fname = redir->nfile.expfname;
10769 if ((f = open(fname, O_RDONLY)) < 0)
10773 fname = redir->nfile.expfname;
10774 if ((f = open(fname, O_RDWR | O_CREAT | O_TRUNC, 0666)) < 0)
10778 /* Take care of noclobber mode. */
10780 fname = redir->nfile.expfname;
10781 if ((f = noclobberopen(fname)) < 0)
10786 fname = redir->nfile.expfname;
10788 if ((f = open(fname, O_WRONLY | O_CREAT | O_TRUNC, 0666)) < 0)
10791 if ((f = creat(fname, 0666)) < 0)
10796 fname = redir->nfile.expfname;
10798 if ((f = open(fname, O_WRONLY | O_CREAT | O_APPEND, 0666)) < 0)
10801 if ((f = open(fname, O_WRONLY)) < 0 && (f = creat(fname, 0666)) < 0)
10803 lseek(f, (off_t) 0, 2);
10810 /* Fall through to eliminate warning. */
10817 f = openhere(redir);
10823 error("cannot create %s: %s", fname, errmsg(errno, E_CREAT));
10825 error("cannot open %s: %s", fname, errmsg(errno, E_OPEN));
10830 * Process a list of redirection commands. If the REDIR_PUSH flag is set,
10831 * old file descriptors are stashed away so that the redirection can be
10832 * undone by calling popredir. If the REDIR_BACKQ flag is set, then the
10833 * standard output, and the standard error if it becomes a duplicate of
10837 static void redirect(union node *redir, int flags)
10840 struct redirtab *sv = NULL;
10845 int fd1dup = flags & REDIR_BACKQ;; /* stdout `cmd` redir to pipe */
10847 TRACE(("redirect(%s) called\n",
10848 flags & REDIR_PUSH ? "REDIR_PUSH" : "NO_REDIR_PUSH"));
10849 if (flags & REDIR_PUSH) {
10850 sv = xmalloc(sizeof(struct redirtab));
10851 for (i = 0; i < 10; i++)
10852 sv->renamed[i] = EMPTY;
10853 sv->next = redirlist;
10856 for (n = redir; n; n = n->nfile.next) {
10859 if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD) &&
10860 n->ndup.dupfd == fd)
10861 continue; /* redirect from/to same file descriptor */
10864 newfd = openredirect(n);
10865 if ((flags & REDIR_PUSH) && sv->renamed[fd] == EMPTY) {
10868 } else if ((i = fcntl(fd, F_DUPFD, 10)) == -1) {
10872 dupredirect(n, newfd, fd1dup);
10882 error("%d: %m", fd);
10888 if (flags & REDIR_PUSH) {
10889 sv->renamed[fd] = i;
10892 } else if (fd != newfd) {
10898 dupredirect(n, newfd, fd1dup);
10904 static void dupredirect(const union node *redir, int f, int fd1dup)
10906 int fd = redir->nfile.fd;
10910 if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) {
10911 if (redir->ndup.dupfd >= 0) { /* if not ">&-" */
10912 if (redir->ndup.dupfd != 1 || fd1dup != 1)
10913 dup_as_newfd(redir->ndup.dupfd, fd);
10919 dup_as_newfd(f, fd);
10928 * Undo the effects of the last redirection.
10931 static void popredir(void)
10933 struct redirtab *rp = redirlist;
10937 for (i = 0; i < 10; i++) {
10938 if (rp->renamed[i] != EMPTY) {
10942 if (rp->renamed[i] >= 0) {
10943 dup_as_newfd(rp->renamed[i], i);
10944 close(rp->renamed[i]);
10948 redirlist = rp->next;
10954 * Discard all saved file descriptors.
10957 static void clearredir(void)
10959 struct redirtab *rp;
10962 for (rp = redirlist; rp; rp = rp->next) {
10963 for (i = 0; i < 10; i++) {
10964 if (rp->renamed[i] >= 0) {
10965 close(rp->renamed[i]);
10967 rp->renamed[i] = EMPTY;
10974 * Copy a file descriptor to be >= to. Returns -1
10975 * if the source file descriptor is closed, EMPTY if there are no unused
10976 * file descriptors left.
10979 static int dup_as_newfd(int from, int to)
10983 newfd = fcntl(from, F_DUPFD, to);
10985 if (errno == EMFILE)
10988 error("%d: %m", from);
10998 static void shtree(union node *, int, char *, FILE *);
10999 static void shcmd(union node *, FILE *);
11000 static void sharg(union node *, FILE *);
11001 static void indent(int, char *, FILE *);
11002 static void trstring(char *);
11006 static void showtree(node * n)
11008 trputs("showtree called\n");
11009 shtree(n, 1, NULL, stdout);
11013 static void shtree(union node *n, int ind, char *pfx, FILE * fp)
11015 struct nodelist *lp;
11021 indent(ind, pfx, fp);
11032 shtree(n->nbinary.ch1, ind, NULL, fp);
11035 shtree(n->nbinary.ch2, ind, NULL, fp);
11043 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
11048 if (n->npipe.backgnd)
11054 fprintf(fp, "<node type %d>", n->type);
11062 static void shcmd(union node *cmd, FILE * fp)
11070 for (np = cmd->ncmd.args; np; np = np->narg.next) {
11076 for (np = cmd->ncmd.redirect; np; np = np->nfile.next) {
11082 if ((np->nfile.type <= NFROMFD) && (np->nfile.type >= NTO)) {
11083 s = redir_strings[np->nfile.type - NTO];
11089 switch (np->nfile.type) {
11124 if (np->nfile.fd != dftfd)
11125 fprintf(fp, "%d", np->nfile.fd);
11127 if (np->nfile.type == NTOFD || np->nfile.type == NFROMFD) {
11128 fprintf(fp, "%d", np->ndup.dupfd);
11130 sharg(np->nfile.fname, fp);
11137 static void sharg(union node *arg, FILE * fp)
11140 struct nodelist *bqlist;
11143 if (arg->type != NARG) {
11144 printf("<node type %d>\n", arg->type);
11148 bqlist = arg->narg.backquote;
11149 for (p = arg->narg.text; *p; p++) {
11158 if (subtype == VSLENGTH)
11164 if (subtype & VSNUL)
11167 switch (subtype & VSTYPE) {
11186 case VSTRIMLEFTMAX:
11193 case VSTRIMRIGHTMAX:
11200 printf("<subtype %d>", subtype);
11207 case CTLBACKQ | CTLQUOTE:
11210 shtree(bqlist->n, -1, NULL, fp);
11221 static void indent(int amount, char *pfx, FILE * fp)
11225 for (i = 0; i < amount; i++) {
11226 if (pfx && i == amount - 1)
11235 static int debug = 1;
11237 static int debug = 0;
11241 static void trputc(int c)
11243 if (tracefile == NULL)
11245 putc(c, tracefile);
11250 static void trace(const char *fmt, ...)
11255 if (tracefile != NULL) {
11256 (void) vfprintf(tracefile, fmt, va);
11257 if (strchr(fmt, '\n'))
11258 (void) fflush(tracefile);
11264 static void trputs(const char *s)
11266 if (tracefile == NULL)
11268 fputs(s, tracefile);
11269 if (strchr(s, '\n'))
11274 static void trstring(char *s)
11279 if (tracefile == NULL)
11281 putc('"', tracefile);
11282 for (p = s; *p; p++) {
11305 case CTLVAR + CTLQUOTE:
11311 case CTLBACKQ + CTLQUOTE:
11314 backslash:putc('\\', tracefile);
11315 putc(c, tracefile);
11318 if (*p >= ' ' && *p <= '~')
11319 putc(*p, tracefile);
11321 putc('\\', tracefile);
11322 putc(*p >> 6 & 03, tracefile);
11323 putc(*p >> 3 & 07, tracefile);
11324 putc(*p & 07, tracefile);
11329 putc('"', tracefile);
11333 static void trargs(char **ap)
11335 if (tracefile == NULL)
11340 putc(' ', tracefile);
11342 putc('\n', tracefile);
11348 static void opentrace()
11358 #ifdef not_this_way
11362 if ((p = getenv("HOME")) == NULL) {
11363 if (geteuid() == 0)
11369 strcat(s, "/trace");
11372 strcpy(s, "./trace");
11373 #endif /* not_this_way */
11374 if ((tracefile = wfopen(s, "a")) == NULL)
11377 if ((flags = fcntl(fileno(tracefile), F_GETFL, 0)) >= 0)
11378 fcntl(fileno(tracefile), F_SETFL, flags | O_APPEND);
11380 fputs("\nTracing started.\n", tracefile);
11387 * The trap builtin.
11390 static int trapcmd(int argc, char **argv)
11397 for (signo = 0; signo < NSIG; signo++) {
11398 if (trap[signo] != NULL) {
11402 p = single_quote(trap[signo]);
11403 sn = sys_siglist[signo];
11405 sn = u_signal_names(0, &signo, 0);
11408 printf("trap -- %s %s\n", p, sn);
11420 if ((signo = decode_signal(*ap, 0)) < 0)
11421 error("%s: bad trap", *ap);
11424 if (action[0] == '-' && action[1] == '\0')
11427 action = xstrdup(action);
11430 trap[signo] = action;
11441 * Set the signal handler for the specified signal. The routine figures
11442 * out what it should be set to.
11445 static void setsignal(int signo)
11449 struct sigaction act;
11451 if ((t = trap[signo]) == NULL)
11453 else if (*t != '\0')
11457 if (rootshell && action == S_DFL) {
11460 if (iflag || minusc || sflag == 0)
11476 #ifdef CONFIG_ASH_JOB_CONTROL
11486 t = &sigmode[signo - 1];
11489 * current setting unknown
11491 if (sigaction(signo, 0, &act) == -1) {
11493 * Pretend it worked; maybe we should give a warning
11494 * here, but other shells don't. We don't alter
11495 * sigmode, so that we retry every time.
11499 if (act.sa_handler == SIG_IGN) {
11500 if (mflag && (signo == SIGTSTP ||
11501 signo == SIGTTIN || signo == SIGTTOU)) {
11502 *t = S_IGN; /* don't hard ignore these */
11506 *t = S_RESET; /* force to be set */
11509 if (*t == S_HARD_IGN || *t == action)
11511 act.sa_handler = ((action == S_CATCH) ? onsig
11512 : ((action == S_IGN) ? SIG_IGN : SIG_DFL));
11515 sigemptyset(&act.sa_mask);
11516 sigaction(signo, &act, 0);
11523 static void ignoresig(int signo)
11525 if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
11526 signal(signo, SIG_IGN);
11528 sigmode[signo - 1] = S_HARD_IGN;
11536 static void onsig(int signo)
11538 if (signo == SIGINT && trap[SIGINT] == NULL) {
11542 gotsig[signo - 1] = 1;
11548 * Called to execute a trap. Perhaps we should avoid entering new trap
11549 * handlers while we are executing a trap handler.
11552 static void dotrap(void)
11558 for (i = 1;; i++) {
11565 savestatus = exitstatus;
11566 evalstring(trap[i], 0);
11567 exitstatus = savestatus;
11574 * Called to exit the shell.
11577 static void exitshell(int status)
11579 struct jmploc loc1, loc2;
11582 TRACE(("exitshell(%d) pid=%d\n", status, getpid()));
11583 if (setjmp(loc1.loc)) {
11586 if (setjmp(loc2.loc)) {
11590 if ((p = trap[0]) != NULL && *p != '\0') {
11594 l1:handler = &loc2; /* probably unnecessary */
11596 #ifdef CONFIG_ASH_JOB_CONTROL
11603 static int decode_signal(const char *string, int minsig)
11606 const char *name = u_signal_names(string, &signo, minsig);
11608 return name ? signo : -1;
11611 static struct var **hashvar(const char *);
11612 static void showvars(const char *, int, int);
11613 static struct var **findvar(struct var **, const char *);
11616 * Initialize the varable symbol tables and import the environment
11620 * This routine initializes the builtin variables. It is called when the
11621 * shell is initialized and again when a shell procedure is spawned.
11624 static void initvar()
11626 const struct varinit *ip;
11630 for (ip = varinit; (vp = ip->var) != NULL; ip++) {
11631 if ((vp->flags & VEXPORT) == 0) {
11632 vpp = hashvar(ip->text);
11635 vp->text = xstrdup(ip->text);
11636 vp->flags = ip->flags;
11637 vp->func = ip->func;
11640 #if !defined(CONFIG_FEATURE_COMMAND_EDITING) || !defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
11642 * PS1 depends on uid
11644 if ((vps1.flags & VEXPORT) == 0) {
11645 vpp = hashvar("PS1=$ ");
11648 vps1.text = xstrdup(geteuid()? "PS1=$ " : "PS1=# ");
11649 vps1.flags = VSTRFIXED | VTEXTFIXED;
11655 * Set the value of a variable. The flags argument is ored with the
11656 * flags of the variable. If val is NULL, the variable is unset.
11659 static void setvar(const char *name, const char *val, int flags)
11674 if (!is_in_name(*p)) {
11675 if (*p == '\0' || *p == '=')
11681 namelen = p - name;
11683 error("%.*s: bad variable name", namelen, name);
11684 len = namelen + 2; /* 2 is space for '=' and '\0' */
11688 len += vallen = strlen(val);
11691 nameeq = xmalloc(len);
11692 memcpy(nameeq, name, namelen);
11693 nameeq[namelen] = '=';
11695 memcpy(nameeq + namelen + 1, val, vallen + 1);
11697 nameeq[namelen + 1] = '\0';
11699 setvareq(nameeq, flags);
11706 * Same as setvar except that the variable and value are passed in
11707 * the first argument as name=value. Since the first argument will
11708 * be actually stored in the table, it should not be a string that
11712 static void setvareq(char *s, int flags)
11714 struct var *vp, **vpp;
11717 flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1));
11718 if ((vp = *findvar(vpp, s))) {
11719 if (vp->flags & VREADONLY) {
11720 size_t len = strchr(s, '=') - s;
11722 error("%.*s: is read only", len, s);
11726 if (vp->func && (flags & VNOFUNC) == 0)
11727 (*vp->func) (strchr(s, '=') + 1);
11729 if ((vp->flags & (VTEXTFIXED | VSTACK)) == 0)
11732 vp->flags &= ~(VTEXTFIXED | VSTACK | VUNSET);
11733 vp->flags |= flags;
11736 #ifdef CONFIG_ASH_MAIL
11738 * We could roll this to a function, to handle it as
11739 * a regular variable function callback, but why bother?
11741 if (iflag && (vp == &vmpath || (vp == &vmail && !mpathset())))
11748 vp = xmalloc(sizeof(*vp));
11759 * Process a linked list of variable assignments.
11762 static void listsetvar(struct strlist *mylist)
11764 struct strlist *lp;
11767 for (lp = mylist; lp; lp = lp->next) {
11768 setvareq(xstrdup(lp->text), 0);
11776 * Find the value of a variable. Returns NULL if not set.
11779 static const char *lookupvar(const char *name)
11783 if ((v = *findvar(hashvar(name), name)) && !(v->flags & VUNSET)) {
11784 return strchr(v->text, '=') + 1;
11792 * Search the environment of a builtin command.
11795 static const char *bltinlookup(const char *name)
11797 const struct strlist *sp;
11799 for (sp = cmdenviron; sp; sp = sp->next) {
11800 if (varequal(sp->text, name))
11801 return strchr(sp->text, '=') + 1;
11803 return lookupvar(name);
11809 * Generate a list of exported variables. This routine is used to construct
11810 * the third argument to execve when executing a program.
11813 static char **environment()
11822 for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
11823 for (vp = *vpp; vp; vp = vp->next)
11824 if (vp->flags & VEXPORT)
11827 ep = env = stalloc((nenv + 1) * sizeof *env);
11828 for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
11829 for (vp = *vpp; vp; vp = vp->next)
11830 if (vp->flags & VEXPORT)
11839 * Command to list all variables which are set. Currently this command
11840 * is invoked from the set command when the set command is called without
11844 static int showvarscmd(int argc, char **argv)
11846 showvars(nullstr, VUNSET, VUNSET);
11853 * The export and readonly commands.
11856 static int exportcmd(int argc, char **argv)
11861 int flag = argv[0][0] == 'r' ? VREADONLY : VEXPORT;
11864 listsetvar(cmdenviron);
11865 pflag = (nextopt("p") == 'p');
11866 if (argc > 1 && !pflag) {
11867 while ((name = *argptr++) != NULL) {
11868 if ((p = strchr(name, '=')) != NULL) {
11871 if ((vp = *findvar(hashvar(name), name))) {
11876 setvar(name, p, flag);
11880 showvars(argv[0], flag, 0);
11887 * The "local" command.
11890 /* funcnest nonzero if we are currently evaluating a function */
11892 static int localcmd(int argc, char **argv)
11897 error("Not in a function");
11898 while ((name = *argptr++) != NULL) {
11906 * Make a variable a local variable. When a variable is made local, it's
11907 * value and flags are saved in a localvar structure. The saved values
11908 * will be restored when the shell function returns. We handle the name
11909 * "-" as a special case.
11912 static void mklocal(char *name)
11914 struct localvar *lvp;
11919 lvp = xmalloc(sizeof(struct localvar));
11920 if (name[0] == '-' && name[1] == '\0') {
11923 p = xmalloc(sizeof optet_vals);
11924 lvp->text = memcpy(p, optet_vals, sizeof optet_vals);
11927 vpp = hashvar(name);
11928 vp = *findvar(vpp, name);
11930 if (strchr(name, '='))
11931 setvareq(xstrdup(name), VSTRFIXED);
11933 setvar(name, NULL, VSTRFIXED);
11934 vp = *vpp; /* the new variable */
11936 lvp->flags = VUNSET;
11938 lvp->text = vp->text;
11939 lvp->flags = vp->flags;
11940 vp->flags |= VSTRFIXED | VTEXTFIXED;
11941 if (strchr(name, '='))
11942 setvareq(xstrdup(name), 0);
11946 lvp->next = localvars;
11953 * Called after a function returns.
11956 static void poplocalvars()
11958 struct localvar *lvp;
11961 while ((lvp = localvars) != NULL) {
11962 localvars = lvp->next;
11964 if (vp == NULL) { /* $- saved */
11965 memcpy(optet_vals, lvp->text, sizeof optet_vals);
11967 } else if ((lvp->flags & (VUNSET | VSTRFIXED)) == VUNSET) {
11968 (void) unsetvar(vp->text);
11970 if ((vp->flags & VTEXTFIXED) == 0)
11972 vp->flags = lvp->flags;
11973 vp->text = lvp->text;
11980 static int setvarcmd(int argc, char **argv)
11983 return unsetcmd(argc, argv);
11984 else if (argc == 3)
11985 setvar(argv[1], argv[2], 0);
11987 error("List assignment not implemented");
11993 * The unset builtin command. We unset the function before we unset the
11994 * variable to allow a function to be unset when there is a readonly variable
11995 * with the same name.
11998 static int unsetcmd(int argc, char **argv)
12006 while ((i = nextopt("vf")) != '\0') {
12012 if (flg_func == 0 && flg_var == 0)
12015 for (ap = argptr; *ap; ap++) {
12019 ret |= unsetvar(*ap);
12026 * Unset the specified variable.
12029 static int unsetvar(const char *s)
12034 vpp = findvar(hashvar(s), s);
12037 if (vp->flags & VREADONLY)
12040 if (*(strchr(vp->text, '=') + 1) != '\0')
12041 setvar(s, nullstr, 0);
12042 vp->flags &= ~VEXPORT;
12043 vp->flags |= VUNSET;
12044 if ((vp->flags & VSTRFIXED) == 0) {
12045 if ((vp->flags & VTEXTFIXED) == 0)
12060 * Find the appropriate entry in the hash table from the name.
12063 static struct var **hashvar(const char *p)
12065 unsigned int hashval;
12067 hashval = ((unsigned char) *p) << 4;
12068 while (*p && *p != '=')
12069 hashval += (unsigned char) *p++;
12070 return &vartab[hashval % VTABSIZE];
12076 * Returns true if the two strings specify the same varable. The first
12077 * variable name is terminated by '='; the second may be terminated by
12078 * either '=' or '\0'.
12081 static int varequal(const char *p, const char *q)
12083 while (*p == *q++) {
12087 if (*p == '=' && *(q - 1) == '\0')
12092 static void showvars(const char *myprefix, int mask, int xor)
12096 const char *sep = myprefix == nullstr ? myprefix : spcstr;
12098 for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
12099 for (vp = *vpp; vp; vp = vp->next) {
12100 if ((vp->flags & mask) ^ xor) {
12104 p = strchr(vp->text, '=') + 1;
12105 len = p - vp->text;
12106 p = single_quote(p);
12108 printf("%s%s%.*s%s\n", myprefix, sep, len, vp->text, p);
12115 static struct var **findvar(struct var **vpp, const char *name)
12117 for (; *vpp; vpp = &(*vpp)->next) {
12118 if (varequal((*vpp)->text, name)) {
12126 * Copyright (c) 1999 Herbert Xu <herbert@debian.org>
12127 * This file contains code for the times builtin.
12129 static int timescmd(int argc, char **argv)
12132 long int clk_tck = sysconf(_SC_CLK_TCK);
12135 printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n",
12136 (int) (buf.tms_utime / clk_tck / 60),
12137 ((double) buf.tms_utime) / clk_tck,
12138 (int) (buf.tms_stime / clk_tck / 60),
12139 ((double) buf.tms_stime) / clk_tck,
12140 (int) (buf.tms_cutime / clk_tck / 60),
12141 ((double) buf.tms_cutime) / clk_tck,
12142 (int) (buf.tms_cstime / clk_tck / 60),
12143 ((double) buf.tms_cstime) / clk_tck);
12147 #ifdef CONFIG_ASH_MATH_SUPPORT
12148 /* The let builtin. */
12149 int letcmd(int argc, char **argv)
12155 char *tmp, *expression, p[13];
12157 expression = strchr(argv[1], '=');
12159 /* Cannot use 'error()' here, or the return code
12160 * will be incorrect */
12161 out2fmt("sh: let: syntax error: \"%s\"\n", argv[1]);
12164 *expression = '\0';
12165 tmp = ++expression;
12166 result = arith(tmp, &errcode);
12168 /* Cannot use 'error()' here, or the return code
12169 * will be incorrect */
12170 out2fmt("sh: let: ");
12172 out2fmt("divide by zero");
12174 out2fmt("syntax error: \"%s=%s\"\n", argv[1], expression);
12177 snprintf(p, 12, "%ld", result);
12178 setvar(argv[1], xstrdup(p), 0);
12179 } else if (argc >= 3)
12180 synerror("invalid operand");
12188 * Copyright (c) 1989, 1991, 1993, 1994
12189 * The Regents of the University of California. All rights reserved.
12191 * This code is derived from software contributed to Berkeley by
12192 * Kenneth Almquist.
12194 * Redistribution and use in source and binary forms, with or without
12195 * modification, are permitted provided that the following conditions
12197 * 1. Redistributions of source code must retain the above copyright
12198 * notice, this list of conditions and the following disclaimer.
12199 * 2. Redistributions in binary form must reproduce the above copyright
12200 * notice, this list of conditions and the following disclaimer in the
12201 * documentation and/or other materials provided with the distribution.
12203 * 3. <BSD Advertising Clause omitted per the July 22, 1999 licensing change
12204 * ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change>
12206 * 4. Neither the name of the University nor the names of its contributors
12207 * may be used to endorse or promote products derived from this software
12208 * without specific prior written permission.
12210 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
12211 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
12212 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
12213 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
12214 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
12215 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
12216 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
12217 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
12218 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
12219 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF