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
89 * This file was generated by the mksyntax program.
93 #define CWORD 0 /* character is nothing special */
94 #define CNL 1 /* newline character */
95 #define CBACK 2 /* a backslash character */
96 #define CSQUOTE 3 /* single quote */
97 #define CDQUOTE 4 /* double quote */
98 #define CENDQUOTE 5 /* a terminating quote */
99 #define CBQUOTE 6 /* backwards single quote */
100 #define CVAR 7 /* a dollar sign */
101 #define CENDVAR 8 /* a '}' character */
102 #define CLP 9 /* a left paren in arithmetic */
103 #define CRP 10 /* a right paren in arithmetic */
104 #define CENDFILE 11 /* end of file */
105 #define CCTL 12 /* like CWORD, except it must be escaped */
106 #define CSPCL 13 /* these terminate a word */
107 #define CIGN 14 /* character should be ignored */
127 #define TENDBQUOTE 13
147 /* control characters in argument strings */
148 #define CTLESC '\201'
149 #define CTLVAR '\202'
150 #define CTLENDVAR '\203'
151 #define CTLBACKQ '\204'
152 #define CTLQUOTE 01 /* ored with CTLBACKQ code if in quotes */
153 /* CTLBACKQ | CTLQUOTE == '\205' */
154 #define CTLARI '\206'
155 #define CTLENDARI '\207'
156 #define CTLQUOTEMARK '\210'
159 #define is_digit(c) ((c)>='0' && (c)<='9')
160 #define is_name(c) (((c) < CTLESC || (c) > CTLENDARI) && ((c) == '_' || isalpha((unsigned char) (c))))
161 #define is_in_name(c) (((c) < CTLESC || (c) > CTLENDARI) && ((c) == '_' || isalnum((unsigned char) (c))))
164 * is_special(c) evaluates to 1 for c in "!#$*-0123456789?@"; 0 otherwise
165 * (assuming ascii char codes, as the original implementation did)
167 #define is_special(c) \
168 ( (((unsigned int)c) - 33 < 32) \
169 && ((0xc1ff920dUL >> (((unsigned int)c) - 33)) & 1))
171 #define digit_val(c) ((c) - '0')
174 #define S_DFL 1 /* default signal handling (SIG_DFL) */
175 #define S_CATCH 2 /* signal is caught */
176 #define S_IGN 3 /* signal is ignored (SIG_IGN) */
177 #define S_HARD_IGN 4 /* signal is ignored permenantly */
178 #define S_RESET 5 /* temporary - to reset a hard ignored sig */
181 /* variable substitution byte (follows CTLVAR) */
182 #define VSTYPE 0x0f /* type of variable substitution */
183 #define VSNUL 0x10 /* colon--treat the empty string as unset */
184 #define VSQUOTE 0x80 /* inside double quotes--suppress splitting */
186 /* values of VSTYPE field */
187 #define VSNORMAL 0x1 /* normal variable: $var or ${var} */
188 #define VSMINUS 0x2 /* ${var-text} */
189 #define VSPLUS 0x3 /* ${var+text} */
190 #define VSQUESTION 0x4 /* ${var?message} */
191 #define VSASSIGN 0x5 /* ${var=text} */
192 #define VSTRIMLEFT 0x6 /* ${var#pattern} */
193 #define VSTRIMLEFTMAX 0x7 /* ${var##pattern} */
194 #define VSTRIMRIGHT 0x8 /* ${var%pattern} */
195 #define VSTRIMRIGHTMAX 0x9 /* ${var%%pattern} */
196 #define VSLENGTH 0xa /* ${#var} */
198 /* flags passed to redirect */
199 #define REDIR_PUSH 01 /* save previous values of file descriptors */
200 #define REDIR_BACKQ 02 /* save the command output to pipe */
203 * BSD setjmp saves the signal mask, which violates ANSI C and takes time,
204 * so we use _setjmp instead.
208 #define setjmp(jmploc) _setjmp(jmploc)
209 #define longjmp(jmploc, val) _longjmp(jmploc, val)
213 * Most machines require the value returned from malloc to be aligned
214 * in some way. The following macro will get this right on many machines.
223 #define ALIGN(nbytes) (((nbytes) + sizeof(union align) - 1) & ~(sizeof(union align) - 1))
226 #ifdef CONFIG_LOCALE_SUPPORT
228 static void change_lc_all(const char *value);
229 static void change_lc_ctype(const char *value);
233 * These macros allow the user to suspend the handling of interrupt signals
234 * over a period of time. This is similar to SIGHOLD to or sigblock, but
235 * much more efficient and portable. (But hacking the kernel is so much
236 * more fun than worrying about efficiency and portability. :-))
239 static void onint(void);
240 static volatile int suppressint;
241 static volatile int intpending;
243 #define INTOFF suppressint++
244 #ifndef CONFIG_ASH_OPTIMIZE_FOR_SIZE
245 #define INTON { if (--suppressint == 0 && intpending) onint(); }
246 #define FORCEINTON {suppressint = 0; if (intpending) onint();}
248 static void __inton(void);
249 static void forceinton(void);
251 #define INTON __inton()
252 #define FORCEINTON forceinton()
255 #define CLEAR_PENDING_INT intpending = 0
256 #define int_pending() intpending
259 typedef void *pointer;
262 #define NULL (void *)0
265 static pointer stalloc(int);
266 static void stunalloc(pointer);
267 static void ungrabstackstr(char *, char *);
268 static char *growstackstr(void);
269 static char *makestrspace(size_t newlen);
272 * Parse trees for commands are allocated in lifo order, so we use a stack
273 * to make this more efficient, and also to avoid all sorts of exception
274 * handling code to handle interrupts in the middle of a parse.
276 * The size 504 was chosen because the Ultrix malloc handles that size
280 #define MINSIZE 504 /* minimum size of a block */
284 struct stack_block *prev;
288 static struct stack_block stackbase;
289 static struct stack_block *stackp = &stackbase;
290 static struct stackmark *markp;
291 static char *stacknxt = stackbase.space;
292 static int stacknleft = MINSIZE;
295 #define equal(s1, s2) (strcmp(s1, s2) == 0)
297 #define stackblock() stacknxt
298 #define stackblocksize() stacknleft
299 #define STARTSTACKSTR(p) p = stackblock(), sstrnleft = stackblocksize()
301 #define STPUTC(c, p) (--sstrnleft >= 0? (*p++ = (c)) : (p = growstackstr(), *p++ = (c)))
302 #define CHECKSTRSPACE(n, p) { if (sstrnleft < n) p = makestrspace(n); }
303 #define STACKSTRNUL(p) (sstrnleft == 0? (p = growstackstr(), *p = '\0') : (*p = '\0'))
306 #define USTPUTC(c, p) (--sstrnleft, *p++ = (c))
307 #define STUNPUTC(p) (++sstrnleft, --p)
308 #define STTOPC(p) p[-1]
309 #define STADJUST(amount, p) (p += (amount), sstrnleft -= (amount))
310 #define grabstackstr(p) stalloc(stackblocksize() - sstrnleft)
314 #define TRACE(param) trace param
315 typedef union node unode;
316 static void trace(const char *, ...);
317 static void trargs(char **);
318 static void showtree(unode *);
319 static void trputc(int);
320 static void trputs(const char *);
321 static void opentrace(void);
356 #define EXP_FULL 0x1 /* perform word splitting & file globbing */
357 #define EXP_TILDE 0x2 /* do normal tilde expansion */
358 #define EXP_VARTILDE 0x4 /* expand tildes in an assignment */
359 #define EXP_REDIR 0x8 /* file glob for a redirection (1 match only) */
360 #define EXP_CASE 0x10 /* keeps quotes around for CASE pattern */
361 #define EXP_RECORD 0x20 /* need to record arguments for ifs breakup */
366 static char optet_vals[NOPTS];
368 static const char *const optlist[NOPTS] = {
387 #define optent_name(optent) (optent+1)
388 #define optent_letter(optent) optent[0]
389 #define optent_val(optent) optet_vals[optent]
391 #define eflag optent_val(0)
392 #define fflag optent_val(1)
393 #define Iflag optent_val(2)
394 #define iflag optent_val(3)
395 #define mflag optent_val(4)
396 #define nflag optent_val(5)
397 #define sflag optent_val(6)
398 #define xflag optent_val(7)
399 #define vflag optent_val(8)
400 #define Vflag optent_val(9)
401 #define Eflag optent_val(10)
402 #define Cflag optent_val(11)
403 #define aflag optent_val(12)
404 #define bflag optent_val(13)
405 #define uflag optent_val(14)
406 #define qflag optent_val(15)
409 /* Mode argument to forkshell. Don't change FORK_FG or FORK_BG. */
427 union node *redirect;
434 struct nodelist *cmdlist;
441 union node *redirect;
449 union node *elsepart;
480 struct nodelist *backquote;
518 struct nbinary nbinary;
521 struct nredir nredir;
525 struct nclist nclist;
535 struct nodelist *next;
539 struct backcmd { /* result of evalbackcmd */
540 int fd; /* file descriptor to read from */
541 char *buf; /* buffer */
542 int nleft; /* number of chars in buffer */
543 struct job *jp; /* job structure for command */
551 const struct builtincmd *cmd;
556 struct strlist *next;
562 struct strlist *list;
563 struct strlist **lastp;
567 struct strpush *prev; /* preceding string on stack */
570 #ifdef CONFIG_ASH_ALIAS
571 struct alias *ap; /* if push was associated with an alias */
573 char *string; /* remember the string since it may change */
577 struct parsefile *prev; /* preceding file on stack */
578 int linno; /* current line */
579 int fd; /* file descriptor (or -1 if string) */
580 int nleft; /* number of chars left in this line */
581 int lleft; /* number of chars left in this buffer */
582 char *nextc; /* next char in buffer */
583 char *buf; /* input buffer */
584 struct strpush *strpush; /* for pushing strings at this level */
585 struct strpush basestrpush; /* so pushing one is fast */
589 struct stack_block *stackp;
592 struct stackmark *marknext;
596 int nparam; /* # of positional parameters (without $0) */
597 unsigned char malloc; /* if parameter list dynamically allocated */
598 char **p; /* parameter list */
599 int optind; /* next parameter to be processed by getopts */
600 int optoff; /* used by getopts */
604 * When commands are first encountered, they are entered in a hash table.
605 * This ensures that a full path search will not have to be done for them
606 * on each invocation.
608 * We should investigate converting to a linear search, even though that
609 * would make the command name "hash" a misnomer.
611 #define CMDTABLESIZE 31 /* should be prime */
612 #define ARB 1 /* actual size determined at run time */
617 struct tblentry *next; /* next entry in hash chain */
618 union param param; /* definition of builtin function */
619 short cmdtype; /* index identifying command */
620 char rehash; /* if set, cd done since entry created */
621 char cmdname[ARB]; /* name of command */
625 static struct tblentry *cmdtable[CMDTABLESIZE];
626 static int builtinloc = -1; /* index in path of %builtin, or -1 */
627 static int exerrno = 0; /* Last exec error */
630 static void tryexec(char *, char **, char **);
631 static void printentry(struct tblentry *, int);
632 static void clearcmdentry(int);
633 static struct tblentry *cmdlookup(const char *, int);
634 static void delete_cmd_entry(void);
635 static int path_change(const char *, int *);
638 static void flushall(void);
639 static void out2fmt(const char *, ...)
640 __attribute__ ((__format__(__printf__, 1, 2)));
641 static int xwrite(int, const char *, int);
643 static inline void outstr(const char *p, FILE * file)
647 static void out1str(const char *p)
651 static void out2str(const char *p)
656 #ifndef CONFIG_ASH_OPTIMIZE_FOR_SIZE
657 #define out2c(c) putc((c), stderr)
659 static void out2c(int c)
666 #ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE
667 #define USE_SIT_FUNCTION
670 /* number syntax index */
671 #define BASESYNTAX 0 /* not in quotes */
672 #define DQSYNTAX 1 /* in double quotes */
673 #define SQSYNTAX 2 /* in single quotes */
674 #define ARISYNTAX 3 /* in arithmetic */
676 static const char S_I_T[][4] = {
677 {CSPCL, CIGN, CIGN, CIGN}, /* 0, PEOA */
678 {CSPCL, CWORD, CWORD, CWORD}, /* 1, ' ' */
679 {CNL, CNL, CNL, CNL}, /* 2, \n */
680 {CWORD, CCTL, CCTL, CWORD}, /* 3, !*-/:=?[]~ */
681 {CDQUOTE, CENDQUOTE, CWORD, CDQUOTE}, /* 4, '"' */
682 {CVAR, CVAR, CWORD, CVAR}, /* 5, $ */
683 {CSQUOTE, CWORD, CENDQUOTE, CSQUOTE}, /* 6, "'" */
684 {CSPCL, CWORD, CWORD, CLP}, /* 7, ( */
685 {CSPCL, CWORD, CWORD, CRP}, /* 8, ) */
686 {CBACK, CBACK, CCTL, CBACK}, /* 9, \ */
687 {CBQUOTE, CBQUOTE, CWORD, CBQUOTE}, /* 10, ` */
688 {CENDVAR, CENDVAR, CWORD, CENDVAR}, /* 11, } */
689 #ifndef USE_SIT_FUNCTION
690 {CENDFILE, CENDFILE, CENDFILE, CENDFILE}, /* 12, PEOF */
691 {CWORD, CWORD, CWORD, CWORD}, /* 13, 0-9A-Za-z */
692 {CCTL, CCTL, CCTL, CCTL} /* 14, CTLESC ... */
696 #ifdef USE_SIT_FUNCTION
698 #define U_C(c) ((unsigned char)(c))
700 static int SIT(int c, int syntax)
702 static const char spec_symbls[] = "\t\n !\"$&'()*-/:;<=>?[\\]`|}~";
703 static const char syntax_index_table[] = {
704 1, 2, 1, 3, 4, 5, 1, 6, /* "\t\n !\"$&'" */
705 7, 8, 3, 3, 3, 3, 1, 1, /* "()*-/:;<" */
706 3, 1, 3, 3, 9, 3, 10, 1, /* "=>?[\\]`|" */
712 if (c == PEOF) /* 2^8+2 */
714 if (c == PEOA) /* 2^8+1 */
716 else if (U_C(c) >= U_C(CTLESC) && U_C(c) <= U_C(CTLQUOTEMARK))
719 s = strchr(spec_symbls, c);
722 indx = syntax_index_table[(s - spec_symbls)];
724 return S_I_T[indx][syntax];
727 #else /* USE_SIT_FUNCTION */
729 #define SIT(c, syntax) S_I_T[(int)syntax_index_table[((int)c)+SYNBASE]][syntax]
731 #define CSPCL_CIGN_CIGN_CIGN 0
732 #define CSPCL_CWORD_CWORD_CWORD 1
733 #define CNL_CNL_CNL_CNL 2
734 #define CWORD_CCTL_CCTL_CWORD 3
735 #define CDQUOTE_CENDQUOTE_CWORD_CDQUOTE 4
736 #define CVAR_CVAR_CWORD_CVAR 5
737 #define CSQUOTE_CWORD_CENDQUOTE_CSQUOTE 6
738 #define CSPCL_CWORD_CWORD_CLP 7
739 #define CSPCL_CWORD_CWORD_CRP 8
740 #define CBACK_CBACK_CCTL_CBACK 9
741 #define CBQUOTE_CBQUOTE_CWORD_CBQUOTE 10
742 #define CENDVAR_CENDVAR_CWORD_CENDVAR 11
743 #define CENDFILE_CENDFILE_CENDFILE_CENDFILE 12
744 #define CWORD_CWORD_CWORD_CWORD 13
745 #define CCTL_CCTL_CCTL_CCTL 14
747 static const char syntax_index_table[258] = {
748 /* BASESYNTAX_DQSYNTAX_SQSYNTAX_ARISYNTAX */
749 /* 0 -130 PEOF */ CENDFILE_CENDFILE_CENDFILE_CENDFILE,
750 /* 1 -129 PEOA */ CSPCL_CIGN_CIGN_CIGN,
751 /* 2 -128 0xff */ CWORD_CWORD_CWORD_CWORD,
752 /* 3 -127 */ CCTL_CCTL_CCTL_CCTL,
754 /* 4 -126 */ CCTL_CCTL_CCTL_CCTL,
755 /* 5 -125 */ CCTL_CCTL_CCTL_CCTL,
756 /* 6 -124 */ CCTL_CCTL_CCTL_CCTL,
757 /* 7 -123 */ CCTL_CCTL_CCTL_CCTL,
758 /* 8 -122 */ CCTL_CCTL_CCTL_CCTL,
759 /* 9 -121 */ CCTL_CCTL_CCTL_CCTL,
760 /* 10 -120 */ CCTL_CCTL_CCTL_CCTL,
762 /* 11 -119 */ CWORD_CWORD_CWORD_CWORD,
763 /* 12 -118 */ CWORD_CWORD_CWORD_CWORD,
764 /* 13 -117 */ CWORD_CWORD_CWORD_CWORD,
765 /* 14 -116 */ CWORD_CWORD_CWORD_CWORD,
766 /* 15 -115 */ CWORD_CWORD_CWORD_CWORD,
767 /* 16 -114 */ CWORD_CWORD_CWORD_CWORD,
768 /* 17 -113 */ CWORD_CWORD_CWORD_CWORD,
769 /* 18 -112 */ CWORD_CWORD_CWORD_CWORD,
770 /* 19 -111 */ CWORD_CWORD_CWORD_CWORD,
771 /* 20 -110 */ CWORD_CWORD_CWORD_CWORD,
772 /* 21 -109 */ CWORD_CWORD_CWORD_CWORD,
773 /* 22 -108 */ CWORD_CWORD_CWORD_CWORD,
774 /* 23 -107 */ CWORD_CWORD_CWORD_CWORD,
775 /* 24 -106 */ CWORD_CWORD_CWORD_CWORD,
776 /* 25 -105 */ CWORD_CWORD_CWORD_CWORD,
777 /* 26 -104 */ CWORD_CWORD_CWORD_CWORD,
778 /* 27 -103 */ CWORD_CWORD_CWORD_CWORD,
779 /* 28 -102 */ CWORD_CWORD_CWORD_CWORD,
780 /* 29 -101 */ CWORD_CWORD_CWORD_CWORD,
781 /* 30 -100 */ CWORD_CWORD_CWORD_CWORD,
782 /* 31 -99 */ CWORD_CWORD_CWORD_CWORD,
783 /* 32 -98 */ CWORD_CWORD_CWORD_CWORD,
784 /* 33 -97 */ CWORD_CWORD_CWORD_CWORD,
785 /* 34 -96 */ CWORD_CWORD_CWORD_CWORD,
786 /* 35 -95 */ CWORD_CWORD_CWORD_CWORD,
787 /* 36 -94 */ CWORD_CWORD_CWORD_CWORD,
788 /* 37 -93 */ CWORD_CWORD_CWORD_CWORD,
789 /* 38 -92 */ CWORD_CWORD_CWORD_CWORD,
790 /* 39 -91 */ CWORD_CWORD_CWORD_CWORD,
791 /* 40 -90 */ CWORD_CWORD_CWORD_CWORD,
792 /* 41 -89 */ CWORD_CWORD_CWORD_CWORD,
793 /* 42 -88 */ CWORD_CWORD_CWORD_CWORD,
794 /* 43 -87 */ CWORD_CWORD_CWORD_CWORD,
795 /* 44 -86 */ CWORD_CWORD_CWORD_CWORD,
796 /* 45 -85 */ CWORD_CWORD_CWORD_CWORD,
797 /* 46 -84 */ CWORD_CWORD_CWORD_CWORD,
798 /* 47 -83 */ CWORD_CWORD_CWORD_CWORD,
799 /* 48 -82 */ CWORD_CWORD_CWORD_CWORD,
800 /* 49 -81 */ CWORD_CWORD_CWORD_CWORD,
801 /* 50 -80 */ CWORD_CWORD_CWORD_CWORD,
802 /* 51 -79 */ CWORD_CWORD_CWORD_CWORD,
803 /* 52 -78 */ CWORD_CWORD_CWORD_CWORD,
804 /* 53 -77 */ CWORD_CWORD_CWORD_CWORD,
805 /* 54 -76 */ CWORD_CWORD_CWORD_CWORD,
806 /* 55 -75 */ CWORD_CWORD_CWORD_CWORD,
807 /* 56 -74 */ CWORD_CWORD_CWORD_CWORD,
808 /* 57 -73 */ CWORD_CWORD_CWORD_CWORD,
809 /* 58 -72 */ CWORD_CWORD_CWORD_CWORD,
810 /* 59 -71 */ CWORD_CWORD_CWORD_CWORD,
811 /* 60 -70 */ CWORD_CWORD_CWORD_CWORD,
812 /* 61 -69 */ CWORD_CWORD_CWORD_CWORD,
813 /* 62 -68 */ CWORD_CWORD_CWORD_CWORD,
814 /* 63 -67 */ CWORD_CWORD_CWORD_CWORD,
815 /* 64 -66 */ CWORD_CWORD_CWORD_CWORD,
816 /* 65 -65 */ CWORD_CWORD_CWORD_CWORD,
817 /* 66 -64 */ CWORD_CWORD_CWORD_CWORD,
818 /* 67 -63 */ CWORD_CWORD_CWORD_CWORD,
819 /* 68 -62 */ CWORD_CWORD_CWORD_CWORD,
820 /* 69 -61 */ CWORD_CWORD_CWORD_CWORD,
821 /* 70 -60 */ CWORD_CWORD_CWORD_CWORD,
822 /* 71 -59 */ CWORD_CWORD_CWORD_CWORD,
823 /* 72 -58 */ CWORD_CWORD_CWORD_CWORD,
824 /* 73 -57 */ CWORD_CWORD_CWORD_CWORD,
825 /* 74 -56 */ CWORD_CWORD_CWORD_CWORD,
826 /* 75 -55 */ CWORD_CWORD_CWORD_CWORD,
827 /* 76 -54 */ CWORD_CWORD_CWORD_CWORD,
828 /* 77 -53 */ CWORD_CWORD_CWORD_CWORD,
829 /* 78 -52 */ CWORD_CWORD_CWORD_CWORD,
830 /* 79 -51 */ CWORD_CWORD_CWORD_CWORD,
831 /* 80 -50 */ CWORD_CWORD_CWORD_CWORD,
832 /* 81 -49 */ CWORD_CWORD_CWORD_CWORD,
833 /* 82 -48 */ CWORD_CWORD_CWORD_CWORD,
834 /* 83 -47 */ CWORD_CWORD_CWORD_CWORD,
835 /* 84 -46 */ CWORD_CWORD_CWORD_CWORD,
836 /* 85 -45 */ CWORD_CWORD_CWORD_CWORD,
837 /* 86 -44 */ CWORD_CWORD_CWORD_CWORD,
838 /* 87 -43 */ CWORD_CWORD_CWORD_CWORD,
839 /* 88 -42 */ CWORD_CWORD_CWORD_CWORD,
840 /* 89 -41 */ CWORD_CWORD_CWORD_CWORD,
841 /* 90 -40 */ CWORD_CWORD_CWORD_CWORD,
842 /* 91 -39 */ CWORD_CWORD_CWORD_CWORD,
843 /* 92 -38 */ CWORD_CWORD_CWORD_CWORD,
844 /* 93 -37 */ CWORD_CWORD_CWORD_CWORD,
845 /* 94 -36 */ CWORD_CWORD_CWORD_CWORD,
846 /* 95 -35 */ CWORD_CWORD_CWORD_CWORD,
847 /* 96 -34 */ CWORD_CWORD_CWORD_CWORD,
848 /* 97 -33 */ CWORD_CWORD_CWORD_CWORD,
849 /* 98 -32 */ CWORD_CWORD_CWORD_CWORD,
850 /* 99 -31 */ CWORD_CWORD_CWORD_CWORD,
851 /* 100 -30 */ CWORD_CWORD_CWORD_CWORD,
852 /* 101 -29 */ CWORD_CWORD_CWORD_CWORD,
853 /* 102 -28 */ CWORD_CWORD_CWORD_CWORD,
854 /* 103 -27 */ CWORD_CWORD_CWORD_CWORD,
855 /* 104 -26 */ CWORD_CWORD_CWORD_CWORD,
856 /* 105 -25 */ CWORD_CWORD_CWORD_CWORD,
857 /* 106 -24 */ CWORD_CWORD_CWORD_CWORD,
858 /* 107 -23 */ CWORD_CWORD_CWORD_CWORD,
859 /* 108 -22 */ CWORD_CWORD_CWORD_CWORD,
860 /* 109 -21 */ CWORD_CWORD_CWORD_CWORD,
861 /* 110 -20 */ CWORD_CWORD_CWORD_CWORD,
862 /* 111 -19 */ CWORD_CWORD_CWORD_CWORD,
863 /* 112 -18 */ CWORD_CWORD_CWORD_CWORD,
864 /* 113 -17 */ CWORD_CWORD_CWORD_CWORD,
865 /* 114 -16 */ CWORD_CWORD_CWORD_CWORD,
866 /* 115 -15 */ CWORD_CWORD_CWORD_CWORD,
867 /* 116 -14 */ CWORD_CWORD_CWORD_CWORD,
868 /* 117 -13 */ CWORD_CWORD_CWORD_CWORD,
869 /* 118 -12 */ CWORD_CWORD_CWORD_CWORD,
870 /* 119 -11 */ CWORD_CWORD_CWORD_CWORD,
871 /* 120 -10 */ CWORD_CWORD_CWORD_CWORD,
872 /* 121 -9 */ CWORD_CWORD_CWORD_CWORD,
873 /* 122 -8 */ CWORD_CWORD_CWORD_CWORD,
874 /* 123 -7 */ CWORD_CWORD_CWORD_CWORD,
875 /* 124 -6 */ CWORD_CWORD_CWORD_CWORD,
876 /* 125 -5 */ CWORD_CWORD_CWORD_CWORD,
877 /* 126 -4 */ CWORD_CWORD_CWORD_CWORD,
878 /* 127 -3 */ CWORD_CWORD_CWORD_CWORD,
879 /* 128 -2 */ CWORD_CWORD_CWORD_CWORD,
880 /* 129 -1 */ CWORD_CWORD_CWORD_CWORD,
881 /* 130 0 */ CWORD_CWORD_CWORD_CWORD,
882 /* 131 1 */ CWORD_CWORD_CWORD_CWORD,
883 /* 132 2 */ CWORD_CWORD_CWORD_CWORD,
884 /* 133 3 */ CWORD_CWORD_CWORD_CWORD,
885 /* 134 4 */ CWORD_CWORD_CWORD_CWORD,
886 /* 135 5 */ CWORD_CWORD_CWORD_CWORD,
887 /* 136 6 */ CWORD_CWORD_CWORD_CWORD,
888 /* 137 7 */ CWORD_CWORD_CWORD_CWORD,
889 /* 138 8 */ CWORD_CWORD_CWORD_CWORD,
890 /* 139 9 "\t" */ CSPCL_CWORD_CWORD_CWORD,
891 /* 140 10 "\n" */ CNL_CNL_CNL_CNL,
892 /* 141 11 */ CWORD_CWORD_CWORD_CWORD,
893 /* 142 12 */ CWORD_CWORD_CWORD_CWORD,
894 /* 143 13 */ CWORD_CWORD_CWORD_CWORD,
895 /* 144 14 */ CWORD_CWORD_CWORD_CWORD,
896 /* 145 15 */ CWORD_CWORD_CWORD_CWORD,
897 /* 146 16 */ CWORD_CWORD_CWORD_CWORD,
898 /* 147 17 */ CWORD_CWORD_CWORD_CWORD,
899 /* 148 18 */ CWORD_CWORD_CWORD_CWORD,
900 /* 149 19 */ CWORD_CWORD_CWORD_CWORD,
901 /* 150 20 */ CWORD_CWORD_CWORD_CWORD,
902 /* 151 21 */ CWORD_CWORD_CWORD_CWORD,
903 /* 152 22 */ CWORD_CWORD_CWORD_CWORD,
904 /* 153 23 */ CWORD_CWORD_CWORD_CWORD,
905 /* 154 24 */ CWORD_CWORD_CWORD_CWORD,
906 /* 155 25 */ CWORD_CWORD_CWORD_CWORD,
907 /* 156 26 */ CWORD_CWORD_CWORD_CWORD,
908 /* 157 27 */ CWORD_CWORD_CWORD_CWORD,
909 /* 158 28 */ CWORD_CWORD_CWORD_CWORD,
910 /* 159 29 */ CWORD_CWORD_CWORD_CWORD,
911 /* 160 30 */ CWORD_CWORD_CWORD_CWORD,
912 /* 161 31 */ CWORD_CWORD_CWORD_CWORD,
913 /* 162 32 " " */ CSPCL_CWORD_CWORD_CWORD,
914 /* 163 33 "!" */ CWORD_CCTL_CCTL_CWORD,
915 /* 164 34 """ */ CDQUOTE_CENDQUOTE_CWORD_CDQUOTE,
916 /* 165 35 "#" */ CWORD_CWORD_CWORD_CWORD,
917 /* 166 36 "$" */ CVAR_CVAR_CWORD_CVAR,
918 /* 167 37 "%" */ CWORD_CWORD_CWORD_CWORD,
919 /* 168 38 "&" */ CSPCL_CWORD_CWORD_CWORD,
920 /* 169 39 "'" */ CSQUOTE_CWORD_CENDQUOTE_CSQUOTE,
921 /* 170 40 "(" */ CSPCL_CWORD_CWORD_CLP,
922 /* 171 41 ")" */ CSPCL_CWORD_CWORD_CRP,
923 /* 172 42 "*" */ CWORD_CCTL_CCTL_CWORD,
924 /* 173 43 "+" */ CWORD_CWORD_CWORD_CWORD,
925 /* 174 44 "," */ CWORD_CWORD_CWORD_CWORD,
926 /* 175 45 "-" */ CWORD_CCTL_CCTL_CWORD,
927 /* 176 46 "." */ CWORD_CWORD_CWORD_CWORD,
928 /* 177 47 "/" */ CWORD_CCTL_CCTL_CWORD,
929 /* 178 48 "0" */ CWORD_CWORD_CWORD_CWORD,
930 /* 179 49 "1" */ CWORD_CWORD_CWORD_CWORD,
931 /* 180 50 "2" */ CWORD_CWORD_CWORD_CWORD,
932 /* 181 51 "3" */ CWORD_CWORD_CWORD_CWORD,
933 /* 182 52 "4" */ CWORD_CWORD_CWORD_CWORD,
934 /* 183 53 "5" */ CWORD_CWORD_CWORD_CWORD,
935 /* 184 54 "6" */ CWORD_CWORD_CWORD_CWORD,
936 /* 185 55 "7" */ CWORD_CWORD_CWORD_CWORD,
937 /* 186 56 "8" */ CWORD_CWORD_CWORD_CWORD,
938 /* 187 57 "9" */ CWORD_CWORD_CWORD_CWORD,
939 /* 188 58 ":" */ CWORD_CCTL_CCTL_CWORD,
940 /* 189 59 ";" */ CSPCL_CWORD_CWORD_CWORD,
941 /* 190 60 "<" */ CSPCL_CWORD_CWORD_CWORD,
942 /* 191 61 "=" */ CWORD_CCTL_CCTL_CWORD,
943 /* 192 62 ">" */ CSPCL_CWORD_CWORD_CWORD,
944 /* 193 63 "?" */ CWORD_CCTL_CCTL_CWORD,
945 /* 194 64 "@" */ CWORD_CWORD_CWORD_CWORD,
946 /* 195 65 "A" */ CWORD_CWORD_CWORD_CWORD,
947 /* 196 66 "B" */ CWORD_CWORD_CWORD_CWORD,
948 /* 197 67 "C" */ CWORD_CWORD_CWORD_CWORD,
949 /* 198 68 "D" */ CWORD_CWORD_CWORD_CWORD,
950 /* 199 69 "E" */ CWORD_CWORD_CWORD_CWORD,
951 /* 200 70 "F" */ CWORD_CWORD_CWORD_CWORD,
952 /* 201 71 "G" */ CWORD_CWORD_CWORD_CWORD,
953 /* 202 72 "H" */ CWORD_CWORD_CWORD_CWORD,
954 /* 203 73 "I" */ CWORD_CWORD_CWORD_CWORD,
955 /* 204 74 "J" */ CWORD_CWORD_CWORD_CWORD,
956 /* 205 75 "K" */ CWORD_CWORD_CWORD_CWORD,
957 /* 206 76 "L" */ CWORD_CWORD_CWORD_CWORD,
958 /* 207 77 "M" */ CWORD_CWORD_CWORD_CWORD,
959 /* 208 78 "N" */ CWORD_CWORD_CWORD_CWORD,
960 /* 209 79 "O" */ CWORD_CWORD_CWORD_CWORD,
961 /* 210 80 "P" */ CWORD_CWORD_CWORD_CWORD,
962 /* 211 81 "Q" */ CWORD_CWORD_CWORD_CWORD,
963 /* 212 82 "R" */ CWORD_CWORD_CWORD_CWORD,
964 /* 213 83 "S" */ CWORD_CWORD_CWORD_CWORD,
965 /* 214 84 "T" */ CWORD_CWORD_CWORD_CWORD,
966 /* 215 85 "U" */ CWORD_CWORD_CWORD_CWORD,
967 /* 216 86 "V" */ CWORD_CWORD_CWORD_CWORD,
968 /* 217 87 "W" */ CWORD_CWORD_CWORD_CWORD,
969 /* 218 88 "X" */ CWORD_CWORD_CWORD_CWORD,
970 /* 219 89 "Y" */ CWORD_CWORD_CWORD_CWORD,
971 /* 220 90 "Z" */ CWORD_CWORD_CWORD_CWORD,
972 /* 221 91 "[" */ CWORD_CCTL_CCTL_CWORD,
973 /* 222 92 "\" */ CBACK_CBACK_CCTL_CBACK,
974 /* 223 93 "]" */ CWORD_CCTL_CCTL_CWORD,
975 /* 224 94 "^" */ CWORD_CWORD_CWORD_CWORD,
976 /* 225 95 "_" */ CWORD_CWORD_CWORD_CWORD,
977 /* 226 96 "`" */ CBQUOTE_CBQUOTE_CWORD_CBQUOTE,
978 /* 227 97 "a" */ CWORD_CWORD_CWORD_CWORD,
979 /* 228 98 "b" */ CWORD_CWORD_CWORD_CWORD,
980 /* 229 99 "c" */ CWORD_CWORD_CWORD_CWORD,
981 /* 230 100 "d" */ CWORD_CWORD_CWORD_CWORD,
982 /* 231 101 "e" */ CWORD_CWORD_CWORD_CWORD,
983 /* 232 102 "f" */ CWORD_CWORD_CWORD_CWORD,
984 /* 233 103 "g" */ CWORD_CWORD_CWORD_CWORD,
985 /* 234 104 "h" */ CWORD_CWORD_CWORD_CWORD,
986 /* 235 105 "i" */ CWORD_CWORD_CWORD_CWORD,
987 /* 236 106 "j" */ CWORD_CWORD_CWORD_CWORD,
988 /* 237 107 "k" */ CWORD_CWORD_CWORD_CWORD,
989 /* 238 108 "l" */ CWORD_CWORD_CWORD_CWORD,
990 /* 239 109 "m" */ CWORD_CWORD_CWORD_CWORD,
991 /* 240 110 "n" */ CWORD_CWORD_CWORD_CWORD,
992 /* 241 111 "o" */ CWORD_CWORD_CWORD_CWORD,
993 /* 242 112 "p" */ CWORD_CWORD_CWORD_CWORD,
994 /* 243 113 "q" */ CWORD_CWORD_CWORD_CWORD,
995 /* 244 114 "r" */ CWORD_CWORD_CWORD_CWORD,
996 /* 245 115 "s" */ CWORD_CWORD_CWORD_CWORD,
997 /* 246 116 "t" */ CWORD_CWORD_CWORD_CWORD,
998 /* 247 117 "u" */ CWORD_CWORD_CWORD_CWORD,
999 /* 248 118 "v" */ CWORD_CWORD_CWORD_CWORD,
1000 /* 249 119 "w" */ CWORD_CWORD_CWORD_CWORD,
1001 /* 250 120 "x" */ CWORD_CWORD_CWORD_CWORD,
1002 /* 251 121 "y" */ CWORD_CWORD_CWORD_CWORD,
1003 /* 252 122 "z" */ CWORD_CWORD_CWORD_CWORD,
1004 /* 253 123 "{" */ CWORD_CWORD_CWORD_CWORD,
1005 /* 254 124 "|" */ CSPCL_CWORD_CWORD_CWORD,
1006 /* 255 125 "}" */ CENDVAR_CENDVAR_CWORD_CENDVAR,
1007 /* 256 126 "~" */ CWORD_CCTL_CCTL_CWORD,
1008 /* 257 127 */ CWORD_CWORD_CWORD_CWORD,
1011 #endif /* USE_SIT_FUNCTION */
1014 /* first char is indicating which tokens mark the end of a list */
1015 static const char *const tokname_array[] = {
1030 #define KWDOFFSET 14
1031 /* the following are keywords */
1050 static const char *tokname(int tok)
1052 static char buf[16];
1056 sprintf(buf + (tok >= TSEMI), "%s%c",
1057 tokname_array[tok] + 1, (tok >= TSEMI ? '"' : 0));
1061 static int plinno = 1; /* input line number */
1063 static int parselleft; /* copy of parsefile->lleft */
1065 static struct parsefile basepf; /* top level input file */
1066 static char basebuf[BUFSIZ]; /* buffer for top level input file */
1067 static struct parsefile *parsefile = &basepf; /* current input file */
1070 * NEOF is returned by parsecmd when it encounters an end of file. It
1071 * must be distinct from NULL, so we use the address of a variable that
1072 * happens to be handy.
1075 static int tokpushback; /* last token pushed back */
1077 #define NEOF ((union node *)&tokpushback)
1078 static int checkkwd; /* 1 == check for kwds, 2 == also eat newlines */
1081 static void error(const char *, ...) __attribute__ ((__noreturn__));
1082 static void exerror(int, const char *, ...) __attribute__ ((__noreturn__));
1083 static void shellexec(char **, char **, const char *, int)
1084 __attribute__ ((noreturn));
1085 static void exitshell(int) __attribute__ ((noreturn));
1087 static int goodname(const char *);
1088 static void ignoresig(int);
1089 static void onsig(int);
1090 static void dotrap(void);
1091 static int decode_signal(const char *, int);
1093 static void setparam(char **);
1094 static void freeparam(volatile struct shparam *);
1096 /* reasons for skipping commands (see comment on breakcmd routine) */
1102 /* values of cmdtype */
1103 #define CMDUNKNOWN -1 /* no entry in table for command */
1104 #define CMDNORMAL 0 /* command is an executable program */
1105 #define CMDBUILTIN 1 /* command is a shell builtin */
1106 #define CMDFUNCTION 2 /* command is a shell function */
1108 #define DO_ERR 1 /* find_command prints errors */
1109 #define DO_ABS 2 /* find_command checks absolute paths */
1110 #define DO_NOFUN 4 /* find_command ignores functions */
1111 #define DO_BRUTE 8 /* find_command ignores hash table */
1118 #define VEXPORT 0x01 /* variable is exported */
1119 #define VREADONLY 0x02 /* variable cannot be modified */
1120 #define VSTRFIXED 0x04 /* variable struct is staticly allocated */
1121 #define VTEXTFIXED 0x08 /* text is staticly allocated */
1122 #define VSTACK 0x10 /* text is allocated on the stack */
1123 #define VUNSET 0x20 /* the variable is not set */
1124 #define VNOFUNC 0x40 /* don't call the callback function */
1128 struct var *next; /* next entry in hash list */
1129 int flags; /* flags are defined above */
1130 char *text; /* name=value */
1131 void (*func) (const char *);
1132 /* function to be called when */
1133 /* the variable gets set/unset */
1137 struct localvar *next; /* next local variable in list */
1138 struct var *vp; /* the variable that was made local */
1139 int flags; /* saved flags */
1140 char *text; /* saved text */
1144 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
1145 #define rmescapes(p) _rmescapes((p), 0)
1146 static char *_rmescapes(char *, int);
1148 static void rmescapes(char *);
1151 static int casematch(union node *, const char *);
1152 static void clearredir(void);
1153 static void popstring(void);
1154 static void readcmdfile(const char *);
1156 static int number(const char *);
1157 static int is_number(const char *, int *num);
1158 static char *single_quote(const char *);
1159 static int nextopt(const char *);
1161 static void redirect(union node *, int);
1162 static void popredir(void);
1163 static int dup_as_newfd(int, int);
1165 static void changepath(const char *newval);
1166 static void getoptsreset(const char *value);
1169 static int parsenleft; /* copy of parsefile->nleft */
1170 static char *parsenextc; /* copy of parsefile->nextc */
1171 static int rootpid; /* pid of main shell */
1172 static int rootshell; /* true if we aren't a child of the main shell */
1174 static const char spcstr[] = " ";
1175 static const char snlfmt[] = "%s\n";
1177 static int sstrnleft;
1178 static int herefd = -1;
1180 static struct localvar *localvars;
1182 static struct var vifs;
1183 static struct var vmail;
1184 static struct var vmpath;
1185 static struct var vpath;
1186 static struct var vps1;
1187 static struct var vps2;
1188 static struct var voptind;
1190 #ifdef CONFIG_LOCALE_SUPPORT
1191 static struct var vlc_all;
1192 static struct var vlc_ctype;
1199 void (*func) (const char *);
1202 static const char defpathvar[] =
1203 "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
1204 #define defpath (defpathvar + 5)
1207 static const char defifsvar[] = "IFS= \t\n";
1209 #define defifs (defifsvar + 4)
1211 static const char defifs[] = " \t\n";
1214 static const struct varinit varinit[] = {
1216 {&vifs, VSTRFIXED | VTEXTFIXED, defifsvar,
1218 {&vifs, VSTRFIXED | VTEXTFIXED | VUNSET, "IFS=",
1221 {&vmail, VSTRFIXED | VTEXTFIXED | VUNSET, "MAIL=",
1223 {&vmpath, VSTRFIXED | VTEXTFIXED | VUNSET, "MAILPATH=",
1225 {&vpath, VSTRFIXED | VTEXTFIXED, defpathvar,
1227 #if defined(CONFIG_FEATURE_COMMAND_EDITING) && defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
1228 {&vps1, VSTRFIXED | VTEXTFIXED, "PS1=\\w \\$ ",
1230 #endif /* else vps1 depends on uid */
1231 {&vps2, VSTRFIXED | VTEXTFIXED, "PS2=> ",
1233 {&voptind, VSTRFIXED | VTEXTFIXED, "OPTIND=1",
1235 #ifdef CONFIG_LOCALE_SUPPORT
1236 {&vlc_all, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_ALL=",
1238 {&vlc_ctype, VSTRFIXED | VTEXTFIXED | VUNSET, "LC_CTYPE=",
1247 static struct var *vartab[VTABSIZE];
1250 * The following macros access the values of the above variables.
1251 * They have to skip over the name. They return the null string
1252 * for unset variables.
1255 #define ifsval() (vifs.text + 4)
1256 #define ifsset() ((vifs.flags & VUNSET) == 0)
1257 #define mailval() (vmail.text + 5)
1258 #define mpathval() (vmpath.text + 9)
1259 #define pathval() (vpath.text + 5)
1260 #define ps1val() (vps1.text + 4)
1261 #define ps2val() (vps2.text + 4)
1262 #define optindval() (voptind.text + 7)
1264 #define mpathset() ((vmpath.flags & VUNSET) == 0)
1266 static void initvar(void);
1267 static void setvar(const char *, const char *, int);
1268 static void setvareq(char *, int);
1269 static void listsetvar(struct strlist *);
1270 static const char *lookupvar(const char *);
1271 static const char *bltinlookup(const char *);
1272 static char **environment(void);
1273 static int showvarscmd(int, char **);
1274 static void mklocal(char *);
1275 static void poplocalvars(void);
1276 static int unsetvar(const char *);
1277 static int varequal(const char *, const char *);
1280 static char *arg0; /* value of $0 */
1281 static struct shparam shellparam; /* current positional parameters */
1282 static char **argptr; /* argument list for builtin commands */
1283 static char *optionarg; /* set by nextopt (like getopt) */
1284 static char *optptr; /* used by nextopt */
1285 static char *minusc; /* argument to -c option */
1288 #ifdef CONFIG_ASH_ALIAS
1290 #define ALIASINUSE 1
1302 static struct alias *atab[ATABSIZE];
1304 static void setalias(char *, char *);
1305 static struct alias **hashalias(const char *);
1306 static struct alias *freealias(struct alias *);
1307 static struct alias **__lookupalias(const char *);
1309 static void setalias(char *name, char *val)
1311 struct alias *ap, **app;
1313 app = __lookupalias(name);
1317 if (!(ap->flag & ALIASINUSE)) {
1320 ap->val = xstrdup(val);
1321 ap->flag &= ~ALIASDEAD;
1324 ap = xmalloc(sizeof(struct alias));
1325 ap->name = xstrdup(name);
1326 ap->val = xstrdup(val);
1334 static int unalias(char *name)
1338 app = __lookupalias(name);
1342 *app = freealias(*app);
1350 static void rmaliases(void)
1352 struct alias *ap, **app;
1356 for (i = 0; i < ATABSIZE; i++) {
1358 for (ap = *app; ap; ap = *app) {
1359 *app = freealias(*app);
1368 static void printalias(const struct alias *ap)
1372 p = single_quote(ap->val);
1373 printf("alias %s=%s\n", ap->name, p);
1379 * TODO - sort output
1381 static int aliascmd(int argc, char **argv)
1390 for (i = 0; i < ATABSIZE; i++)
1391 for (ap = atab[i]; ap; ap = ap->next) {
1396 while ((n = *++argv) != NULL) {
1397 if ((v = strchr(n + 1, '=')) == NULL) { /* n+1: funny ksh stuff */
1398 if ((ap = *__lookupalias(n)) == NULL) {
1399 out2fmt("%s: %s not found\n", "alias", n);
1412 static int unaliascmd(int argc, char **argv)
1416 while ((i = nextopt("a")) != '\0') {
1422 for (i = 0; *argptr; argptr++) {
1423 if (unalias(*argptr)) {
1424 out2fmt("%s: %s not found\n", "unalias", *argptr);
1432 static struct alias **hashalias(const char *p)
1434 unsigned int hashval;
1439 return &atab[hashval % ATABSIZE];
1442 static struct alias *freealias(struct alias *ap)
1446 if (ap->flag & ALIASINUSE) {
1447 ap->flag |= ALIASDEAD;
1459 static struct alias **__lookupalias(const char *name)
1461 struct alias **app = hashalias(name);
1463 for (; *app; app = &(*app)->next) {
1464 if (equal(name, (*app)->name)) {
1473 #ifdef CONFIG_ASH_MATH_SUPPORT
1474 /* The generated file arith.c has been replaced with a custom hand
1475 * written implementation written by Aaron Lehmann <aaronl@vitelus.com>.
1476 * This is now part of libbb, so that it can be used by all the shells
1478 static void expari(int);
1481 static char *trap[NSIG]; /* trap handler commands */
1482 static char sigmode[NSIG - 1]; /* current value of signal */
1483 static char gotsig[NSIG - 1]; /* indicates specified signal received */
1484 static int pendingsigs; /* indicates some signal received */
1487 * This file was generated by the mkbuiltins program.
1490 #ifdef CONFIG_ASH_JOB_CONTROL
1491 static int bgcmd(int, char **);
1492 static int fgcmd(int, char **);
1493 static int killcmd(int, char **);
1495 static int bltincmd(int, char **);
1496 static int cdcmd(int, char **);
1497 static int breakcmd(int, char **);
1499 #ifdef CONFIG_ASH_CMDCMD
1500 static int commandcmd(int, char **);
1502 static int dotcmd(int, char **);
1503 static int evalcmd(int, char **);
1504 static int execcmd(int, char **);
1505 static int exitcmd(int, char **);
1506 static int exportcmd(int, char **);
1507 static int histcmd(int, char **);
1508 static int hashcmd(int, char **);
1509 static int helpcmd(int, char **);
1510 static int jobscmd(int, char **);
1511 static int localcmd(int, char **);
1512 static int pwdcmd(int, char **);
1513 static int readcmd(int, char **);
1514 static int returncmd(int, char **);
1515 static int setcmd(int, char **);
1516 static int setvarcmd(int, char **);
1517 static int shiftcmd(int, char **);
1518 static int trapcmd(int, char **);
1519 static int umaskcmd(int, char **);
1521 #ifdef CONFIG_ASH_ALIAS
1522 static int aliascmd(int, char **);
1523 static int unaliascmd(int, char **);
1525 static int unsetcmd(int, char **);
1526 static int waitcmd(int, char **);
1527 static int ulimitcmd(int, char **);
1528 static int timescmd(int, char **);
1530 #ifdef CONFIG_ASH_MATH_SUPPORT
1531 static int letcmd(int, char **);
1533 static int typecmd(int, char **);
1535 #ifdef CONFIG_ASH_GETOPTS
1536 static int getoptscmd(int, char **);
1540 static int true_main(int, char **);
1542 #ifndef CONFIG_FALSE
1543 static int false_main(int, char **);
1546 static void setpwd(const char *, int);
1549 #define BUILTIN_NOSPEC "0"
1550 #define BUILTIN_SPECIAL "1"
1551 #define BUILTIN_REGULAR "2"
1552 #define BUILTIN_ASSIGN "4"
1553 #define BUILTIN_SPEC_ASSG "5"
1554 #define BUILTIN_REG_ASSG "6"
1556 #define IS_BUILTIN_SPECIAL(builtincmd) ((builtincmd)->name[0] & 1)
1557 #define IS_BUILTIN_REGULAR(builtincmd) ((builtincmd)->name[0] & 2)
1558 #define IS_BUILTIN_ASSIGN(builtincmd) ((builtincmd)->name[0] & 4)
1562 int (*const builtinfunc) (int, char **);
1567 /* It is CRUCIAL that this listing be kept in ascii order, otherwise
1568 * the binary search in find_builtin() will stop working. If you value
1569 * your kneecaps, you'll be sure to *make sure* that any changes made
1570 * to this array result in the listing remaining in ascii order. You
1573 static const struct builtincmd builtincmds[] = {
1574 {BUILTIN_SPECIAL ".", dotcmd}, /* first, see declare DOTCMD */
1575 {BUILTIN_SPECIAL ":", true_main},
1576 #ifdef CONFIG_ASH_ALIAS
1577 {BUILTIN_REG_ASSG "alias", aliascmd},
1579 #ifdef CONFIG_ASH_JOB_CONTROL
1580 {BUILTIN_REGULAR "bg", bgcmd},
1582 {BUILTIN_SPECIAL "break", breakcmd},
1583 {BUILTIN_SPECIAL "builtin", bltincmd},
1584 {BUILTIN_REGULAR "cd", cdcmd},
1585 {BUILTIN_NOSPEC "chdir", cdcmd},
1586 #ifdef CONFIG_ASH_CMDCMD
1587 {BUILTIN_REGULAR "command", commandcmd},
1589 {BUILTIN_SPECIAL "continue", breakcmd},
1590 {BUILTIN_SPECIAL "eval", evalcmd},
1591 {BUILTIN_SPECIAL "exec", execcmd},
1592 {BUILTIN_SPECIAL "exit", exitcmd},
1593 {BUILTIN_SPEC_ASSG "export", exportcmd},
1594 {BUILTIN_REGULAR "false", false_main},
1595 {BUILTIN_REGULAR "fc", histcmd},
1596 #ifdef CONFIG_ASH_JOB_CONTROL
1597 {BUILTIN_REGULAR "fg", fgcmd},
1599 #ifdef CONFIG_ASH_GETOPTS
1600 {BUILTIN_REGULAR "getopts", getoptscmd},
1602 {BUILTIN_NOSPEC "hash", hashcmd},
1603 {BUILTIN_NOSPEC "help", helpcmd},
1604 {BUILTIN_REGULAR "jobs", jobscmd},
1605 #ifdef CONFIG_ASH_JOB_CONTROL
1606 {BUILTIN_REGULAR "kill", killcmd},
1608 #ifdef CONFIG_ASH_MATH_SUPPORT
1609 {BUILTIN_REGULAR "let", letcmd},
1611 {BUILTIN_ASSIGN "local", localcmd},
1612 {BUILTIN_NOSPEC "pwd", pwdcmd},
1613 {BUILTIN_REGULAR "read", readcmd},
1614 {BUILTIN_SPEC_ASSG "readonly", exportcmd},
1615 {BUILTIN_SPECIAL "return", returncmd},
1616 {BUILTIN_SPECIAL "set", setcmd},
1617 {BUILTIN_NOSPEC "setvar", setvarcmd},
1618 {BUILTIN_SPECIAL "shift", shiftcmd},
1619 {BUILTIN_SPECIAL "times", timescmd},
1620 {BUILTIN_SPECIAL "trap", trapcmd},
1621 {BUILTIN_REGULAR "true", true_main},
1622 {BUILTIN_NOSPEC "type", typecmd},
1623 {BUILTIN_NOSPEC "ulimit", ulimitcmd},
1624 {BUILTIN_REGULAR "umask", umaskcmd},
1625 #ifdef CONFIG_ASH_ALIAS
1626 {BUILTIN_REGULAR "unalias", unaliascmd},
1628 {BUILTIN_SPECIAL "unset", unsetcmd},
1629 {BUILTIN_REGULAR "wait", waitcmd},
1632 #define NUMBUILTINS (sizeof (builtincmds) / sizeof (struct builtincmd) )
1634 #define DOTCMD &builtincmds[0]
1635 static struct builtincmd *BLTINCMD;
1636 static struct builtincmd *EXECCMD;
1637 static struct builtincmd *EVALCMD;
1640 #define JOBSTOPPED 1 /* all procs are stopped */
1641 #define JOBDONE 2 /* all procs are completed */
1644 * A job structure contains information about a job. A job is either a
1645 * single process or a set of processes contained in a pipeline. In the
1646 * latter case, pidlist will be non-NULL, and will point to a -1 terminated
1651 pid_t pid; /* process id */
1652 int status; /* status flags (defined above) */
1653 char *cmd; /* text of command being run */
1657 static int job_warning; /* user was warned about stopped jobs */
1659 #ifdef CONFIG_ASH_JOB_CONTROL
1660 static void setjobctl(int enable);
1662 #define setjobctl(on) /* do nothing */
1667 struct procstat ps0; /* status of process */
1668 struct procstat *ps; /* status or processes when more than one */
1669 short nprocs; /* number of processes */
1670 short pgrp; /* process group of this job */
1671 char state; /* true if job is finished */
1672 char used; /* true if this entry is in used */
1673 char changed; /* true if status has changed */
1674 #ifdef CONFIG_ASH_JOB_CONTROL
1675 char jobctl; /* job running under job control */
1679 static struct job *jobtab; /* array of jobs */
1680 static int njobs; /* size of array */
1681 static int backgndpid = -1; /* pid of last background process */
1683 #ifdef CONFIG_ASH_JOB_CONTROL
1684 static int initialpgrp; /* pgrp of shell on invocation */
1685 static int curjob; /* current job */
1689 static struct job *makejob(const union node *, int);
1690 static int forkshell(struct job *, const union node *, int);
1691 static int waitforjob(struct job *);
1693 static int docd(char *, int);
1694 static void getpwd(void);
1696 static char *padvance(const char **, const char *);
1698 static char nullstr[1]; /* zero length string */
1699 static char *curdir = nullstr; /* current working directory */
1701 static int cdcmd(int argc, char **argv)
1710 if ((dest = *argptr) == NULL && (dest = bltinlookup("HOME")) == NULL)
1711 error("HOME not set");
1714 if (dest[0] == '-' && dest[1] == '\0') {
1715 dest = bltinlookup("OLDPWD");
1716 if (!dest || !*dest) {
1725 if (*dest == '/' || (path = bltinlookup("CDPATH")) == NULL)
1727 while ((p = padvance(&path, dest)) != NULL) {
1728 if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) {
1733 if (p[0] == '.' && p[1] == '/' && p[2] != '\0')
1735 print = strcmp(p, dest);
1737 if (docd(p, print) >= 0)
1742 error("can't cd to %s", dest);
1748 * Update curdir (the name of the current directory) in response to a
1749 * cd command. We also call hashcd to let the routines in exec.c know
1750 * that the current directory has changed.
1753 static void hashcd(void);
1755 static inline void updatepwd(const char *dir)
1757 hashcd(); /* update command hash table */
1760 * If our argument is NULL, we don't know the current directory
1762 if (dir == NULL || curdir == nullstr) {
1770 * Actually do the chdir. In an interactive shell, print the
1771 * directory name if "print" is nonzero.
1774 static int docd(char *dest, int print)
1776 TRACE(("docd(\"%s\", %d) called\n", dest, print));
1778 if (chdir(dest) < 0) {
1790 static int pwdcmd(int argc, char **argv)
1796 /* Ask system the current directory */
1797 static void getpwd(void)
1799 curdir = xgetcwd(0);
1804 static void setpwd(const char *val, int setold)
1809 setvar("OLDPWD", curdir, VEXPORT);
1812 if (curdir != nullstr) {
1813 if (val != NULL && *val != '/')
1814 val = cated = concat_path_file(curdir, val);
1820 curdir = simplify_path(val);
1823 setvar("PWD", curdir, VEXPORT);
1827 * Errors and exceptions.
1831 * Code to handle exceptions in C.
1835 * We enclose jmp_buf in a structure so that we can declare pointers to
1836 * jump locations. The global variable handler contains the location to
1837 * jump to when an exception occurs, and the global variable exception
1838 * contains a code identifying the exeception. To implement nested
1839 * exception handlers, the user should save the value of handler on entry
1840 * to an inner scope, set handler to point to a jmploc structure for the
1841 * inner scope, and restore handler on exit from the scope.
1849 #define EXINT 0 /* SIGINT received */
1850 #define EXERROR 1 /* a generic error */
1851 #define EXSHELLPROC 2 /* execute a shell procedure */
1852 #define EXEXEC 3 /* command execution failed */
1853 #define EXREDIR 4 /* redirection error */
1855 static struct jmploc *handler;
1856 static int exception;
1858 static void exverror(int, const char *, va_list)
1859 __attribute__ ((__noreturn__));
1862 * Called to raise an exception. Since C doesn't include exceptions, we
1863 * just do a longjmp to the exception handler. The type of exception is
1864 * stored in the global variable "exception".
1867 static void exraise(int) __attribute__ ((__noreturn__));
1869 static void exraise(int e)
1872 if (handler == NULL)
1877 longjmp(handler->loc, 1);
1882 * Called from trap.c when a SIGINT is received. (If the user specifies
1883 * that SIGINT is to be trapped or ignored using the trap builtin, then
1884 * this routine is not called.) Suppressint is nonzero when interrupts
1885 * are held using the INTOFF macro. The call to _exit is necessary because
1886 * there is a short period after a fork before the signal handlers are
1887 * set to the appropriate value for the child. (The test for iflag is
1888 * just defensive programming.)
1891 static void onint(void)
1900 sigemptyset(&mysigset);
1901 sigprocmask(SIG_SETMASK, &mysigset, NULL);
1902 if (!(rootshell && iflag)) {
1903 signal(SIGINT, SIG_DFL);
1911 static char *commandname; /* currently executing command */
1914 * Exverror is called to raise the error exception. If the first argument
1915 * is not NULL then error prints an error message using printf style
1916 * formatting. It then raises the error exception.
1918 static void exverror(int cond, const char *msg, va_list ap)
1925 TRACE(("exverror(%d, \"%s\") pid=%d\n", cond, msg, getpid()));
1927 TRACE(("exverror(%d, NULL) pid=%d\n", cond, getpid()));
1931 out2fmt("%s: ", commandname);
1932 vfprintf(stderr, msg, ap);
1940 static void error(const char *msg, ...)
1945 exverror(EXERROR, msg, ap);
1951 static void exerror(int cond, const char *msg, ...)
1956 exverror(cond, msg, ap);
1964 * Table of error messages.
1968 short errcode; /* error number */
1969 short action; /* operation which encountered the error */
1973 * Types of operations (passed to the errmsg routine).
1976 #define E_OPEN 01 /* opening a file */
1977 #define E_CREAT 02 /* creating a file */
1978 #define E_EXEC 04 /* executing a program */
1980 #define ALL (E_OPEN|E_CREAT|E_EXEC)
1982 static const struct errname errormsg[] = {
2036 #define ERRNAME_SIZE (sizeof(errormsg)/sizeof(struct errname))
2039 * Return a string describing an error. The returned string may be a
2040 * pointer to a static buffer that will be overwritten on the next call.
2041 * Action describes the operation that got the error.
2044 static const char *errmsg(int e, int action)
2046 struct errname const *ep;
2047 static char buf[12];
2049 for (ep = errormsg; ep < errormsg + ERRNAME_SIZE; ep++) {
2050 if (ep->errcode == e && (ep->action & action) != 0)
2054 snprintf(buf, sizeof buf, "error %d", e);
2059 #ifdef CONFIG_ASH_OPTIMIZE_FOR_SIZE
2060 static void __inton()
2062 if (--suppressint == 0 && intpending) {
2066 static void forceinton(void)
2074 /* flags in argument to evaltree */
2075 #define EV_EXIT 01 /* exit after evaluating tree */
2076 #define EV_TESTED 02 /* exit status is checked; ignore -e flag */
2077 #define EV_BACKCMD 04 /* command executing within back quotes */
2079 static int evalskip; /* set if we are skipping commands */
2080 static int skipcount; /* number of levels to skip */
2081 static int loopnest; /* current loop nesting level */
2082 static int funcnest; /* depth of function calls */
2085 static struct strlist *cmdenviron; /* environment for builtin command */
2086 static int exitstatus; /* exit status of last command */
2087 static int oexitstatus; /* saved exit status */
2089 static void evalsubshell(const union node *, int);
2090 static void expredir(union node *);
2091 static void prehash(union node *);
2092 static void eprintlist(struct strlist *);
2094 static union node *parsecmd(int);
2097 * Called to reset things after an exception.
2101 * The eval commmand.
2103 static void evalstring(char *, int);
2105 static int evalcmd(int argc, char **argv)
2114 STARTSTACKSTR(concat);
2118 STPUTC(*p++, concat);
2119 if ((p = *ap++) == NULL)
2121 STPUTC(' ', concat);
2123 STPUTC('\0', concat);
2124 p = grabstackstr(concat);
2126 evalstring(p, EV_TESTED);
2132 * Execute a command or commands contained in a string.
2135 static void evaltree(union node *, int);
2136 static void setinputstring(char *);
2137 static void popfile(void);
2138 static void setstackmark(struct stackmark *mark);
2139 static void popstackmark(struct stackmark *mark);
2142 static void evalstring(char *s, int flag)
2145 struct stackmark smark;
2147 setstackmark(&smark);
2149 while ((n = parsecmd(0)) != NEOF) {
2151 popstackmark(&smark);
2154 popstackmark(&smark);
2157 static struct builtincmd *find_builtin(const char *);
2158 static void expandarg(union node *, struct arglist *, int);
2159 static void calcsize(const union node *);
2160 static union node *copynode(const union node *);
2163 * Make a copy of a parse tree.
2166 static int funcblocksize; /* size of structures in function */
2167 static int funcstringsize; /* size of strings in node */
2168 static pointer funcblock; /* block to allocate function from */
2169 static char *funcstring; /* block to allocate strings from */
2172 static inline union node *copyfunc(union node *n)
2179 funcblock = xmalloc(funcblocksize + funcstringsize);
2180 funcstring = (char *) funcblock + funcblocksize;
2185 * Add a new command entry, replacing any existing command entry for
2189 static inline void addcmdentry(char *name, struct cmdentry *entry)
2191 struct tblentry *cmdp;
2194 cmdp = cmdlookup(name, 1);
2195 if (cmdp->cmdtype == CMDFUNCTION) {
2196 free(cmdp->param.func);
2198 cmdp->cmdtype = entry->cmdtype;
2199 cmdp->param = entry->u;
2203 static inline void evalloop(const union node *n, int flags)
2211 evaltree(n->nbinary.ch1, EV_TESTED);
2213 skipping:if (evalskip == SKIPCONT && --skipcount <= 0) {
2217 if (evalskip == SKIPBREAK && --skipcount <= 0)
2221 if (n->type == NWHILE) {
2222 if (exitstatus != 0)
2225 if (exitstatus == 0)
2228 evaltree(n->nbinary.ch2, flags);
2229 status = exitstatus;
2234 exitstatus = status;
2237 static void evalfor(const union node *n, int flags)
2239 struct arglist arglist;
2242 struct stackmark smark;
2244 setstackmark(&smark);
2245 arglist.lastp = &arglist.list;
2246 for (argp = n->nfor.args; argp; argp = argp->narg.next) {
2247 oexitstatus = exitstatus;
2248 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE | EXP_RECORD);
2252 *arglist.lastp = NULL;
2257 for (sp = arglist.list; sp; sp = sp->next) {
2258 setvar(n->nfor.var, sp->text, 0);
2259 evaltree(n->nfor.body, flags);
2261 if (evalskip == SKIPCONT && --skipcount <= 0) {
2265 if (evalskip == SKIPBREAK && --skipcount <= 0)
2272 popstackmark(&smark);
2275 static inline void evalcase(const union node *n, int flags)
2279 struct arglist arglist;
2280 struct stackmark smark;
2282 setstackmark(&smark);
2283 arglist.lastp = &arglist.list;
2284 oexitstatus = exitstatus;
2285 expandarg(n->ncase.expr, &arglist, EXP_TILDE);
2286 for (cp = n->ncase.cases; cp && evalskip == 0; cp = cp->nclist.next) {
2287 for (patp = cp->nclist.pattern; patp; patp = patp->narg.next) {
2288 if (casematch(patp, arglist.list->text)) {
2289 if (evalskip == 0) {
2290 evaltree(cp->nclist.body, flags);
2297 popstackmark(&smark);
2301 * Evaluate a pipeline. All the processes in the pipeline are children
2302 * of the process creating the pipeline. (This differs from some versions
2303 * of the shell, which make the last process in a pipeline the parent
2307 static inline void evalpipe(union node *n, int flags)
2310 struct nodelist *lp;
2315 TRACE(("evalpipe(0x%lx) called\n", (long) n));
2317 for (lp = n->npipe.cmdlist; lp; lp = lp->next)
2321 jp = makejob(n, pipelen);
2323 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
2327 if (pipe(pip) < 0) {
2329 error("Pipe call failed");
2332 if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) {
2345 evaltree(lp->n, flags);
2352 if (n->npipe.backgnd == 0) {
2353 exitstatus = waitforjob(jp);
2354 TRACE(("evalpipe: job done exit status %d\n", exitstatus));
2359 static void find_command(const char *, struct cmdentry *, int, const char *);
2361 static int isassignment(const char *word)
2363 if (!is_name(*word)) {
2368 } while (is_in_name(*word));
2369 return *word == '=';
2373 static void evalcommand(union node *cmd, int flags)
2375 struct stackmark smark;
2377 struct arglist arglist;
2378 struct arglist varlist;
2384 struct cmdentry cmdentry;
2386 char *volatile savecmdname;
2387 volatile struct shparam saveparam;
2388 struct localvar *volatile savelocalvars;
2393 struct jmploc *volatile savehandler;
2394 struct jmploc jmploc;
2397 /* Avoid longjmp clobbering */
2405 /* First expand the arguments. */
2406 TRACE(("evalcommand(0x%lx, %d) called\n", (long) cmd, flags));
2407 setstackmark(&smark);
2408 arglist.lastp = &arglist.list;
2409 varlist.lastp = &varlist.list;
2411 oexitstatus = exitstatus;
2414 for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
2415 expandarg(argp, &varlist, EXP_VARTILDE);
2417 for (argp = cmd->ncmd.args; argp; argp = argp->narg.next) {
2418 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
2420 *arglist.lastp = NULL;
2421 *varlist.lastp = NULL;
2422 expredir(cmd->ncmd.redirect);
2424 for (sp = arglist.list; sp; sp = sp->next)
2426 argv = stalloc(sizeof(char *) * (argc + 1));
2428 for (sp = arglist.list; sp; sp = sp->next) {
2429 TRACE(("evalcommand arg: %s\n", sp->text));
2434 if (iflag && funcnest == 0 && argc > 0)
2438 /* Print the command if xflag is set. */
2441 eprintlist(varlist.list);
2442 eprintlist(arglist.list);
2446 /* Now locate the command. */
2448 cmdentry.cmdtype = CMDBUILTIN;
2449 cmdentry.u.cmd = BLTINCMD;
2452 const char *oldpath;
2453 int findflag = DO_ERR;
2457 * Modify the command lookup path, if a PATH= assignment
2460 for (sp = varlist.list; sp; sp = sp->next)
2461 if (varequal(sp->text, defpathvar)) {
2462 path = sp->text + 5;
2463 findflag |= DO_BRUTE;
2466 oldfindflag = findflag;
2469 find_command(argv[0], &cmdentry, findflag, path);
2470 if (cmdentry.cmdtype == CMDUNKNOWN) { /* command not found */
2474 /* implement bltin and command here */
2475 if (cmdentry.cmdtype != CMDBUILTIN) {
2478 if (spclbltin < 0) {
2479 spclbltin = !!(IS_BUILTIN_SPECIAL(cmdentry.u.cmd)) * 2;
2481 if (cmdentry.u.cmd == BLTINCMD) {
2483 struct builtincmd *bcmd;
2488 if (!(bcmd = find_builtin(*argv))) {
2489 out2fmt("%s: not found\n", *argv);
2493 cmdentry.u.cmd = bcmd;
2494 if (bcmd != BLTINCMD)
2498 if (cmdentry.u.cmd == find_builtin("command")) {
2503 if (*argv[0] == '-') {
2504 if (!equal(argv[0], "-p")) {
2514 findflag |= DO_BRUTE;
2517 findflag = oldfindflag;
2519 findflag |= DO_NOFUN;
2527 /* Fork off a child process if necessary. */
2528 if (cmd->ncmd.backgnd
2529 || (cmdentry.cmdtype == CMDNORMAL && (!(flags & EV_EXIT) || trap[0]))
2532 jp = makejob(cmd, 1);
2533 mode = cmd->ncmd.backgnd;
2534 if (forkshell(jp, cmd, mode) != 0)
2535 goto parent; /* at end of routine */
2542 /* This is the child process if a fork occurred. */
2543 /* Execute the command. */
2544 if (cmdentry.cmdtype == CMDFUNCTION) {
2546 trputs("Shell function: ");
2549 exitstatus = oexitstatus;
2550 saveparam = shellparam;
2551 shellparam.malloc = 0;
2552 shellparam.nparam = argc - 1;
2553 shellparam.p = argv + 1;
2555 savelocalvars = localvars;
2558 if (setjmp(jmploc.loc)) {
2559 if (exception == EXREDIR) {
2563 saveparam.optind = shellparam.optind;
2564 saveparam.optoff = shellparam.optoff;
2565 freeparam(&shellparam);
2566 shellparam = saveparam;
2568 localvars = savelocalvars;
2569 handler = savehandler;
2570 longjmp(handler->loc, 1);
2572 savehandler = handler;
2574 redirect(cmd->ncmd.redirect, REDIR_PUSH);
2575 listsetvar(varlist.list);
2577 evaltree(cmdentry.u.func, flags & EV_TESTED);
2582 localvars = savelocalvars;
2583 saveparam.optind = shellparam.optind;
2584 saveparam.optoff = shellparam.optoff;
2585 freeparam(&shellparam);
2586 shellparam = saveparam;
2587 handler = savehandler;
2590 if (evalskip == SKIPFUNC) {
2594 } else if (cmdentry.cmdtype == CMDBUILTIN) {
2598 trputs("builtin command: ");
2601 redir = (cmdentry.u.cmd == EXECCMD) ? 0 : REDIR_PUSH;
2602 savecmdname = commandname;
2604 listsetvar(varlist.list);
2606 cmdenviron = varlist.list;
2609 if (setjmp(jmploc.loc)) {
2611 exitstatus = (e == EXINT) ? SIGINT + 128 : 2;
2614 savehandler = handler;
2616 redirect(cmd->ncmd.redirect, redir);
2617 commandname = argv[0];
2619 optptr = NULL; /* initialize nextopt */
2620 exitstatus = (*cmdentry.u.cmd->builtinfunc) (argc, argv);
2624 commandname = savecmdname;
2625 handler = savehandler;
2627 if (e == EXINT || spclbltin & 2) {
2633 if (cmdentry.u.cmd != EXECCMD)
2637 trputs("normal command: ");
2640 redirect(cmd->ncmd.redirect, 0);
2642 for (sp = varlist.list; sp; sp = sp->next)
2643 setvareq(sp->text, VEXPORT | VSTACK);
2644 envp = environment();
2645 shellexec(argv, envp, path, cmdentry.u.index);
2647 if (flags & EV_EXIT)
2648 exitshell(exitstatus);
2651 parent: /* parent process gets here (if we forked) */
2652 if (mode == 0) { /* argument to fork */
2653 exitstatus = waitforjob(jp);
2659 setvar("_", lastarg, 0);
2660 popstackmark(&smark);
2664 * Evaluate a parse tree. The value is left in the global variable
2667 static void evaltree(union node *n, int flags)
2672 TRACE(("evaltree(NULL) called\n"));
2675 TRACE(("evaltree(0x%lx: %d) called\n", (long) n, n->type));
2678 evaltree(n->nbinary.ch1, flags & EV_TESTED);
2681 evaltree(n->nbinary.ch2, flags);
2684 evaltree(n->nbinary.ch1, EV_TESTED);
2685 if (evalskip || exitstatus != 0)
2687 evaltree(n->nbinary.ch2, flags);
2690 evaltree(n->nbinary.ch1, EV_TESTED);
2691 if (evalskip || exitstatus == 0)
2693 evaltree(n->nbinary.ch2, flags);
2696 expredir(n->nredir.redirect);
2697 redirect(n->nredir.redirect, REDIR_PUSH);
2698 evaltree(n->nredir.n, flags);
2702 evalsubshell(n, flags);
2705 evalsubshell(n, flags);
2708 evaltree(n->nif.test, EV_TESTED);
2711 if (exitstatus == 0)
2712 evaltree(n->nif.ifpart, flags);
2713 else if (n->nif.elsepart)
2714 evaltree(n->nif.elsepart, flags);
2730 struct builtincmd *bcmd;
2731 struct cmdentry entry;
2733 if ((bcmd = find_builtin(n->narg.text)) && IS_BUILTIN_SPECIAL(bcmd)
2735 out2fmt("%s is a special built-in\n", n->narg.text);
2739 entry.cmdtype = CMDFUNCTION;
2740 entry.u.func = copyfunc(n->narg.next);
2741 addcmdentry(n->narg.text, &entry);
2746 evaltree(n->nnot.com, EV_TESTED);
2747 exitstatus = !exitstatus;
2755 evalcommand(n, flags);
2760 printf("Node type = %d\n", n->type);
2767 if (flags & EV_EXIT ||
2768 (checkexit && eflag && exitstatus && !(flags & EV_TESTED))
2770 exitshell(exitstatus);
2774 * Kick off a subshell to evaluate a tree.
2777 static void evalsubshell(const union node *n, int flags)
2780 int backgnd = (n->type == NBACKGND);
2782 expredir(n->nredir.redirect);
2783 if (!backgnd && flags & EV_EXIT && !trap[0])
2787 if (forkshell(jp, n, backgnd) == 0) {
2791 flags &= ~EV_TESTED;
2793 redirect(n->nredir.redirect, 0);
2794 evaltree(n->nredir.n, flags); /* never returns */
2797 exitstatus = waitforjob(jp);
2803 * Compute the names of the files in a redirection list.
2806 static void fixredir(union node *n, const char *text, int err);
2808 static void expredir(union node *n)
2812 for (redir = n; redir; redir = redir->nfile.next) {
2815 fn.lastp = &fn.list;
2816 oexitstatus = exitstatus;
2817 switch (redir->type) {
2823 expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
2824 redir->nfile.expfname = fn.list->text;
2828 if (redir->ndup.vname) {
2829 expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE);
2830 fixredir(redir, fn.list->text, 1);
2839 * Execute a command inside back quotes. If it's a builtin command, we
2840 * want to save its output in a block obtained from malloc. Otherwise
2841 * we fork off a subprocess and get the output of the command via a pipe.
2842 * Should be called with interrupts off.
2845 static void evalbackcmd(union node *n, struct backcmd *result)
2849 struct stackmark smark; /* unnecessary */
2851 setstackmark(&smark);
2862 error("Pipe call failed");
2864 if (forkshell(jp, n, FORK_NOJOB) == 0) {
2869 dup_as_newfd(pip[1], 1);
2873 evaltree(n, EV_EXIT);
2876 result->fd = pip[0];
2879 popstackmark(&smark);
2880 TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
2881 result->fd, result->buf, result->nleft, result->jp));
2886 * Execute a simple command.
2890 * Search for a command. This is called before we fork so that the
2891 * location of the command will be available in the parent as well as
2892 * the child. The check for "goodname" is an overly conservative
2893 * check that the name will not be subject to expansion.
2896 static void prehash(union node *n)
2898 struct cmdentry entry;
2900 if (n->type == NCMD && n->ncmd.args)
2901 if (goodname(n->ncmd.args->narg.text))
2902 find_command(n->ncmd.args->narg.text, &entry, 0, pathval());
2907 * Builtin commands. Builtin commands whose functions are closely
2908 * tied to evaluation are implemented here.
2912 * No command given, or a bltin command with no arguments. Set the
2913 * specified variables.
2916 int bltincmd(int argc, char **argv)
2919 * Preserve exitstatus of a previous possible redirection
2927 * Handle break and continue commands. Break, continue, and return are
2928 * all handled by setting the evalskip flag. The evaluation routines
2929 * above all check this flag, and if it is set they start skipping
2930 * commands rather than executing them. The variable skipcount is
2931 * the number of loops to break/continue, or the number of function
2932 * levels to return. (The latter is always 1.) It should probably
2933 * be an error to break out of more loops than exist, but it isn't
2934 * in the standard shell so we don't make it one here.
2937 static int breakcmd(int argc, char **argv)
2939 int n = argc > 1 ? number(argv[1]) : 1;
2942 error("Illegal number: %s", argv[1]);
2946 evalskip = (**argv == 'c') ? SKIPCONT : SKIPBREAK;
2954 * The return command.
2957 static int returncmd(int argc, char **argv)
2959 int ret = argc > 1 ? number(argv[1]) : oexitstatus;
2962 evalskip = SKIPFUNC;
2966 /* Do what ksh does; skip the rest of the file */
2967 evalskip = SKIPFILE;
2974 #ifndef CONFIG_FALSE
2975 static int false_main(int argc, char **argv)
2982 static int true_main(int argc, char **argv)
2989 * Controls whether the shell is interactive or not.
2992 static void setsignal(int signo);
2994 #ifdef CONFIG_ASH_MAIL
2995 static void chkmail(int silent);
2998 static void setinteractive(int on)
3000 static int is_interactive;
3001 static int do_banner = 0;
3003 if (on == is_interactive)
3008 #ifdef CONFIG_ASH_MAIL
3011 is_interactive = on;
3012 if (do_banner == 0 && is_interactive) {
3013 /* Looks like they want an interactive shell */
3014 #ifndef CONFIG_FEATURE_SH_EXTRA_QUIET
3015 printf("\n\n" BB_BANNER " Built-in shell (ash)\n");
3016 printf("Enter 'help' for a list of built-in commands.\n\n");
3022 static void optschanged(void)
3024 setinteractive(iflag);
3029 static int execcmd(int argc, char **argv)
3034 iflag = 0; /* exit on error */
3037 for (sp = cmdenviron; sp; sp = sp->next)
3038 setvareq(sp->text, VEXPORT | VSTACK);
3039 shellexec(argv + 1, environment(), pathval(), 0);
3044 static void eprintlist(struct strlist *sp)
3046 for (; sp; sp = sp->next) {
3047 out2fmt(" %s", sp->text);
3052 * Exec a program. Never returns. If you change this routine, you may
3053 * have to change the find_command routine as well.
3056 static const char *pathopt; /* set by padvance */
3058 static void shellexec(char **argv, char **envp, const char *path, int idx)
3063 if (strchr(argv[0], '/') != NULL) {
3064 tryexec(argv[0], argv, envp);
3068 while ((cmdname = padvance(&path, argv[0])) != NULL) {
3069 if (--idx < 0 && pathopt == NULL) {
3070 tryexec(cmdname, argv, envp);
3071 if (errno != ENOENT && errno != ENOTDIR)
3078 /* Map to POSIX errors */
3090 exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC));
3095 * Clear traps on a fork.
3097 static void clear_traps(void)
3101 for (tp = trap; tp < &trap[NSIG]; tp++) {
3102 if (*tp && **tp) { /* trap not NULL or SIG_IGN */
3107 setsignal(tp - trap);
3114 static int preadbuffer(void);
3115 static void pushfile(void);
3118 * Read a character from the script, returning PEOF on end of file.
3119 * Nul characters in the input are silently discarded.
3122 #ifndef CONFIG_ASH_OPTIMIZE_FOR_SIZE
3123 #define pgetc_macro() (--parsenleft >= 0? *parsenextc++ : preadbuffer())
3124 static int pgetc(void)
3126 return pgetc_macro();
3129 static int pgetc_macro(void)
3131 return --parsenleft >= 0 ? *parsenextc++ : preadbuffer();
3134 static inline int pgetc(void)
3136 return pgetc_macro();
3142 * Undo the last call to pgetc. Only one character may be pushed back.
3143 * PEOF may be pushed back.
3146 static void pungetc(void)
3153 static void popfile(void)
3155 struct parsefile *pf = parsefile;
3163 parsefile = pf->prev;
3165 parsenleft = parsefile->nleft;
3166 parselleft = parsefile->lleft;
3167 parsenextc = parsefile->nextc;
3168 plinno = parsefile->linno;
3174 * Return to top level.
3177 static void popallfiles(void)
3179 while (parsefile != &basepf)
3184 * Close the file(s) that the shell is reading commands from. Called
3185 * after a fork is done.
3188 static void closescript(void)
3191 if (parsefile->fd > 0) {
3192 close(parsefile->fd);
3199 * Like setinputfile, but takes an open file descriptor. Call this with
3203 static void setinputfd(int fd, int push)
3205 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
3211 while (parsefile->strpush)
3215 if (parsefile->buf == NULL)
3216 parsefile->buf = xmalloc(BUFSIZ);
3217 parselleft = parsenleft = 0;
3223 * Set the input to take input from a file. If push is set, push the
3224 * old input onto the stack first.
3227 static void setinputfile(const char *fname, int push)
3233 if ((fd = open(fname, O_RDONLY)) < 0)
3234 error("Can't open %s", fname);
3236 myfileno2 = dup_as_newfd(fd, 10);
3239 error("Out of file descriptors");
3242 setinputfd(fd, push);
3247 static void tryexec(char *cmd, char **argv, char **envp)
3251 #ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
3253 char **argv_l = argv;
3256 #ifdef CONFIG_FEATURE_SH_APPLETS_ALWAYS_WIN
3257 name = get_last_path_component(name);
3260 for (argc_l = 0; *argv_l != NULL; argv_l++, argc_l++)
3263 for (argc_l = 0; *argv_l != NULL; argv_l++, argc_l++)
3265 run_applet_by_name(name, argc_l, argv);
3268 execve(cmd, argv, envp);
3271 } else if (errno == ENOEXEC) {
3275 for (ap = argv; *ap; ap++);
3276 ap = new = xmalloc((ap - argv + 2) * sizeof(char *));
3277 *ap++ = cmd = "/bin/sh";
3278 while ((*ap++ = *argv++));
3284 static char *commandtext(const union node *);
3287 * Do a path search. The variable path (passed by reference) should be
3288 * set to the start of the path before the first call; padvance will update
3289 * this value as it proceeds. Successive calls to padvance will return
3290 * the possible path expansions in sequence. If an option (indicated by
3291 * a percent sign) appears in the path entry then the global variable
3292 * pathopt will be set to point to it; otherwise pathopt will be set to
3296 static const char *pathopt;
3298 static void growstackblock(void);
3301 static char *padvance(const char **path, const char *name)
3311 for (p = start; *p && *p != ':' && *p != '%'; p++);
3312 len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */
3313 while (stackblocksize() < len)
3317 memcpy(q, start, p - start);
3325 while (*p && *p != ':')
3332 return stalloc(len);
3336 * Wrapper around strcmp for qsort/bsearch/...
3338 static int pstrcmp(const void *a, const void *b)
3340 return strcmp((const char *) a, (*(const char *const *) b) + 1);
3344 * Find a keyword is in a sorted array.
3347 static const char *const *findkwd(const char *s)
3349 return bsearch(s, tokname_array + KWDOFFSET,
3350 (sizeof(tokname_array) / sizeof(const char *)) - KWDOFFSET,
3351 sizeof(const char *), pstrcmp);
3355 /*** Command hashing code ***/
3357 static int hashcmd(int argc, char **argv)
3359 struct tblentry **pp;
3360 struct tblentry *cmdp;
3363 struct cmdentry entry;
3366 #ifdef CONFIG_ASH_ALIAS
3367 const struct alias *ap;
3371 while ((c = nextopt("rvV")) != '\0') {
3375 } else if (c == 'v' || c == 'V') {
3379 if (*argptr == NULL) {
3380 for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
3381 for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
3382 if (cmdp->cmdtype != CMDBUILTIN) {
3383 printentry(cmdp, verbose);
3390 while ((name = *argptr++) != NULL) {
3391 if ((cmdp = cmdlookup(name, 0)) != NULL
3392 && (cmdp->cmdtype == CMDNORMAL
3393 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
3395 #ifdef CONFIG_ASH_ALIAS
3396 /* Then look at the aliases */
3397 if ((ap = *__lookupalias(name)) != NULL) {
3399 printf("%s is an alias for %s\n", name, ap->val);
3405 /* First look at the keywords */
3406 if (findkwd(name) != 0) {
3408 printf("%s is a shell keyword\n", name);
3414 find_command(name, &entry, DO_ERR, pathval());
3415 if (entry.cmdtype == CMDUNKNOWN)
3418 cmdp = cmdlookup(name, 0);
3420 printentry(cmdp, verbose == 'v');
3427 static void printentry(struct tblentry *cmdp, int verbose)
3433 printf("%s%s", cmdp->cmdname, (verbose ? " is " : ""));
3434 if (cmdp->cmdtype == CMDNORMAL) {
3435 idx = cmdp->param.index;
3438 name = padvance(&path, cmdp->cmdname);
3440 } while (--idx >= 0);
3443 } else if (cmdp->cmdtype == CMDBUILTIN) {
3445 out1str("a shell builtin");
3446 } else if (cmdp->cmdtype == CMDFUNCTION) {
3449 out1str("a function\n");
3450 name = commandtext(cmdp->param.func);
3451 printf("%s() {\n %s\n}", cmdp->cmdname, name);
3457 error("internal error: cmdtype %d", cmdp->cmdtype);
3460 puts(cmdp->rehash ? "*" : nullstr);
3465 /*** List the available builtins ***/
3468 static int helpcmd(int argc, char **argv)
3472 printf("\nBuilt-in commands:\n-------------------\n");
3473 for (col = 0, i = 0; i < NUMBUILTINS; i++) {
3474 col += printf("%c%s", ((col == 0) ? '\t' : ' '),
3475 builtincmds[i].name + 1);
3481 #ifdef CONFIG_FEATURE_SH_STANDALONE_SHELL
3483 extern const struct BB_applet applets[];
3484 extern const size_t NUM_APPLETS;
3486 for (i = 0; i < NUM_APPLETS; i++) {
3488 col += printf("%c%s", ((col == 0) ? '\t' : ' '), applets[i].name);
3497 return EXIT_SUCCESS;
3501 * Resolve a command name. If you change this routine, you may have to
3502 * change the shellexec routine as well.
3505 static int prefix(const char *, const char *);
3508 find_command(const char *name, struct cmdentry *entry, int act,
3511 struct tblentry *cmdp;
3521 struct builtincmd *bcmd;
3523 /* If name contains a slash, don't use the hash table */
3524 if (strchr(name, '/') != NULL) {
3526 while (stat(name, &statb) < 0) {
3527 if (errno != ENOENT && errno != ENOTDIR)
3529 entry->cmdtype = CMDUNKNOWN;
3530 entry->u.index = -1;
3533 entry->cmdtype = CMDNORMAL;
3534 entry->u.index = -1;
3537 entry->cmdtype = CMDNORMAL;
3543 if (act & DO_BRUTE) {
3544 firstchange = path_change(path, &bltin);
3550 /* If name is in the table, and not invalidated by cd, we're done */
3551 if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0) {
3552 if (cmdp->cmdtype == CMDFUNCTION) {
3553 if (act & DO_NOFUN) {
3558 } else if (act & DO_BRUTE) {
3559 if ((cmdp->cmdtype == CMDNORMAL &&
3560 cmdp->param.index >= firstchange) ||
3561 (cmdp->cmdtype == CMDBUILTIN &&
3562 ((builtinloc < 0 && bltin >= 0) ?
3563 bltin : builtinloc) >= firstchange)) {
3564 /* need to recompute the entry */
3573 bcmd = find_builtin(name);
3574 regular = bcmd && IS_BUILTIN_REGULAR(bcmd);
3577 if (cmdp && (cmdp->cmdtype == CMDBUILTIN)) {
3580 } else if (act & DO_BRUTE) {
3581 if (firstchange == 0) {
3586 /* If %builtin not in path, check for builtin next */
3587 if (regular || (bltin < 0 && bcmd)) {
3590 entry->cmdtype = CMDBUILTIN;
3591 entry->u.cmd = bcmd;
3595 cmdp = cmdlookup(name, 1);
3596 cmdp->cmdtype = CMDBUILTIN;
3597 cmdp->param.cmd = bcmd;
3602 /* We have to search path. */
3603 prev = -1; /* where to start */
3604 if (cmdp && cmdp->rehash) { /* doing a rehash */
3605 if (cmdp->cmdtype == CMDBUILTIN)
3608 prev = cmdp->param.index;
3614 while ((fullname = padvance(&path, name)) != NULL) {
3615 stunalloc(fullname);
3617 if (idx >= firstchange) {
3621 if (prefix("builtin", pathopt)) {
3622 if ((bcmd = find_builtin(name))) {
3626 } else if (!(act & DO_NOFUN) && prefix("func", pathopt)) {
3629 continue; /* ignore unimplemented options */
3632 /* if rehash, don't redo absolute path names */
3633 if (fullname[0] == '/' && idx <= prev && idx < firstchange) {
3636 TRACE(("searchexec \"%s\": no change\n", name));
3639 while (stat(fullname, &statb) < 0) {
3640 if (errno != ENOENT && errno != ENOTDIR)
3644 e = EACCES; /* if we fail, this will be the error */
3645 if (!S_ISREG(statb.st_mode))
3647 if (pathopt) { /* this is a %func directory */
3648 stalloc(strlen(fullname) + 1);
3649 readcmdfile(fullname);
3650 if ((cmdp = cmdlookup(name, 0)) == NULL
3651 || cmdp->cmdtype != CMDFUNCTION)
3652 error("%s not defined in %s", name, fullname);
3653 stunalloc(fullname);
3656 TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
3657 /* If we aren't called with DO_BRUTE and cmdp is set, it must
3658 be a function and we're being called with DO_NOFUN */
3660 entry->cmdtype = CMDNORMAL;
3661 entry->u.index = idx;
3665 cmdp = cmdlookup(name, 1);
3666 cmdp->cmdtype = CMDNORMAL;
3667 cmdp->param.index = idx;
3672 /* We failed. If there was an entry for this command, delete it */
3673 if (cmdp && updatetbl)
3676 out2fmt("%s: %s\n", name, errmsg(e, E_EXEC));
3677 entry->cmdtype = CMDUNKNOWN;
3682 entry->cmdtype = cmdp->cmdtype;
3683 entry->u = cmdp->param;
3689 * Search the table of builtin commands.
3692 static struct builtincmd *find_builtin(const char *name)
3694 struct builtincmd *bp;
3696 bp = bsearch(name, builtincmds, NUMBUILTINS, sizeof(struct builtincmd),
3703 * Called when a cd is done. Marks all commands so the next time they
3704 * are executed they will be rehashed.
3707 static void hashcd(void)
3709 struct tblentry **pp;
3710 struct tblentry *cmdp;
3712 for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
3713 for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
3714 if (cmdp->cmdtype == CMDNORMAL
3715 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))
3724 * Called before PATH is changed. The argument is the new value of PATH;
3725 * pathval() still returns the old value at this point. Called with
3729 static void changepath(const char *newval)
3734 firstchange = path_change(newval, &bltin);
3735 if (builtinloc < 0 && bltin >= 0)
3736 builtinloc = bltin; /* zap builtins */
3737 clearcmdentry(firstchange);
3739 /* Ensure that getenv("PATH") stays current */
3740 setenv("PATH", newval, 1);
3745 * Clear out command entries. The argument specifies the first entry in
3746 * PATH which has changed.
3749 static void clearcmdentry(int firstchange)
3751 struct tblentry **tblp;
3752 struct tblentry **pp;
3753 struct tblentry *cmdp;
3756 for (tblp = cmdtable; tblp < &cmdtable[CMDTABLESIZE]; tblp++) {
3758 while ((cmdp = *pp) != NULL) {
3759 if ((cmdp->cmdtype == CMDNORMAL &&
3760 cmdp->param.index >= firstchange)
3761 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= firstchange)) {
3774 * Locate a command in the command hash table. If "add" is nonzero,
3775 * add the command to the table if it is not already present. The
3776 * variable "lastcmdentry" is set to point to the address of the link
3777 * pointing to the entry, so that delete_cmd_entry can delete the
3781 static struct tblentry **lastcmdentry;
3783 static struct tblentry *cmdlookup(const char *name, int add)
3787 struct tblentry *cmdp;
3788 struct tblentry **pp;
3795 pp = &cmdtable[hashval % CMDTABLESIZE];
3796 for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
3797 if (equal(cmdp->cmdname, name))
3801 if (add && cmdp == NULL) {
3803 cmdp = *pp = xmalloc(sizeof(struct tblentry) - ARB
3804 + strlen(name) + 1);
3806 cmdp->cmdtype = CMDUNKNOWN;
3808 strcpy(cmdp->cmdname, name);
3816 * Delete the command entry returned on the last lookup.
3819 static void delete_cmd_entry(void)
3821 struct tblentry *cmdp;
3824 cmdp = *lastcmdentry;
3825 *lastcmdentry = cmdp->next;
3834 static const unsigned char nodesize[26] = {
3835 ALIGN(sizeof(struct nbinary)),
3836 ALIGN(sizeof(struct ncmd)),
3837 ALIGN(sizeof(struct npipe)),
3838 ALIGN(sizeof(struct nredir)),
3839 ALIGN(sizeof(struct nredir)),
3840 ALIGN(sizeof(struct nredir)),
3841 ALIGN(sizeof(struct nbinary)),
3842 ALIGN(sizeof(struct nbinary)),
3843 ALIGN(sizeof(struct nif)),
3844 ALIGN(sizeof(struct nbinary)),
3845 ALIGN(sizeof(struct nbinary)),
3846 ALIGN(sizeof(struct nfor)),
3847 ALIGN(sizeof(struct ncase)),
3848 ALIGN(sizeof(struct nclist)),
3849 ALIGN(sizeof(struct narg)),
3850 ALIGN(sizeof(struct narg)),
3851 ALIGN(sizeof(struct nfile)),
3852 ALIGN(sizeof(struct nfile)),
3853 ALIGN(sizeof(struct nfile)),
3854 ALIGN(sizeof(struct nfile)),
3855 ALIGN(sizeof(struct nfile)),
3856 ALIGN(sizeof(struct ndup)),
3857 ALIGN(sizeof(struct ndup)),
3858 ALIGN(sizeof(struct nhere)),
3859 ALIGN(sizeof(struct nhere)),
3860 ALIGN(sizeof(struct nnot)),
3866 * Delete a function if it exists.
3869 static void unsetfunc(char *name)
3871 struct tblentry *cmdp;
3873 if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->cmdtype == CMDFUNCTION) {
3874 free(cmdp->param.func);
3881 * Locate and print what a word is...
3884 static int typecmd(int argc, char **argv)
3892 for (i = 1; i < argc; i++) {
3893 argv_a[0] = argv[i];
3896 err |= hashcmd(argc, argv);
3901 #ifdef CONFIG_ASH_CMDCMD
3902 static int commandcmd(int argc, char **argv)
3905 int default_path = 0;
3906 int verify_only = 0;
3907 int verbose_verify_only = 0;
3909 while ((c = nextopt("pvV")) != '\0')
3918 verbose_verify_only = 1;
3922 if (default_path + verify_only + verbose_verify_only > 1 || !*argptr) {
3923 out2str("command [-p] command [arg ...]\n"
3924 "command {-v|-V} command\n");
3928 if (verify_only || verbose_verify_only) {
3932 argv_a[0] = *argptr;
3934 optptr = verbose_verify_only ? "v" : "V"; /* reverse special */
3935 return hashcmd(argc, argv);
3942 static int path_change(const char *newval, int *bltin)
3944 const char *old, *new;
3950 firstchange = 9999; /* assume no change */
3956 if ((*old == '\0' && *new == ':')
3957 || (*old == ':' && *new == '\0'))
3959 old = new; /* ignore subsequent differences */
3963 if (*new == '%' && *bltin < 0 && prefix("builtin", new + 1))
3970 if (builtinloc >= 0 && *bltin < 0)
3976 * Routines to expand arguments to commands. We have to deal with
3977 * backquotes, shell variables, and file metacharacters.
3982 #define RMESCAPE_ALLOC 0x1 /* Allocate a new string */
3983 #define RMESCAPE_GLOB 0x2 /* Add backslashes for glob */
3986 * Structure specifying which parts of the string should be searched
3987 * for IFS characters.
3991 struct ifsregion *next; /* next region in list */
3992 int begoff; /* offset of start of region */
3993 int endoff; /* offset of end of region */
3994 int nulonly; /* search for nul bytes only */
3998 static char *expdest; /* output of current string */
3999 static struct nodelist *argbackq; /* list of back quote expressions */
4000 static struct ifsregion ifsfirst; /* first struct in list of ifs regions */
4001 static struct ifsregion *ifslastp; /* last struct in list */
4002 static struct arglist exparg; /* holds expanded arg list */
4004 static void argstr(char *, int);
4005 static char *exptilde(char *, int);
4006 static void expbackq(union node *, int, int);
4007 static int subevalvar(char *, char *, int, int, int, int, int);
4008 static int varisset(char *, int);
4009 static void strtodest(const char *, int, int);
4010 static void varvalue(char *, int, int);
4011 static void recordregion(int, int, int);
4012 static void removerecordregions(int);
4013 static void ifsbreakup(char *, struct arglist *);
4014 static void ifsfree(void);
4015 static void expandmeta(struct strlist *, int);
4017 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
4018 #define preglob(p) _rmescapes((p), RMESCAPE_ALLOC | RMESCAPE_GLOB)
4019 #if !defined(GLOB_BROKEN)
4020 static void addglob(const glob_t *);
4023 #if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
4024 static void expmeta(char *, char *);
4026 #if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
4027 static struct strlist *expsort(struct strlist *);
4028 static struct strlist *msort(struct strlist *, int);
4030 static int patmatch(char *, char *, int);
4032 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
4033 static int patmatch2(char *, char *, int);
4035 static int pmatch(char *, char *, int);
4037 #define patmatch2 patmatch
4039 static char *cvtnum(int, char *);
4042 * Expand shell variables and backquotes inside a here document.
4045 /* arg: the document, fd: where to write the expanded version */
4046 static inline void expandhere(union node *arg, int fd)
4049 expandarg(arg, (struct arglist *) NULL, 0);
4050 xwrite(fd, stackblock(), expdest - stackblock());
4055 * Perform variable substitution and command substitution on an argument,
4056 * placing the resulting list of arguments in arglist. If EXP_FULL is true,
4057 * perform splitting and file name expansion. When arglist is NULL, perform
4058 * here document expansion.
4061 static void expandarg(union node *arg, struct arglist *arglist, int flag)
4066 argbackq = arg->narg.backquote;
4067 STARTSTACKSTR(expdest);
4068 ifsfirst.next = NULL;
4070 argstr(arg->narg.text, flag);
4071 if (arglist == NULL) {
4072 return; /* here document expanded */
4074 STPUTC('\0', expdest);
4075 p = grabstackstr(expdest);
4076 exparg.lastp = &exparg.list;
4080 if (flag & EXP_FULL) {
4081 ifsbreakup(p, &exparg);
4082 *exparg.lastp = NULL;
4083 exparg.lastp = &exparg.list;
4084 expandmeta(exparg.list, flag);
4086 if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
4088 sp = (struct strlist *) stalloc(sizeof(struct strlist));
4091 exparg.lastp = &sp->next;
4094 *exparg.lastp = NULL;
4096 *arglist->lastp = exparg.list;
4097 arglist->lastp = exparg.lastp;
4103 * Expand a variable, and return a pointer to the next character in the
4107 static inline char *evalvar(char *p, int flag)
4120 int quotes = flag & (EXP_FULL | EXP_CASE);
4123 subtype = varflags & VSTYPE;
4128 p = strchr(p, '=') + 1;
4129 again: /* jump here after setting a variable with ${var=text} */
4131 set = varisset(var, varflags & VSNUL);
4134 val = lookupvar(var);
4135 if (val == NULL || ((varflags & VSNUL) && val[0] == '\0')) {
4142 startloc = expdest - stackblock();
4143 if (set && subtype != VSPLUS) {
4144 /* insert the value of the variable */
4146 varvalue(var, varflags & VSQUOTE, flag);
4147 if (subtype == VSLENGTH) {
4148 varlen = expdest - stackblock() - startloc;
4149 STADJUST(-varlen, expdest);
4152 if (subtype == VSLENGTH) {
4153 varlen = strlen(val);
4156 varflags & VSQUOTE ? DQSYNTAX : BASESYNTAX, quotes);
4161 if (subtype == VSPLUS)
4164 easy = ((varflags & VSQUOTE) == 0 ||
4165 (*var == '@' && shellparam.nparam != 1));
4170 expdest = cvtnum(varlen, expdest);
4177 recordregion(startloc, expdest - stackblock(), varflags & VSQUOTE);
4193 case VSTRIMRIGHTMAX:
4197 * Terminate the string and start recording the pattern
4200 STPUTC('\0', expdest);
4201 patloc = expdest - stackblock();
4202 if (subevalvar(p, NULL, patloc, subtype,
4203 startloc, varflags, quotes) == 0) {
4204 int amount = (expdest - stackblock() - patloc) + 1;
4206 STADJUST(-amount, expdest);
4208 /* Remove any recorded regions beyond start of variable */
4209 removerecordregions(startloc);
4215 if (subevalvar(p, var, 0, subtype, startloc, varflags, quotes)) {
4218 * Remove any recorded regions beyond
4221 removerecordregions(startloc);
4236 if (subtype != VSNORMAL) { /* skip to end of alternative */
4240 if ((c = *p++) == CTLESC)
4242 else if (c == CTLBACKQ || c == (CTLBACKQ | CTLQUOTE)) {
4244 argbackq = argbackq->next;
4245 } else if (c == CTLVAR) {
4246 if ((*p++ & VSTYPE) != VSNORMAL)
4248 } else if (c == CTLENDVAR) {
4259 * Perform variable and command substitution. If EXP_FULL is set, output CTLESC
4260 * characters to allow for further processing. Otherwise treat
4261 * $@ like $* since no splitting will be performed.
4264 static void argstr(char *p, int flag)
4267 int quotes = flag & (EXP_FULL | EXP_CASE); /* do CTLESC */
4270 if (*p == '~' && (flag & (EXP_TILDE | EXP_VARTILDE)))
4271 p = exptilde(p, flag);
4275 case CTLENDVAR: /* ??? */
4278 /* "$@" syntax adherence hack */
4279 if (p[0] == CTLVAR && p[2] == '@' && p[3] == '=')
4281 if ((flag & EXP_FULL) != 0)
4291 p = evalvar(p, flag);
4294 case CTLBACKQ | CTLQUOTE:
4295 expbackq(argbackq->n, c & CTLQUOTE, flag);
4296 argbackq = argbackq->next;
4298 #ifdef CONFIG_ASH_MATH_SUPPORT
4306 * sort of a hack - expand tildes in variable
4307 * assignments (after the first '=' and after ':'s).
4310 if (flag & EXP_VARTILDE && *p == '~') {
4317 p = exptilde(p, flag);
4326 static char *exptilde(char *p, int flag)
4328 char c, *startp = p;
4331 int quotes = flag & (EXP_FULL | EXP_CASE);
4333 while ((c = *p) != '\0') {
4340 if (flag & EXP_VARTILDE)
4350 if (*(startp + 1) == '\0') {
4351 if ((home = lookupvar("HOME")) == NULL)
4354 if ((pw = getpwnam(startp + 1)) == NULL)
4361 strtodest(home, SQSYNTAX, quotes);
4369 static void removerecordregions(int endoff)
4371 if (ifslastp == NULL)
4374 if (ifsfirst.endoff > endoff) {
4375 while (ifsfirst.next != NULL) {
4376 struct ifsregion *ifsp;
4379 ifsp = ifsfirst.next->next;
4380 free(ifsfirst.next);
4381 ifsfirst.next = ifsp;
4384 if (ifsfirst.begoff > endoff)
4387 ifslastp = &ifsfirst;
4388 ifsfirst.endoff = endoff;
4393 ifslastp = &ifsfirst;
4394 while (ifslastp->next && ifslastp->next->begoff < endoff)
4395 ifslastp = ifslastp->next;
4396 while (ifslastp->next != NULL) {
4397 struct ifsregion *ifsp;
4400 ifsp = ifslastp->next->next;
4401 free(ifslastp->next);
4402 ifslastp->next = ifsp;
4405 if (ifslastp->endoff > endoff)
4406 ifslastp->endoff = endoff;
4410 #ifdef CONFIG_ASH_MATH_SUPPORT
4412 * Expand arithmetic expression. Backup to start of expression,
4413 * evaluate, place result in (backed up) result, adjust string position.
4415 static void expari(int flag)
4421 int quotes = flag & (EXP_FULL | EXP_CASE);
4427 * This routine is slightly over-complicated for
4428 * efficiency. First we make sure there is
4429 * enough space for the result, which may be bigger
4430 * than the expression if we add exponentation. Next we
4431 * scan backwards looking for the start of arithmetic. If the
4432 * next previous character is a CTLESC character, then we
4433 * have to rescan starting from the beginning since CTLESC
4434 * characters have to be processed left to right.
4436 CHECKSTRSPACE(10, expdest);
4437 USTPUTC('\0', expdest);
4438 start = stackblock();
4440 while (*p != CTLARI && p >= start)
4443 error("missing CTLARI (shouldn't happen)");
4444 if (p > start && *(p - 1) == CTLESC)
4445 for (p = start; *p != CTLARI; p++)
4454 removerecordregions(begoff);
4457 result = arith(p + 2, &errcode);
4460 error("divide by zero");
4462 error("syntax error: \"%s\"\n", p + 2);
4464 snprintf(p, 12, "%d", result);
4468 recordregion(begoff, p - 1 - start, 0);
4469 result = expdest - p + 1;
4470 STADJUST(-result, expdest);
4475 * Expand stuff in backwards quotes.
4478 static void expbackq(union node *cmd, int quoted, int flag)
4480 volatile struct backcmd in;
4484 char *dest = expdest;
4485 volatile struct ifsregion saveifs;
4486 struct ifsregion *volatile savelastp;
4487 struct nodelist *volatile saveargbackq;
4489 int startloc = dest - stackblock();
4490 int syntax = quoted ? DQSYNTAX : BASESYNTAX;
4491 volatile int saveherefd;
4492 int quotes = flag & (EXP_FULL | EXP_CASE);
4493 struct jmploc jmploc;
4494 struct jmploc *volatile savehandler;
4498 /* Avoid longjmp clobbering */
4509 savelastp = ifslastp;
4510 saveargbackq = argbackq;
4511 saveherefd = herefd;
4513 if ((ex = setjmp(jmploc.loc))) {
4516 savehandler = handler;
4519 p = grabstackstr(dest);
4520 evalbackcmd(cmd, (struct backcmd *) &in);
4521 ungrabstackstr(p, dest);
4525 ifslastp = savelastp;
4526 argbackq = saveargbackq;
4527 herefd = saveherefd;
4535 if (--in.nleft < 0) {
4538 i = safe_read(in.fd, buf, sizeof buf);
4539 TRACE(("expbackq: read returns %d\n", i));
4546 if (lastc != '\0') {
4547 if (quotes && SIT(lastc, syntax) == CCTL)
4548 STPUTC(CTLESC, dest);
4549 STPUTC(lastc, dest);
4553 /* Eat all trailing newlines */
4554 for (; dest > stackblock() && dest[-1] == '\n';)
4562 exitstatus = waitforjob(in.jp);
4563 handler = savehandler;
4565 longjmp(handler->loc, 1);
4568 recordregion(startloc, dest - stackblock(), 0);
4569 TRACE(("evalbackq: size=%d: \"%.*s\"\n",
4570 (dest - stackblock()) - startloc,
4571 (dest - stackblock()) - startloc, stackblock() + startloc));
4577 subevalvar(char *p, char *str, int strloc, int subtype, int startloc,
4578 int varflags, int quotes)
4584 int saveherefd = herefd;
4585 struct nodelist *saveargbackq = argbackq;
4589 argstr(p, subtype != VSASSIGN && subtype != VSQUESTION ? EXP_CASE : 0);
4590 STACKSTRNUL(expdest);
4591 herefd = saveherefd;
4592 argbackq = saveargbackq;
4593 startp = stackblock() + startloc;
4595 str = stackblock() + strloc;
4599 setvar(str, startp, 0);
4600 amount = startp - expdest;
4601 STADJUST(amount, expdest);
4608 if (*p != CTLENDVAR) {
4609 out2fmt(snlfmt, startp);
4610 error((char *) NULL);
4612 error("%.*s: parameter %snot set", p - str - 1,
4613 str, (varflags & VSNUL) ? "null or " : nullstr);
4617 for (loc = startp; loc < str; loc++) {
4620 if (patmatch2(str, startp, quotes))
4623 if (quotes && *loc == CTLESC)
4629 for (loc = str - 1; loc >= startp;) {
4632 if (patmatch2(str, startp, quotes))
4636 if (quotes && loc > startp && *(loc - 1) == CTLESC) {
4637 for (q = startp; q < loc; q++)
4647 for (loc = str - 1; loc >= startp;) {
4648 if (patmatch2(str, loc, quotes))
4651 if (quotes && loc > startp && *(loc - 1) == CTLESC) {
4652 for (q = startp; q < loc; q++)
4661 case VSTRIMRIGHTMAX:
4662 for (loc = startp; loc < str - 1; loc++) {
4663 if (patmatch2(str, loc, quotes))
4665 if (quotes && *loc == CTLESC)
4678 amount = ((str - 1) - (loc - startp)) - expdest;
4679 STADJUST(amount, expdest);
4680 while (loc != str - 1)
4685 amount = loc - expdest;
4686 STADJUST(amount, expdest);
4687 STPUTC('\0', expdest);
4688 STADJUST(-1, expdest);
4694 * Test whether a specialized variable is set.
4697 static int varisset(char *name, int nulok)
4700 return backgndpid != -1;
4701 else if (*name == '@' || *name == '*') {
4702 if (*shellparam.p == NULL)
4708 for (av = shellparam.p; *av; av++)
4713 } else if (is_digit(*name)) {
4715 int num = atoi(name);
4717 if (num > shellparam.nparam)
4723 ap = shellparam.p[num - 1];
4725 if (nulok && (ap == NULL || *ap == '\0'))
4732 * Put a string on the stack.
4735 static void strtodest(const char *p, int syntax, int quotes)
4738 if (quotes && SIT(*p, syntax) == CCTL)
4739 STPUTC(CTLESC, expdest);
4740 STPUTC(*p++, expdest);
4745 * Add the value of a specialized variable to the stack string.
4748 static void varvalue(char *name, int quoted, int flags)
4757 int allow_split = flags & EXP_FULL;
4758 int quotes = flags & (EXP_FULL | EXP_CASE);
4760 syntax = quoted ? DQSYNTAX : BASESYNTAX;
4769 num = shellparam.nparam;
4774 expdest = cvtnum(num, expdest);
4777 for (i = 0; i < NOPTS; i++) {
4779 STPUTC(optent_letter(optlist[i]), expdest);
4783 if (allow_split && quoted) {
4784 sep = 1 << CHAR_BIT;
4789 sep = ifsset()? ifsval()[0] : ' ';
4791 sepq = SIT(sep, syntax) == CCTL;
4794 for (ap = shellparam.p; (p = *ap++) != NULL;) {
4795 strtodest(p, syntax, quotes);
4798 STPUTC(CTLESC, expdest);
4799 STPUTC(sep, expdest);
4804 strtodest(arg0, syntax, quotes);
4808 if (num > 0 && num <= shellparam.nparam) {
4809 strtodest(shellparam.p[num - 1], syntax, quotes);
4817 * Record the fact that we have to scan this region of the
4818 * string for IFS characters.
4821 static void recordregion(int start, int end, int nulonly)
4823 struct ifsregion *ifsp;
4825 if (ifslastp == NULL) {
4829 ifsp = (struct ifsregion *) xmalloc(sizeof(struct ifsregion));
4831 ifslastp->next = ifsp;
4835 ifslastp->begoff = start;
4836 ifslastp->endoff = end;
4837 ifslastp->nulonly = nulonly;
4843 * Break the argument string into pieces based upon IFS and add the
4844 * strings to the argument list. The regions of the string to be
4845 * searched for IFS characters have been stored by recordregion.
4847 static void ifsbreakup(char *string, struct arglist *arglist)
4849 struct ifsregion *ifsp;
4854 const char *ifs, *realifs;
4862 realifs = ifsset()? ifsval() : defifs;
4863 if (ifslastp != NULL) {
4866 p = string + ifsp->begoff;
4867 nulonly = ifsp->nulonly;
4868 ifs = nulonly ? nullstr : realifs;
4870 while (p < string + ifsp->endoff) {
4874 if (strchr(ifs, *p)) {
4876 ifsspc = (strchr(defifs, *p) != NULL);
4877 /* Ignore IFS whitespace at start */
4878 if (q == start && ifsspc) {
4884 sp = (struct strlist *) stalloc(sizeof *sp);
4886 *arglist->lastp = sp;
4887 arglist->lastp = &sp->next;
4891 if (p >= string + ifsp->endoff) {
4897 if (strchr(ifs, *p) == NULL) {
4900 } else if (strchr(defifs, *p) == NULL) {
4916 } while ((ifsp = ifsp->next) != NULL);
4917 if (!(*start || (!ifsspc && start > string && nulonly))) {
4922 sp = (struct strlist *) stalloc(sizeof *sp);
4924 *arglist->lastp = sp;
4925 arglist->lastp = &sp->next;
4928 static void ifsfree(void)
4930 while (ifsfirst.next != NULL) {
4931 struct ifsregion *ifsp;
4934 ifsp = ifsfirst.next->next;
4935 free(ifsfirst.next);
4936 ifsfirst.next = ifsp;
4940 ifsfirst.next = NULL;
4944 * Add a file name to the list.
4947 static void addfname(const char *name)
4950 size_t len = strlen(name) + 1;
4952 sp = (struct strlist *) stalloc(sizeof *sp);
4953 sp->text = memcpy(stalloc(len), name, len);
4955 exparg.lastp = &sp->next;
4959 * Expand shell metacharacters. At this point, the only control characters
4960 * should be escapes. The results are stored in the list exparg.
4963 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN)
4964 static void expandmeta(struct strlist *str, int flag)
4969 /* TODO - EXP_REDIR */
4974 p = preglob(str->text);
4976 switch (glob(p, 0, 0, &pglob)) {
4978 if (pglob.gl_pathv[1] == 0 && !strcmp(p, pglob.gl_pathv[0]))
4989 *exparg.lastp = str;
4990 rmescapes(str->text);
4991 exparg.lastp = &str->next;
4993 default: /* GLOB_NOSPACE */
4994 error("Out of space");
5002 * Add the result of glob(3) to the list.
5005 static void addglob(const glob_t * pglob)
5007 char **p = pglob->gl_pathv;
5015 #else /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
5016 static char *expdir;
5019 static void expandmeta(struct strlist *str, int flag)
5022 struct strlist **savelastp;
5026 /* TODO - EXP_REDIR */
5032 for (;;) { /* fast check for meta chars */
5033 if ((c = *p++) == '\0')
5035 if (c == '*' || c == '?' || c == '[' || c == '!')
5038 savelastp = exparg.lastp;
5040 if (expdir == NULL) {
5041 int i = strlen(str->text);
5043 expdir = xmalloc(i < 2048 ? 2048 : i); /* XXX */
5046 expmeta(expdir, str->text);
5050 if (exparg.lastp == savelastp) {
5055 *exparg.lastp = str;
5056 rmescapes(str->text);
5057 exparg.lastp = &str->next;
5059 *exparg.lastp = NULL;
5060 *savelastp = sp = expsort(*savelastp);
5061 while (sp->next != NULL)
5063 exparg.lastp = &sp->next;
5071 * Do metacharacter (i.e. *, ?, [...]) expansion.
5074 static void expmeta(char *enddir, char *name)
5090 for (p = name;; p++) {
5091 if (*p == '*' || *p == '?')
5093 else if (*p == '[') {
5098 while (*q == CTLQUOTEMARK)
5102 if (*q == '/' || *q == '\0')
5109 } else if (*p == '!' && p[1] == '!' && (p == name || p[-1] == '/')) {
5111 } else if (*p == '\0')
5113 else if (*p == CTLQUOTEMARK)
5115 else if (*p == CTLESC)
5123 if (metaflag == 0) { /* we've reached the end of the file name */
5124 if (enddir != expdir)
5126 for (p = name;; p++) {
5127 if (*p == CTLQUOTEMARK)
5135 if (metaflag == 0 || lstat(expdir, &statb) >= 0)
5140 if (start != name) {
5143 while (*p == CTLQUOTEMARK)
5150 if (enddir == expdir) {
5152 } else if (enddir == expdir + 1 && *expdir == '/') {
5158 if ((dirp = opendir(cp)) == NULL)
5160 if (enddir != expdir)
5162 if (*endname == 0) {
5170 while (*p == CTLQUOTEMARK)
5176 while (!int_pending() && (dp = readdir(dirp)) != NULL) {
5177 if (dp->d_name[0] == '.' && !matchdot)
5179 if (patmatch(start, dp->d_name, 0)) {
5181 strcpy(enddir, dp->d_name);
5184 for (p = enddir, cp = dp->d_name; (*p++ = *cp++) != '\0';)
5187 expmeta(p, endname);
5195 #endif /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
5199 #if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
5201 * Sort the results of file name expansion. It calculates the number of
5202 * strings to sort and then calls msort (short for merge sort) to do the
5206 static struct strlist *expsort(struct strlist *str)
5212 for (sp = str; sp; sp = sp->next)
5214 return msort(str, len);
5218 static struct strlist *msort(struct strlist *list, int len)
5220 struct strlist *p, *q = NULL;
5221 struct strlist **lpp;
5229 for (n = half; --n >= 0;) {
5233 q->next = NULL; /* terminate first half of list */
5234 q = msort(list, half); /* sort first half of list */
5235 p = msort(p, len - half); /* sort second half */
5238 if (strcmp(p->text, q->text) < 0) {
5241 if ((p = *lpp) == NULL) {
5248 if ((q = *lpp) == NULL) {
5261 * Returns true if the pattern matches the string.
5264 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
5265 /* squoted: string might have quote chars */
5266 static int patmatch(char *pattern, char *string, int squoted)
5271 p = preglob(pattern);
5272 q = squoted ? _rmescapes(string, RMESCAPE_ALLOC) : string;
5274 return !fnmatch(p, q, 0);
5278 static int patmatch2(char *pattern, char *string, int squoted)
5284 p = grabstackstr(expdest);
5285 res = patmatch(pattern, string, squoted);
5286 ungrabstackstr(p, expdest);
5290 static int patmatch(char *pattern, char *string, int squoted)
5292 return pmatch(pattern, string, squoted);
5296 static int pmatch(char *pattern, char *string, int squoted)
5308 if (squoted && *q == CTLESC)
5316 if (squoted && *q == CTLESC)
5323 while (c == CTLQUOTEMARK || c == '*')
5325 if (c != CTLESC && c != CTLQUOTEMARK &&
5326 c != '?' && c != '*' && c != '[') {
5328 if (squoted && *q == CTLESC && q[1] == c)
5332 if (squoted && *q == CTLESC)
5338 if (pmatch(p, q, squoted))
5340 if (squoted && *q == CTLESC)
5342 } while (*q++ != '\0');
5353 while (*endp == CTLQUOTEMARK)
5356 goto dft; /* no matching ] */
5357 if (*endp == CTLESC)
5369 if (squoted && chr == CTLESC)
5375 if (c == CTLQUOTEMARK)
5379 if (*p == '-' && p[1] != ']') {
5381 while (*p == CTLQUOTEMARK)
5385 if (chr >= c && chr <= *p)
5392 } while ((c = *p++) != ']');
5393 if (found == invert)
5398 if (squoted && *q == CTLESC)
5415 * Remove any CTLESC characters from a string.
5418 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
5419 static char *_rmescapes(char *str, int flag)
5422 static const char qchars[] = { CTLESC, CTLQUOTEMARK, 0 };
5424 p = strpbrk(str, qchars);
5430 if (flag & RMESCAPE_ALLOC) {
5431 size_t len = p - str;
5433 q = r = stalloc(strlen(p) + len + 1);
5435 memcpy(q, str, len);
5440 if (*p == CTLQUOTEMARK) {
5446 if (flag & RMESCAPE_GLOB && *p != '/') {
5456 static void rmescapes(char *str)
5461 while (*p != CTLESC && *p != CTLQUOTEMARK) {
5467 if (*p == CTLQUOTEMARK) {
5482 * See if a pattern matches in a case statement.
5485 static int casematch(union node *pattern, const char *val)
5487 struct stackmark smark;
5491 setstackmark(&smark);
5492 argbackq = pattern->narg.backquote;
5493 STARTSTACKSTR(expdest);
5495 argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
5496 STPUTC('\0', expdest);
5497 p = grabstackstr(expdest);
5498 result = patmatch(p, (char *) val, 0);
5499 popstackmark(&smark);
5507 static char *cvtnum(int num, char *buf)
5511 CHECKSTRSPACE(32, buf);
5512 len = sprintf(buf, "%d", num);
5518 * Editline and history functions (and glue).
5520 static int histcmd(int argc, char **argv)
5522 error("not compiled with history support");
5528 struct redirtab *next;
5529 short renamed[10]; /* Current ash support only 0-9 descriptors */
5530 /* char on arm (and others) can't be negative */
5533 static struct redirtab *redirlist;
5535 extern char **environ;
5540 * Initialization code.
5543 static void init(void)
5554 basepf.nextc = basepf.buf = basebuf;
5563 for (envp = environ; *envp; envp++) {
5564 if (strchr(*envp, '=')) {
5565 setvareq(*envp, VEXPORT | VTEXTFIXED);
5569 snprintf(ppid, sizeof(ppid), "%d", (int) getppid());
5570 setvar("PPID", ppid, 0);
5577 * This routine is called when an error or an interrupt occurs in an
5578 * interactive shell and control is returned to the main command loop.
5581 /* 1 == check for aliases, 2 == also check for assignments */
5582 static int checkalias; /* also used in no alias mode for check assignments */
5584 static void reset(void)
5596 parselleft = parsenleft = 0; /* clear input buffer */
5600 /* from parser.c: */
5618 * This file implements the input routines used by the parser.
5621 #ifdef CONFIG_FEATURE_COMMAND_EDITING
5622 static const char *cmdedit_prompt;
5623 static inline void putprompt(const char *s)
5628 static inline void putprompt(const char *s)
5634 #define EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */
5639 * Same as pgetc(), but ignores PEOA.
5642 #ifdef CONFIG_ASH_ALIAS
5643 static int pgetc2(void)
5649 } while (c == PEOA);
5653 static inline int pgetc2(void)
5655 return pgetc_macro();
5660 * Read a line from the script.
5663 static inline char *pfgets(char *line, int len)
5669 while (--nleft > 0) {
5684 static inline int preadfd(void)
5687 char *buf = parsefile->buf;
5692 #ifdef CONFIG_FEATURE_COMMAND_EDITING
5694 if (!iflag || parsefile->fd)
5695 nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
5697 nr = cmdedit_read_input((char *) cmdedit_prompt, buf);
5701 nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
5705 if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
5706 int flags = fcntl(0, F_GETFL, 0);
5708 if (flags >= 0 && flags & O_NONBLOCK) {
5709 flags &= ~O_NONBLOCK;
5710 if (fcntl(0, F_SETFL, flags) >= 0) {
5711 out2str("sh: turning off NDELAY mode\n");
5720 static void popstring(void)
5722 struct strpush *sp = parsefile->strpush;
5725 #ifdef CONFIG_ASH_ALIAS
5727 if (parsenextc[-1] == ' ' || parsenextc[-1] == '\t') {
5732 if (sp->string != sp->ap->val) {
5736 sp->ap->flag &= ~ALIASINUSE;
5737 if (sp->ap->flag & ALIASDEAD) {
5738 unalias(sp->ap->name);
5742 parsenextc = sp->prevstring;
5743 parsenleft = sp->prevnleft;
5744 /*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
5745 parsefile->strpush = sp->prev;
5746 if (sp != &(parsefile->basestrpush))
5753 * Refill the input buffer and return the next input character:
5755 * 1) If a string was pushed back on the input, pop it;
5756 * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
5757 * from a string so we can't refill the buffer, return EOF.
5758 * 3) If the is more stuff in this buffer, use it else call read to fill it.
5759 * 4) Process input up to the next newline, deleting nul characters.
5762 static int preadbuffer(void)
5768 while (parsefile->strpush) {
5769 #ifdef CONFIG_ASH_ALIAS
5770 if (parsenleft == -1 && parsefile->strpush->ap &&
5771 parsenextc[-1] != ' ' && parsenextc[-1] != '\t') {
5776 if (--parsenleft >= 0)
5777 return (*parsenextc++);
5779 if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
5784 if (parselleft <= 0) {
5785 if ((parselleft = preadfd()) <= 0) {
5786 parselleft = parsenleft = EOF_NLEFT;
5793 /* delete nul characters */
5794 for (more = 1; more;) {
5802 parsenleft = q - parsenextc;
5803 more = 0; /* Stop processing here */
5809 if (--parselleft <= 0 && more) {
5810 parsenleft = q - parsenextc - 1;
5821 out2str(parsenextc);
5826 return *parsenextc++;
5831 * Push a string back onto the input at this current parsefile level.
5832 * We handle aliases this way.
5834 static void pushstring(char *s, int len, void *ap)
5839 /*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
5840 if (parsefile->strpush) {
5841 sp = xmalloc(sizeof(struct strpush));
5842 sp->prev = parsefile->strpush;
5843 parsefile->strpush = sp;
5845 sp = parsefile->strpush = &(parsefile->basestrpush);
5846 sp->prevstring = parsenextc;
5847 sp->prevnleft = parsenleft;
5848 #ifdef CONFIG_ASH_ALIAS
5849 sp->ap = (struct alias *) ap;
5851 ((struct alias *) ap)->flag |= ALIASINUSE;
5862 * Like setinputfile, but takes input from a string.
5865 static void setinputstring(char *string)
5869 parsenextc = string;
5870 parsenleft = strlen(string);
5871 parsefile->buf = NULL;
5879 * To handle the "." command, a stack of input files is used. Pushfile
5880 * adds a new entry to the stack and popfile restores the previous level.
5883 static void pushfile(void)
5885 struct parsefile *pf;
5887 parsefile->nleft = parsenleft;
5888 parsefile->lleft = parselleft;
5889 parsefile->nextc = parsenextc;
5890 parsefile->linno = plinno;
5891 pf = (struct parsefile *) xmalloc(sizeof(struct parsefile));
5892 pf->prev = parsefile;
5895 pf->basestrpush.prev = NULL;
5899 #ifdef CONFIG_ASH_JOB_CONTROL
5900 static void restartjob(struct job *);
5902 static void freejob(struct job *);
5903 static struct job *getjob(const char *);
5904 static int dowait(int, struct job *);
5908 * We keep track of whether or not fd0 has been redirected. This is for
5909 * background commands, where we want to redirect fd0 to /dev/null only
5910 * if it hasn't already been redirected.
5912 static int fd0_redirected = 0;
5914 /* Return true if fd 0 has already been redirected at least once. */
5915 static inline int fd0_redirected_p(void)
5917 return fd0_redirected != 0;
5920 static void dupredirect(const union node *, int, int fd1dup);
5922 #ifdef CONFIG_ASH_JOB_CONTROL
5924 * Turn job control on and off.
5926 * Note: This code assumes that the third arg to ioctl is a character
5927 * pointer, which is true on Berkeley systems but not System V. Since
5928 * System V doesn't have job control yet, this isn't a problem now.
5933 static void setjobctl(int enable)
5935 if (enable == jobctl || rootshell == 0)
5938 do { /* while we are in the background */
5939 initialpgrp = tcgetpgrp(2);
5940 if (initialpgrp < 0) {
5941 out2str("sh: can't access tty; job control turned off\n");
5945 if (initialpgrp == -1)
5946 initialpgrp = getpgrp();
5947 else if (initialpgrp != getpgrp()) {
5948 killpg(initialpgrp, SIGTTIN);
5955 setpgid(0, rootpid);
5956 tcsetpgrp(2, rootpid);
5957 } else { /* turning job control off */
5958 setpgid(0, initialpgrp);
5959 tcsetpgrp(2, initialpgrp);
5969 #ifdef CONFIG_ASH_JOB_CONTROL
5970 static int killcmd(int argc, char **argv)
5981 ("Usage: kill [-s sigspec | -signum | -sigspec] [pid | job]... or\n"
5982 "kill -l [exitstatus]");
5985 if (*argv[1] == '-') {
5986 signo = decode_signal(argv[1] + 1, 1);
5990 while ((c = nextopt("ls:")) != '\0')
5996 signo = decode_signal(optionarg, 1);
5998 error("invalid signal number or name: %s", optionarg);
6003 error("nextopt returned character code 0%o", c);
6010 if (!list && signo < 0)
6013 if ((signo < 0 || !*argptr) ^ list) {
6022 for (i = 1; i < NSIG; i++) {
6023 name = u_signal_names(0, &i, 1);
6029 name = u_signal_names(*argptr, &signo, -1);
6033 error("invalid signal number or exit status: %s", *argptr);
6038 if (**argptr == '%') {
6039 jp = getjob(*argptr);
6040 if (jp->jobctl == 0)
6041 error("job %s not created under job control", *argptr);
6042 pid = -jp->ps[0].pid;
6044 pid = atoi(*argptr);
6045 if (kill(pid, signo) != 0)
6046 error("%s: %m", *argptr);
6047 } while (*++argptr);
6052 static int fgcmd(int argc, char **argv)
6058 jp = getjob(argv[1]);
6059 if (jp->jobctl == 0)
6060 error("job not created under job control");
6061 pgrp = jp->ps[0].pid;
6062 ioctl(2, TIOCSPGRP, (char *) &pgrp);
6064 status = waitforjob(jp);
6069 static int bgcmd(int argc, char **argv)
6074 jp = getjob(*++argv);
6075 if (jp->jobctl == 0)
6076 error("job not created under job control");
6078 } while (--argc > 1);
6083 static void restartjob(struct job *jp)
6085 struct procstat *ps;
6088 if (jp->state == JOBDONE)
6091 killpg(jp->ps[0].pid, SIGCONT);
6092 for (ps = jp->ps, i = jp->nprocs; --i >= 0; ps++) {
6093 if (WIFSTOPPED(ps->status)) {
6102 static void showjobs(int change);
6105 static int jobscmd(int argc, char **argv)
6113 * Print a list of jobs. If "change" is nonzero, only print jobs whose
6114 * statuses have changed since the last call to showjobs.
6116 * If the shell is interrupted in the process of creating a job, the
6117 * result may be a job structure containing zero processes. Such structures
6118 * will be freed here.
6121 static void showjobs(int change)
6127 struct procstat *ps;
6131 TRACE(("showjobs(%d) called\n", change));
6132 while (dowait(0, (struct job *) NULL) > 0);
6133 for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
6136 if (jp->nprocs == 0) {
6140 if (change && !jp->changed)
6142 procno = jp->nprocs;
6143 for (ps = jp->ps;; ps++) { /* for each process */
6145 snprintf(s, 64, "[%d] %ld ", jobno, (long) ps->pid);
6147 snprintf(s, 64, " %ld ", (long) ps->pid);
6151 if (ps->status == -1) {
6152 /* don't print anything */
6153 } else if (WIFEXITED(ps->status)) {
6154 snprintf(s, 64, "Exit %d", WEXITSTATUS(ps->status));
6156 #ifdef CONFIG_ASH_JOB_CONTROL
6157 if (WIFSTOPPED(ps->status))
6158 i = WSTOPSIG(ps->status);
6159 else /* WIFSIGNALED(ps->status) */
6161 i = WTERMSIG(ps->status);
6162 if ((i & 0x7F) < NSIG && sys_siglist[i & 0x7F])
6163 strcpy(s, sys_siglist[i & 0x7F]);
6165 snprintf(s, 64, "Signal %d", i & 0x7F);
6166 if (WCOREDUMP(ps->status))
6167 strcat(s, " (core dumped)");
6171 printf("%*c%s\n", 30 - col >= 0 ? 30 - col : 0, ' ', ps->cmd);
6176 if (jp->state == JOBDONE) {
6184 * Mark a job structure as unused.
6187 static void freejob(struct job *jp)
6189 const struct procstat *ps;
6193 for (i = jp->nprocs, ps = jp->ps; --i >= 0; ps++) {
6194 if (ps->cmd != nullstr)
6197 if (jp->ps != &jp->ps0)
6200 #ifdef CONFIG_ASH_JOB_CONTROL
6201 if (curjob == jp - jobtab + 1)
6209 static int waitcmd(int argc, char **argv)
6217 job = getjob(*++argv);
6221 for (;;) { /* loop until process terminated or stopped */
6224 status = job->ps[job->nprocs - 1].status;
6230 if (WIFEXITED(status))
6231 retval = WEXITSTATUS(status);
6232 #ifdef CONFIG_ASH_JOB_CONTROL
6233 else if (WIFSTOPPED(status))
6234 retval = WSTOPSIG(status) + 128;
6237 /* XXX: limits number of signals */
6238 retval = WTERMSIG(status) + 128;
6243 for (jp = jobtab;; jp++) {
6244 if (jp >= jobtab + njobs) { /* no running procs */
6247 if (jp->used && jp->state == 0)
6251 if (dowait(2, 0) < 0 && errno == EINTR) {
6260 * Convert a job name to a job structure.
6263 static struct job *getjob(const char *name)
6271 #ifdef CONFIG_ASH_JOB_CONTROL
6273 if ((jobno = curjob) == 0 || jobtab[jobno - 1].used == 0)
6274 error("No current job");
6275 return &jobtab[jobno - 1];
6277 error("No current job");
6279 } else if (name[0] == '%') {
6280 if (is_digit(name[1])) {
6281 jobno = number(name + 1);
6282 if (jobno > 0 && jobno <= njobs && jobtab[jobno - 1].used != 0)
6283 return &jobtab[jobno - 1];
6284 #ifdef CONFIG_ASH_JOB_CONTROL
6285 } else if (name[1] == '%' && name[2] == '\0') {
6289 struct job *found = NULL;
6291 for (jp = jobtab, i = njobs; --i >= 0; jp++) {
6292 if (jp->used && jp->nprocs > 0
6293 && prefix(name + 1, jp->ps[0].cmd)) {
6295 error("%s: ambiguous", name);
6302 } else if (is_number(name, &pid)) {
6303 for (jp = jobtab, i = njobs; --i >= 0; jp++) {
6304 if (jp->used && jp->nprocs > 0
6305 && jp->ps[jp->nprocs - 1].pid == pid)
6309 error("No such job: %s", name);
6316 * Return a new job structure,
6319 static struct job *makejob(const union node *node, int nprocs)
6324 for (i = njobs, jp = jobtab;; jp++) {
6328 jobtab = xmalloc(4 * sizeof jobtab[0]);
6330 jp = xmalloc((njobs + 4) * sizeof jobtab[0]);
6331 memcpy(jp, jobtab, njobs * sizeof jp[0]);
6332 /* Relocate `ps' pointers */
6333 for (i = 0; i < njobs; i++)
6334 if (jp[i].ps == &jobtab[i].ps0)
6335 jp[i].ps = &jp[i].ps0;
6339 jp = jobtab + njobs;
6340 for (i = 4; --i >= 0; jobtab[njobs++].used = 0);
6352 #ifdef CONFIG_ASH_JOB_CONTROL
6353 jp->jobctl = jobctl;
6356 jp->ps = xmalloc(nprocs * sizeof(struct procstat));
6361 TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long) node, nprocs,
6368 * Fork of a subshell. If we are doing job control, give the subshell its
6369 * own process group. Jp is a job structure that the job is to be added to.
6370 * N is the command that will be evaluated by the child. Both jp and n may
6371 * be NULL. The mode parameter can be one of the following:
6372 * FORK_FG - Fork off a foreground process.
6373 * FORK_BG - Fork off a background process.
6374 * FORK_NOJOB - Like FORK_FG, but don't give the process its own
6375 * process group even if job control is on.
6377 * When job control is turned off, background processes have their standard
6378 * input redirected to /dev/null (except for the second and later processes
6384 static int forkshell(struct job *jp, const union node *n, int mode)
6388 #ifdef CONFIG_ASH_JOB_CONTROL
6391 const char *devnull = _PATH_DEVNULL;
6392 const char *nullerr = "Can't open %s";
6394 TRACE(("forkshell(%%%d, 0x%lx, %d) called\n", jp - jobtab, (long) n,
6397 #if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__)
6403 TRACE(("Fork failed, errno=%d\n", errno));
6405 error("Cannot fork");
6412 TRACE(("Child shell %d\n", getpid()));
6413 wasroot = rootshell;
6418 #ifdef CONFIG_ASH_JOB_CONTROL
6419 jobctl = 0; /* do job control only in root shell */
6420 if (wasroot && mode != FORK_NOJOB && mflag) {
6421 if (jp == NULL || jp->nprocs == 0)
6424 pgrp = jp->ps[0].pid;
6426 if (mode == FORK_FG) {
6427 /*** this causes superfluous TIOCSPGRPS ***/
6428 if (tcsetpgrp(2, pgrp) < 0)
6429 error("tcsetpgrp failed, errno=%d", errno);
6433 } else if (mode == FORK_BG) {
6435 if (mode == FORK_BG) {
6439 if ((jp == NULL || jp->nprocs == 0) && !fd0_redirected_p()) {
6441 if (open(devnull, O_RDONLY) != 0)
6442 error(nullerr, devnull);
6445 for (i = njobs, p = jobtab; --i >= 0; p++)
6448 if (wasroot && iflag) {
6455 #ifdef CONFIG_ASH_JOB_CONTROL
6456 if (rootshell && mode != FORK_NOJOB && mflag) {
6457 if (jp == NULL || jp->nprocs == 0)
6460 pgrp = jp->ps[0].pid;
6464 if (mode == FORK_BG)
6465 backgndpid = pid; /* set $! */
6467 struct procstat *ps = &jp->ps[jp->nprocs++];
6472 if (iflag && rootshell && n)
6473 ps->cmd = commandtext(n);
6476 TRACE(("In parent shell: child = %d\n", pid));
6483 * Wait for job to finish.
6485 * Under job control we have the problem that while a child process is
6486 * running interrupts generated by the user are sent to the child but not
6487 * to the shell. This means that an infinite loop started by an inter-
6488 * active user may be hard to kill. With job control turned off, an
6489 * interactive user may place an interactive program inside a loop. If
6490 * the interactive program catches interrupts, the user doesn't want
6491 * these interrupts to also abort the loop. The approach we take here
6492 * is to have the shell ignore interrupt signals while waiting for a
6493 * forground process to terminate, and then send itself an interrupt
6494 * signal if the child process was terminated by an interrupt signal.
6495 * Unfortunately, some programs want to do a bit of cleanup and then
6496 * exit on interrupt; unless these processes terminate themselves by
6497 * sending a signal to themselves (instead of calling exit) they will
6498 * confuse this approach.
6501 static int waitforjob(struct job *jp)
6503 #ifdef CONFIG_ASH_JOB_CONTROL
6504 int mypgrp = getpgrp();
6510 TRACE(("waitforjob(%%%d) called\n", jp - jobtab + 1));
6511 while (jp->state == 0) {
6514 #ifdef CONFIG_ASH_JOB_CONTROL
6516 if (tcsetpgrp(2, mypgrp) < 0)
6517 error("tcsetpgrp failed, errno=%d\n", errno);
6519 if (jp->state == JOBSTOPPED)
6520 curjob = jp - jobtab + 1;
6522 status = jp->ps[jp->nprocs - 1].status;
6523 /* convert to 8 bits */
6524 if (WIFEXITED(status))
6525 st = WEXITSTATUS(status);
6526 #ifdef CONFIG_ASH_JOB_CONTROL
6527 else if (WIFSTOPPED(status))
6528 st = WSTOPSIG(status) + 128;
6531 st = WTERMSIG(status) + 128;
6532 #ifdef CONFIG_ASH_JOB_CONTROL
6535 * This is truly gross.
6536 * If we're doing job control, then we did a TIOCSPGRP which
6537 * caused us (the shell) to no longer be in the controlling
6538 * session -- so we wouldn't have seen any ^C/SIGINT. So, we
6539 * intuit from the subprocess exit status whether a SIGINT
6540 * occured, and if so interrupt ourselves. Yuck. - mycroft
6542 if (WIFSIGNALED(status) && WTERMSIG(status) == SIGINT)
6545 if (jp->state == JOBDONE)
6555 * Wait for a process to terminate.
6559 * Do a wait system call. If job control is compiled in, we accept
6560 * stopped processes. If block is zero, we return a value of zero
6561 * rather than blocking.
6563 * System V doesn't have a non-blocking wait system call. It does
6564 * have a SIGCLD signal that is sent to a process when one of it's
6565 * children dies. The obvious way to use SIGCLD would be to install
6566 * a handler for SIGCLD which simply bumped a counter when a SIGCLD
6567 * was received, and have waitproc bump another counter when it got
6568 * the status of a process. Waitproc would then know that a wait
6569 * system call would not block if the two counters were different.
6570 * This approach doesn't work because if a process has children that
6571 * have not been waited for, System V will send it a SIGCLD when it
6572 * installs a signal handler for SIGCLD. What this means is that when
6573 * a child exits, the shell will be sent SIGCLD signals continuously
6574 * until is runs out of stack space, unless it does a wait call before
6575 * restoring the signal handler. The code below takes advantage of
6576 * this (mis)feature by installing a signal handler for SIGCLD and
6577 * then checking to see whether it was called. If there are any
6578 * children to be waited for, it will be.
6582 static inline int waitproc(int block, int *status)
6587 #ifdef CONFIG_ASH_JOB_CONTROL
6593 return wait3(status, flags, (struct rusage *) NULL);
6596 static int dowait(int block, struct job *job)
6600 struct procstat *sp;
6602 struct job *thisjob;
6608 TRACE(("dowait(%d) called\n", block));
6610 pid = waitproc(block, &status);
6611 TRACE(("wait returns %d, status=%d\n", pid, status));
6612 } while (!(block & 2) && pid == -1 && errno == EINTR);
6617 for (jp = jobtab; jp < jobtab + njobs; jp++) {
6621 for (sp = jp->ps; sp < jp->ps + jp->nprocs; sp++) {
6624 if (sp->pid == pid) {
6625 TRACE(("Changing status of proc %d from 0x%x to 0x%x\n",
6626 pid, sp->status, status));
6627 sp->status = status;
6630 if (sp->status == -1)
6632 else if (WIFSTOPPED(sp->status))
6635 if (stopped) { /* stopped or done */
6636 int state = done ? JOBDONE : JOBSTOPPED;
6638 if (jp->state != state) {
6639 TRACE(("Job %d: changing state from %d to %d\n",
6640 jp - jobtab + 1, jp->state, state));
6642 #ifdef CONFIG_ASH_JOB_CONTROL
6643 if (done && curjob == jp - jobtab + 1)
6644 curjob = 0; /* no current job */
6651 if (!rootshell || !iflag || (job && thisjob == job)) {
6652 core = WCOREDUMP(status);
6653 #ifdef CONFIG_ASH_JOB_CONTROL
6654 if (WIFSTOPPED(status))
6655 sig = WSTOPSIG(status);
6658 if (WIFEXITED(status))
6661 sig = WTERMSIG(status);
6663 if (sig != 0 && sig != SIGINT && sig != SIGPIPE) {
6665 out2fmt("%d: ", pid);
6666 #ifdef CONFIG_ASH_JOB_CONTROL
6667 if (sig == SIGTSTP && rootshell && iflag)
6668 out2fmt("%%%ld ", (long) (job - jobtab + 1));
6670 if (sig < NSIG && sys_siglist[sig])
6671 out2str(sys_siglist[sig]);
6673 out2fmt("Signal %d", sig);
6675 out2str(" - core dumped");
6678 TRACE(("Not printing status: status=%d, sig=%d\n", status, sig));
6681 TRACE(("Not printing status, rootshell=%d, job=0x%x\n", rootshell,
6684 thisjob->changed = 1;
6693 * return 1 if there are stopped jobs, otherwise 0
6695 static int stoppedjobs(void)
6702 for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
6705 if (jp->state == JOBSTOPPED) {
6706 out2str("You have stopped jobs.\n");
6716 * Return a string identifying a command (to be printed by the
6720 static char *cmdnextc;
6721 static int cmdnleft;
6723 #define MAXCMDTEXT 200
6725 static void cmdputs(const char *s)
6736 while ((c = *p++) != '\0') {
6739 else if (c == CTLVAR) {
6744 } else if (c == '=' && subtype != 0) {
6745 *q++ = "}-+?="[(subtype & VSTYPE) - VSNORMAL];
6747 } else if (c == CTLENDVAR) {
6749 } else if (c == CTLBACKQ || c == CTLBACKQ + CTLQUOTE)
6750 cmdnleft++; /* ignore it */
6753 if (--cmdnleft <= 0) {
6763 #define CMDTXT_TABLE
6766 * To collect a lot of redundant code in cmdtxt() case statements, we
6767 * implement a mini language here. Each type of node struct has an
6768 * associated instruction sequence that operates on its members via
6769 * their offsets. The instruction are pack in unsigned chars with
6770 * format IIDDDDDE where the bits are
6771 * I : part of the instruction opcode, which are
6772 * 00 : member is a pointer to another node -- process it recursively
6773 * 40 : member is a pointer to a char string -- output it
6774 * 80 : output the string whose index is stored in the data field
6775 * CC : flag signaling that this case needs external processing
6776 * D : data - either the (shifted) index of a fixed string to output or
6777 * the actual offset of the member to operate on in the struct
6778 * (since we assume bit 0 is set, the offset is not shifted)
6779 * E : flag signaling end of instruction sequence
6781 * WARNING: In order to handle larger offsets for 64bit archs, this code
6782 * assumes that no offset can be an odd number and stores the
6783 * end-of-instructions flag in bit 0.
6786 #define CMDTXT_NOMORE 0x01 /* NOTE: no offset should be odd */
6787 #define CMDTXT_CHARPTR 0x40
6788 #define CMDTXT_STRING 0x80
6789 #define CMDTXT_SPECIAL 0xC0
6790 #define CMDTXT_OFFSETMASK 0x3E
6792 static const char *const cmdtxt_strings[] = {
6793 /* 0 1 2 3 4 5 6 7 */
6794 "; ", "(", ")", " && ", " || ", "if ", "; then ", "...",
6795 /* 8 9 10 11 12 13 */
6796 "while ", "; do ", "; done", "until ", "for ", " in ...",
6798 "case ", "???", "() ...", "<<..."
6801 static const char *const redir_strings[] = {
6802 ">", "<", "<>", ">>", ">|", ">&", "<&"
6805 static const unsigned char cmdtxt_ops[] = {
6806 #define CMDTXT_NSEMI 0
6807 offsetof(union node, nbinary.ch1),
6809 offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE,
6810 #define CMDTXT_NCMD (CMDTXT_NSEMI + 3)
6811 #define CMDTXT_NPIPE (CMDTXT_NCMD)
6812 #define CMDTXT_NCASE (CMDTXT_NCMD)
6813 #define CMDTXT_NTO (CMDTXT_NCMD)
6814 #define CMDTXT_NFROM (CMDTXT_NCMD)
6815 #define CMDTXT_NFROMTO (CMDTXT_NCMD)
6816 #define CMDTXT_NAPPEND (CMDTXT_NCMD)
6817 #define CMDTXT_NTOOV (CMDTXT_NCMD)
6818 #define CMDTXT_NTOFD (CMDTXT_NCMD)
6819 #define CMDTXT_NFROMFD (CMDTXT_NCMD)
6821 #define CMDTXT_NREDIR (CMDTXT_NPIPE + 1)
6822 #define CMDTXT_NBACKGND (CMDTXT_NREDIR)
6823 offsetof(union node, nredir.n) | CMDTXT_NOMORE,
6824 #define CMDTXT_NSUBSHELL (CMDTXT_NBACKGND + 1)
6825 (1 * 2) | CMDTXT_STRING,
6826 offsetof(union node, nredir.n),
6827 (2 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6828 #define CMDTXT_NAND (CMDTXT_NSUBSHELL + 3)
6829 offsetof(union node, nbinary.ch1),
6830 (3 * 2) | CMDTXT_STRING,
6831 offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE,
6832 #define CMDTXT_NOR (CMDTXT_NAND + 3)
6833 offsetof(union node, nbinary.ch1),
6834 (4 * 2) | CMDTXT_STRING,
6835 offsetof(union node, nbinary.ch2) | CMDTXT_NOMORE,
6836 #define CMDTXT_NIF (CMDTXT_NOR + 3)
6837 (5 * 2) | CMDTXT_STRING,
6838 offsetof(union node, nif.test),
6839 (6 * 2) | CMDTXT_STRING,
6840 offsetof(union node, nif.ifpart),
6841 (7 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6842 #define CMDTXT_NWHILE (CMDTXT_NIF + 5)
6843 (8 * 2) | CMDTXT_STRING,
6844 offsetof(union node, nbinary.ch1),
6845 (9 * 2) | CMDTXT_STRING,
6846 offsetof(union node, nbinary.ch2),
6847 (10 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6848 #define CMDTXT_NUNTIL (CMDTXT_NWHILE + 5)
6849 (11 * 2) | CMDTXT_STRING,
6850 offsetof(union node, nbinary.ch1),
6851 (9 * 2) | CMDTXT_STRING,
6852 offsetof(union node, nbinary.ch2),
6853 (10 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6854 #define CMDTXT_NFOR (CMDTXT_NUNTIL + 5)
6855 (12 * 2) | CMDTXT_STRING,
6856 offsetof(union node, nfor.var) | CMDTXT_CHARPTR,
6857 (13 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6858 #define CMDTXT_NCLIST (CMDTXT_NFOR + 3) /* TODO: IS THIS CORRECT??? */
6859 #define CMDTXT_NNOT (CMDTXT_NCLIST) /* TODO: IS THIS CORRECT??? */
6860 (15 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6861 #define CMDTXT_NDEFUN (CMDTXT_NCLIST + 1)
6862 offsetof(union node, narg.text) | CMDTXT_CHARPTR,
6863 (16 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6864 #define CMDTXT_NARG (CMDTXT_NDEFUN + 2)
6865 offsetof(union node, narg.text) | CMDTXT_CHARPTR | CMDTXT_NOMORE,
6866 #define CMDTXT_NHERE (CMDTXT_NARG + 1)
6867 #define CMDTXT_NXHERE (CMDTXT_NHERE)
6868 (17 * 2) | CMDTXT_STRING | CMDTXT_NOMORE,
6871 #if CMDTXT_NXHERE != 36
6872 #error CMDTXT_NXHERE
6875 static const unsigned char cmdtxt_ops_index[26] = {
6904 static void cmdtxt(const union node *n)
6911 p = cmdtxt_ops + (int) cmdtxt_ops_index[n->type];
6912 if ((*p & CMDTXT_SPECIAL) != CMDTXT_SPECIAL) { /* normal case */
6914 if (*p & CMDTXT_STRING) { /* output fixed string */
6915 cmdputs(cmdtxt_strings
6916 [((int) (*p & CMDTXT_OFFSETMASK) >> 1)]);
6918 const char *pf = ((const char *) n)
6919 + ((int) (*p & CMDTXT_OFFSETMASK));
6921 if (*p & CMDTXT_CHARPTR) { /* output dynamic string */
6922 cmdputs(*((const char **) pf));
6923 } else { /* output field */
6924 cmdtxt(*((const union node **) pf));
6927 } while (!(*p++ & CMDTXT_NOMORE));
6928 } else if (n->type == NCMD) {
6931 for (np = n->ncmd.args; np; np = np->narg.next) {
6936 for (np = n->ncmd.redirect; np; np = np->nfile.next) {
6940 } else if (n->type == NPIPE) {
6941 struct nodelist *lp;
6943 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
6948 } else if (n->type == NCASE) {
6949 cmdputs(cmdtxt_strings[14]);
6950 cmdputs(n->ncase.expr->narg.text);
6951 cmdputs(cmdtxt_strings[13]);
6953 #if (NTO != 16) || (NFROM != 17) || (NFROMTO != 18) || (NAPPEND != 19) || (NTOOV != 20) || (NTOFD != 21) || (NFROMFD != 22)
6954 #error Assumption violated regarding range and ordering of NTO ... NFROMFD!
6959 assert((n->type >= NTO) && (n->type <= NFROMFD));
6962 p = redir_strings[n->type - NTO];
6963 if (n->nfile.fd != ('>' == *p)) {
6964 s[0] = n->nfile.fd + '0';
6969 if (n->type >= NTOFD) {
6970 s[0] = n->ndup.dupfd + '0';
6974 cmdtxt(n->nfile.fname);
6978 #else /* CMDTXT_TABLE */
6979 static void cmdtxt(const union node *n)
6982 struct nodelist *lp;
6991 cmdtxt(n->nbinary.ch1);
6993 cmdtxt(n->nbinary.ch2);
6996 cmdtxt(n->nbinary.ch1);
6998 cmdtxt(n->nbinary.ch2);
7001 cmdtxt(n->nbinary.ch1);
7003 cmdtxt(n->nbinary.ch2);
7006 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
7014 cmdtxt(n->nredir.n);
7019 cmdtxt(n->nredir.n);
7023 cmdtxt(n->nif.test);
7025 cmdtxt(n->nif.ifpart);
7034 cmdtxt(n->nbinary.ch1);
7036 cmdtxt(n->nbinary.ch2);
7041 cmdputs(n->nfor.var);
7046 cmdputs(n->ncase.expr->narg.text);
7050 cmdputs(n->narg.text);
7054 for (np = n->ncmd.args; np; np = np->narg.next) {
7059 for (np = n->ncmd.redirect; np; np = np->nfile.next) {
7065 cmdputs(n->narg.text);
7096 if (n->nfile.fd != i) {
7097 s[0] = n->nfile.fd + '0';
7102 if (n->type == NTOFD || n->type == NFROMFD) {
7103 s[0] = n->ndup.dupfd + '0';
7107 cmdtxt(n->nfile.fname);
7119 #endif /* CMDTXT_TABLE */
7121 static char *commandtext(const union node *n)
7125 cmdnextc = name = xmalloc(MAXCMDTEXT);
7126 cmdnleft = MAXCMDTEXT - 4;
7133 #ifdef CONFIG_ASH_MAIL
7136 * Routines to check for mail.
7140 #define MAXMBOXES 10
7143 static int nmboxes; /* number of mailboxes */
7144 static time_t mailtime[MAXMBOXES]; /* times of mailboxes */
7149 * Print appropriate message(s) if mail has arrived. If the argument is
7150 * nozero, then the value of MAIL has changed, so we just update the
7154 static void chkmail(int silent)
7160 struct stackmark smark;
7167 setstackmark(&smark);
7168 mpath = mpathset()? mpathval() : mailval();
7169 for (i = 0; i < nmboxes; i++) {
7170 p = padvance(&mpath, nullstr);
7175 for (q = p; *q; q++);
7180 q[-1] = '\0'; /* delete trailing '/' */
7181 if (stat(p, &statb) < 0)
7183 if (statb.st_size > mailtime[i] && !silent) {
7184 out2fmt(snlfmt, pathopt ? pathopt : "you have mail");
7186 mailtime[i] = statb.st_size;
7189 popstackmark(&smark);
7192 #endif /* CONFIG_ASH_MAIL */
7197 static short profile_buf[16384];
7201 static int isloginsh = 0;
7203 static void read_profile(const char *);
7204 static void cmdloop(int);
7205 static void options(int);
7206 static void setoption(int, int);
7207 static void procargs(int, char **);
7211 * Main routine. We initialize things, parse the arguments, execute
7212 * profiles if we're a login shell, and then call cmdloop to execute
7213 * commands. The setjmp call sets up the location to jump to when an
7214 * exception occurs. When an exception occurs the variable "state"
7215 * is used to figure out how far we had gotten.
7218 int ash_main(int argc, char **argv)
7220 struct jmploc jmploc;
7221 struct stackmark smark;
7225 BLTINCMD = find_builtin("builtin");
7226 EXECCMD = find_builtin("exec");
7227 EVALCMD = find_builtin("eval");
7229 #ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
7235 monitor(4, etext, profile_buf, sizeof profile_buf, 50);
7237 #if defined(linux) || defined(__GNU__)
7238 signal(SIGCHLD, SIG_DFL);
7241 if (setjmp(jmploc.loc)) {
7244 * When a shell procedure is executed, we raise the
7245 * exception EXSHELLPROC to clean up before executing
7246 * the shell procedure.
7248 if (exception == EXSHELLPROC) {
7254 if (exception == EXEXEC) {
7255 exitstatus = exerrno;
7256 } else if (exception == EXERROR) {
7259 if (state == 0 || iflag == 0 || !rootshell)
7260 exitshell(exitstatus);
7263 if (exception == EXINT) {
7266 popstackmark(&smark);
7267 FORCEINTON; /* enable interrupts */
7270 else if (state == 2)
7272 else if (state == 3)
7280 trputs("Shell args: ");
7286 setstackmark(&smark);
7287 procargs(argc, argv);
7288 if (argv[0] && argv[0][0] == '-')
7292 read_profile("/etc/profile");
7295 read_profile(".profile");
7300 if (getuid() == geteuid() && getgid() == getegid()) {
7302 if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
7304 read_profile(shinit);
7311 if (sflag == 0 || minusc) {
7312 static const char sigs[] = {
7313 SIGINT, SIGQUIT, SIGHUP,
7320 #define SIGSSIZE ((sizeof(sigs)/sizeof(sigs[0])))
7323 for (i = 0; i < SIGSSIZE; i++)
7328 evalstring(minusc, 0);
7330 if (sflag || minusc == NULL) {
7331 state4: /* XXX ??? - why isn't this before the "if" statement */
7337 exitshell(exitstatus);
7343 * Read and execute commands. "Top" is nonzero for the top level command
7344 * loop; it turns on prompting if the shell is interactive.
7347 static void cmdloop(int top)
7350 struct stackmark smark;
7354 TRACE(("cmdloop(%d) called\n", top));
7355 setstackmark(&smark);
7363 #ifdef CONFIG_ASH_MAIL
7368 n = parsecmd(inter);
7369 /* showtree(n); DEBUG */
7371 if (!top || numeof >= 50)
7373 if (!stoppedjobs()) {
7376 out2str("\nUse \"exit\" to leave shell.\n");
7379 } else if (n != NULL && nflag == 0) {
7380 job_warning = (job_warning == 2) ? 1 : 0;
7384 popstackmark(&smark);
7385 setstackmark(&smark);
7386 if (evalskip == SKIPFILE) {
7391 popstackmark(&smark);
7397 * Read /etc/profile or .profile. Return on error.
7400 static void read_profile(const char *name)
7407 if ((fd = open(name, O_RDONLY)) >= 0)
7412 /* -q turns off -x and -v just when executing init files */
7413 /* Note: Might do a little redundant work, but reduces code size. */
7428 * Read a file containing shell functions.
7431 static void readcmdfile(const char *name)
7436 if ((fd = open(name, O_RDONLY)) >= 0)
7439 error("Can't open %s", name);
7448 * Take commands from a file. To be compatable we should do a path
7449 * search for the file, which is necessary to find sub-commands.
7452 static inline char *find_dot_file(char *mybasename)
7455 const char *path = pathval();
7458 /* don't try this for absolute or relative paths */
7459 if (strchr(mybasename, '/'))
7462 while ((fullname = padvance(&path, mybasename)) != NULL) {
7463 if ((stat(fullname, &statb) == 0) && S_ISREG(statb.st_mode)) {
7465 * Don't bother freeing here, since it will
7466 * be freed by the caller.
7470 stunalloc(fullname);
7473 /* not found in the PATH */
7474 error("%s: not found", mybasename);
7478 static int dotcmd(int argc, char **argv)
7481 volatile struct shparam saveparam;
7485 for (sp = cmdenviron; sp; sp = sp->next)
7486 setvareq(xstrdup(sp->text), VSTRFIXED | VTEXTFIXED);
7488 if (argc >= 2) { /* That's what SVR2 does */
7490 struct stackmark smark;
7492 setstackmark(&smark);
7493 fullname = find_dot_file(argv[1]);
7496 saveparam = shellparam;
7497 shellparam.malloc = 0;
7498 shellparam.nparam = argc - 2;
7499 shellparam.p = argv + 2;
7502 setinputfile(fullname, 1);
7503 commandname = fullname;
7508 freeparam(&shellparam);
7509 shellparam = saveparam;
7512 popstackmark(&smark);
7518 static int exitcmd(int argc, char **argv)
7523 exitstatus = number(argv[1]);
7525 exitstatus = oexitstatus;
7526 exitshell(exitstatus);
7530 static pointer stalloc(int nbytes)
7534 nbytes = ALIGN(nbytes);
7535 if (nbytes > stacknleft) {
7537 struct stack_block *sp;
7540 if (blocksize < MINSIZE)
7541 blocksize = MINSIZE;
7543 sp = xmalloc(sizeof(struct stack_block) - MINSIZE + blocksize);
7545 stacknxt = sp->space;
7546 stacknleft = blocksize;
7552 stacknleft -= nbytes;
7557 static void stunalloc(pointer p)
7560 if (p == NULL) { /*DEBUG */
7561 write(2, "stunalloc\n", 10);
7565 if (!(stacknxt >= (char *) p && (char *) p >= stackp->space)) {
7568 stacknleft += stacknxt - (char *) p;
7573 static void setstackmark(struct stackmark *mark)
7575 mark->stackp = stackp;
7576 mark->stacknxt = stacknxt;
7577 mark->stacknleft = stacknleft;
7578 mark->marknext = markp;
7583 static void popstackmark(struct stackmark *mark)
7585 struct stack_block *sp;
7588 markp = mark->marknext;
7589 while (stackp != mark->stackp) {
7594 stacknxt = mark->stacknxt;
7595 stacknleft = mark->stacknleft;
7601 * When the parser reads in a string, it wants to stick the string on the
7602 * stack and only adjust the stack pointer when it knows how big the
7603 * string is. Stackblock (defined in stack.h) returns a pointer to a block
7604 * of space on top of the stack and stackblocklen returns the length of
7605 * this block. Growstackblock will grow this space by at least one byte,
7606 * possibly moving it (like realloc). Grabstackblock actually allocates the
7607 * part of the block that has been used.
7610 static void growstackblock(void)
7613 int newlen = ALIGN(stacknleft * 2 + 100);
7614 char *oldspace = stacknxt;
7615 int oldlen = stacknleft;
7616 struct stack_block *sp;
7617 struct stack_block *oldstackp;
7619 if (stacknxt == stackp->space && stackp != &stackbase) {
7624 sp = xrealloc((pointer) sp,
7625 sizeof(struct stack_block) - MINSIZE + newlen);
7628 stacknxt = sp->space;
7629 stacknleft = newlen;
7631 /* Stack marks pointing to the start of the old block
7632 * must be relocated to point to the new block
7634 struct stackmark *xmark;
7637 while (xmark != NULL && xmark->stackp == oldstackp) {
7638 xmark->stackp = stackp;
7639 xmark->stacknxt = stacknxt;
7640 xmark->stacknleft = stacknleft;
7641 xmark = xmark->marknext;
7646 p = stalloc(newlen);
7647 memcpy(p, oldspace, oldlen);
7648 stacknxt = p; /* free the space */
7649 stacknleft += newlen; /* we just allocated */
7655 static inline void grabstackblock(int len)
7665 * The following routines are somewhat easier to use that the above.
7666 * The user declares a variable of type STACKSTR, which may be declared
7667 * to be a register. The macro STARTSTACKSTR initializes things. Then
7668 * the user uses the macro STPUTC to add characters to the string. In
7669 * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is
7670 * grown as necessary. When the user is done, she can just leave the
7671 * string there and refer to it using stackblock(). Or she can allocate
7672 * the space for it using grabstackstr(). If it is necessary to allow
7673 * someone else to use the stack temporarily and then continue to grow
7674 * the string, the user should use grabstack to allocate the space, and
7675 * then call ungrabstr(p) to return to the previous mode of operation.
7677 * USTPUTC is like STPUTC except that it doesn't check for overflow.
7678 * CHECKSTACKSPACE can be called before USTPUTC to ensure that there
7679 * is space for at least one character.
7683 static char *growstackstr(void)
7685 int len = stackblocksize();
7687 if (herefd >= 0 && len >= 1024) {
7688 xwrite(herefd, stackblock(), len);
7689 sstrnleft = len - 1;
7690 return stackblock();
7693 sstrnleft = stackblocksize() - len - 1;
7694 return stackblock() + len;
7699 * Called from CHECKSTRSPACE.
7702 static char *makestrspace(size_t newlen)
7704 int len = stackblocksize() - sstrnleft;
7708 sstrnleft = stackblocksize() - len;
7709 } while (sstrnleft < newlen);
7710 return stackblock() + len;
7715 static void ungrabstackstr(char *s, char *p)
7717 stacknleft += stacknxt - s;
7719 sstrnleft = stacknleft - (p - s);
7723 * Miscelaneous builtins.
7729 #if !defined(__GLIBC__) || __GLIBC__ == 2 && __GLIBC_MINOR__ < 1
7730 typedef long rlim_t;
7736 * The read builtin. The -e option causes backslashes to escape the
7737 * following character.
7739 * This uses unbuffered input, which may be avoidable in some cases.
7742 static int readcmd(int argc, char **argv)
7757 while ((i = nextopt("p:r")) != '\0') {
7763 if (prompt && isatty(0)) {
7764 out2str(prompt); /* read without cmdedit */
7767 if (*(ap = argptr) == NULL)
7769 if ((ifs = bltinlookup("IFS")) == NULL)
7776 if (read(0, &c, 1) != 1) {
7788 if (!rflag && c == '\\') {
7794 if (startword && *ifs == ' ' && strchr(ifs, c)) {
7798 if (backslash && c == '\\') {
7799 if (read(0, &c, 1) != 1) {
7804 } else if (ap[1] != NULL && strchr(ifs, c) != NULL) {
7806 setvar(*ap, stackblock(), 0);
7815 /* Remove trailing blanks */
7816 while (stackblock() <= --p && strchr(ifs, *p) != NULL)
7818 setvar(*ap, stackblock(), 0);
7819 while (*++ap != NULL)
7820 setvar(*ap, nullstr, 0);
7826 static int umaskcmd(int argc, char **argv)
7828 static const char permuser[3] = "ugo";
7829 static const char permmode[3] = "rwx";
7830 static const short int permmask[] = {
7831 S_IRUSR, S_IWUSR, S_IXUSR,
7832 S_IRGRP, S_IWGRP, S_IXGRP,
7833 S_IROTH, S_IWOTH, S_IXOTH
7839 int symbolic_mode = 0;
7841 while (nextopt("S") != '\0') {
7850 if ((ap = *argptr) == NULL) {
7851 if (symbolic_mode) {
7855 for (i = 0; i < 3; i++) {
7860 for (j = 0; j < 3; j++) {
7861 if ((mask & permmask[3 * i + j]) == 0) {
7870 printf("%.4o\n", mask);
7873 if (is_digit((unsigned char) *ap)) {
7876 if (*ap >= '8' || *ap < '0')
7877 error("Illegal number: %s", argv[1]);
7878 mask = (mask << 3) + (*ap - '0');
7879 } while (*++ap != '\0');
7882 mask = ~mask & 0777;
7883 if (!parse_mode(ap, &mask)) {
7884 error("Illegal mode: %s", ap);
7886 umask(~mask & 0777);
7895 * This code, originally by Doug Gwyn, Doug Kingston, Eric Gisin, and
7896 * Michael Rendell was ripped from pdksh 5.0.8 and hacked for use with
7897 * ash by J.T. Conklin.
7905 short factor; /* multiply by to get rlim_{cur,max} values */
7908 static const struct limits limits[] = {
7910 {"time(seconds)", RLIMIT_CPU, 1},
7913 {"file(blocks)", RLIMIT_FSIZE, 512},
7916 {"data(kbytes)", RLIMIT_DATA, 1024},
7919 {"stack(kbytes)", RLIMIT_STACK, 1024},
7922 {"coredump(blocks)", RLIMIT_CORE, 512},
7925 {"memory(kbytes)", RLIMIT_RSS, 1024},
7927 #ifdef RLIMIT_MEMLOCK
7928 {"locked memory(kbytes)", RLIMIT_MEMLOCK, 1024},
7931 {"process(processes)", RLIMIT_NPROC, 1},
7933 #ifdef RLIMIT_NOFILE
7934 {"nofiles(descriptors)", RLIMIT_NOFILE, 1},
7937 {"vmemory(kbytes)", RLIMIT_VMEM, 1024},
7940 {"swap(kbytes)", RLIMIT_SWAP, 1024},
7945 static int ulimitcmd(int argc, char **argv)
7947 static const char unlimited_string[] = "unlimited";
7950 enum { SOFT = 0x1, HARD = 0x2 } how = SOFT | HARD;
7951 const struct limits *l;
7954 struct rlimit limit;
7958 while ((optc = nextopt("HSa"
7977 #ifdef RLIMIT_MEMLOCK
7983 #ifdef RLIMIT_NOFILE
7995 } else if (optc == 'S') {
7997 } else if (optc == 'a') {
8004 for (l = limits; l->name; l++) {
8005 if (l->name[0] == what)
8007 if (l->name[1] == 'w' && what == 'w')
8011 set = *argptr ? 1 : 0;
8015 if (all || argptr[1])
8016 error("too many arguments");
8017 if (strcmp(p, unlimited_string) == 0)
8018 val = RLIM_INFINITY;
8022 while ((c = *p++) >= '0' && c <= '9') {
8023 val = (val * 10) + (long) (c - '0');
8024 if (val < (rlim_t) 0)
8028 error("bad number");
8034 for (l = limits; l->name; l++) {
8035 printf("%-20s ", l->name);
8036 getrlimit(l->cmd, &limit);
8039 val = limit.rlim_cur;
8040 else if (how & HARD)
8041 val = limit.rlim_max;
8043 if (val == RLIM_INFINITY)
8044 puts(unlimited_string);
8047 printf("%lld\n", (long long) val);
8060 getrlimit(l->cmd, &limit);
8062 limit.rlim_max = val;
8064 limit.rlim_cur = val;
8065 if (setrlimit(l->cmd, &limit) < 0)
8066 error("error setting limit (%m)");
8071 * prefix -- see if pfx is a prefix of string.
8074 static int prefix(char const *pfx, char const *string)
8077 if (*pfx++ != *string++)
8084 * Return true if s is a string of digits, and save munber in intptr
8088 static int is_number(const char *p, int *intptr)
8096 ret += digit_val(*p);
8098 } while (*p != '\0');
8105 * Convert a string of digits to an integer, printing an error message on
8109 static int number(const char *s)
8113 if (!is_number(s, &i))
8114 error("Illegal number: %s", s);
8119 * Produce a possibly single quoted string suitable as input to the shell.
8120 * The return string is allocated on the stack.
8123 static char *single_quote(const char *s)
8131 size_t len1, len1p, len2, len2p;
8133 len1 = strcspn(s, "'");
8134 len2 = strspn(s + len1, "'");
8136 len1p = len1 ? len1 + 2 : len1;
8137 len2p = len2 + ((len2 < 2) ? len2 : 2);
8139 CHECKSTRSPACE(len1p + len2p + 1, p);
8144 memcpy(p + 1, s, len1);
8152 memcpy(q + 1, s, len2);
8155 } else if (len2 == 1) {
8161 STADJUST(len1p + len2p, p);
8166 return grabstackstr(p);
8170 * Routine for dealing with parsed shell commands.
8174 static void sizenodelist(const struct nodelist *);
8175 static struct nodelist *copynodelist(const struct nodelist *);
8176 static char *nodesavestr(const char *);
8178 #define CALCSIZE_TABLE
8179 #define COPYNODE_TABLE
8180 #if defined(CALCSIZE_TABLE) || defined(COPYNODE_TABLE)
8182 * To collect a lot of redundant code in case statements for copynode()
8183 * and calcsize(), we implement a mini language here. Each type of node
8184 * struct has an associated instruction sequence that operates on its
8185 * members via their offsets. The instruction are pack in unsigned chars
8186 * with format IIDDDDDE where the bits are
8187 * I : part of the instruction opcode, which are
8188 * 00 : member is a pointer to another node
8189 * 40 : member is an integer
8190 * 80 : member is a pointer to a nodelist
8191 * CC : member is a pointer to a char string
8192 * D : data - the actual offset of the member to operate on in the struct
8193 * (since we assume bit 0 is set, it is not shifted)
8194 * E : flag signaling end of instruction sequence
8196 * WARNING: In order to handle larger offsets for 64bit archs, this code
8197 * assumes that no offset can be an odd number and stores the
8198 * end-of-instructions flag in bit 0.
8201 #define NODE_INTEGER 0x40
8202 #define NODE_NODELIST 0x80
8203 #define NODE_CHARPTR 0xC0
8204 #define NODE_NOMORE 0x01 /* Note: no offset should be odd (aligned) */
8205 #define NODE_MBRMASK 0xC0
8206 #define NODE_OFFSETMASK 0x3E
8208 static const unsigned char copynode_ops[35] = {
8209 #define COPYNODE_OPS0 0
8210 offsetof(union node, nbinary.ch2),
8211 offsetof(union node, nbinary.ch1) | NODE_NOMORE,
8212 #define COPYNODE_OPS1 (COPYNODE_OPS0 + 2)
8213 offsetof(union node, ncmd.redirect),
8214 offsetof(union node, ncmd.args),
8215 offsetof(union node, ncmd.assign),
8216 offsetof(union node, ncmd.backgnd) | NODE_INTEGER | NODE_NOMORE,
8217 #define COPYNODE_OPS2 (COPYNODE_OPS1 + 4)
8218 offsetof(union node, npipe.cmdlist) | NODE_NODELIST,
8219 offsetof(union node, npipe.backgnd) | NODE_INTEGER | NODE_NOMORE,
8220 #define COPYNODE_OPS3 (COPYNODE_OPS2 + 2)
8221 offsetof(union node, nredir.redirect),
8222 offsetof(union node, nredir.n) | NODE_NOMORE,
8223 #define COPYNODE_OPS4 (COPYNODE_OPS3 + 2)
8224 offsetof(union node, nif.elsepart),
8225 offsetof(union node, nif.ifpart),
8226 offsetof(union node, nif.test) | NODE_NOMORE,
8227 #define COPYNODE_OPS5 (COPYNODE_OPS4 + 3)
8228 offsetof(union node, nfor.var) | NODE_CHARPTR,
8229 offsetof(union node, nfor.body),
8230 offsetof(union node, nfor.args) | NODE_NOMORE,
8231 #define COPYNODE_OPS6 (COPYNODE_OPS5 + 3)
8232 offsetof(union node, ncase.cases),
8233 offsetof(union node, ncase.expr) | NODE_NOMORE,
8234 #define COPYNODE_OPS7 (COPYNODE_OPS6 + 2)
8235 offsetof(union node, nclist.body),
8236 offsetof(union node, nclist.pattern),
8237 offsetof(union node, nclist.next) | NODE_NOMORE,
8238 #define COPYNODE_OPS8 (COPYNODE_OPS7 + 3)
8239 offsetof(union node, narg.backquote) | NODE_NODELIST,
8240 offsetof(union node, narg.text) | NODE_CHARPTR,
8241 offsetof(union node, narg.next) | NODE_NOMORE,
8242 #define COPYNODE_OPS9 (COPYNODE_OPS8 + 3)
8243 offsetof(union node, nfile.fname),
8244 offsetof(union node, nfile.fd) | NODE_INTEGER,
8245 offsetof(union node, nfile.next) | NODE_NOMORE,
8246 #define COPYNODE_OPS10 (COPYNODE_OPS9 + 3)
8247 offsetof(union node, ndup.vname),
8248 offsetof(union node, ndup.dupfd) | NODE_INTEGER,
8249 offsetof(union node, ndup.fd) | NODE_INTEGER,
8250 offsetof(union node, ndup.next) | NODE_NOMORE,
8251 #define COPYNODE_OPS11 (COPYNODE_OPS10 + 4)
8252 offsetof(union node, nhere.doc),
8253 offsetof(union node, nhere.fd) | NODE_INTEGER,
8254 offsetof(union node, nhere.next) | NODE_NOMORE,
8255 #define COPYNODE_OPS12 (COPYNODE_OPS11 + 3)
8256 offsetof(union node, nnot.com) | NODE_NOMORE,
8259 #if COPYNODE_OPS12 != 34
8260 #error COPYNODE_OPS12 is incorrect
8263 static const unsigned char copynode_ops_index[26] = {
8264 COPYNODE_OPS0, /* NSEMI */
8265 COPYNODE_OPS1, /* NCMD */
8266 COPYNODE_OPS2, /* NPIPE */
8267 COPYNODE_OPS3, /* NREDIR */
8268 COPYNODE_OPS3, /* NBACKGND */
8269 COPYNODE_OPS3, /* NSUBSHELL */
8270 COPYNODE_OPS0, /* NAND */
8271 COPYNODE_OPS0, /* NOR */
8272 COPYNODE_OPS4, /* NIF */
8273 COPYNODE_OPS0, /* NWHILE */
8274 COPYNODE_OPS0, /* NUNTIL */
8275 COPYNODE_OPS5, /* NFOR */
8276 COPYNODE_OPS6, /* NCASE */
8277 COPYNODE_OPS7, /* NCLIST */
8278 COPYNODE_OPS8, /* NDEFUN */
8279 COPYNODE_OPS8, /* NARG */
8280 COPYNODE_OPS9, /* NTO */
8281 COPYNODE_OPS9, /* NFROM */
8282 COPYNODE_OPS9, /* NFROMTO */
8283 COPYNODE_OPS9, /* NAPPEND */
8284 COPYNODE_OPS9, /* NTOOV */
8285 COPYNODE_OPS10, /* NTOFD */
8286 COPYNODE_OPS10, /* NFROMFD */
8287 COPYNODE_OPS11, /* NHERE */
8288 COPYNODE_OPS11, /* NXHERE */
8289 COPYNODE_OPS12, /* NNOT */
8292 #if NODE_CHARPTR != NODE_MBRMASK
8293 #error NODE_CHARPTR != NODE_MBRMASK!!!
8295 #endif /* defined(CALCSIZE_TABLE) || defined(COPYNODE_TABLE) */
8297 #ifdef COPYNODE_TABLE
8298 static union node *copynode(const union node *n)
8301 const unsigned char *p;
8307 new->type = n->type;
8308 funcblock = (char *) funcblock + (int) nodesize[n->type];
8309 p = copynode_ops + (int) copynode_ops_index[n->type];
8311 char *nn = ((char *) new) + ((int) (*p & NODE_OFFSETMASK));
8312 const char *no = ((const char *) n) + ((int) (*p & NODE_OFFSETMASK));
8314 if (!(*p & NODE_MBRMASK)) { /* standard node */
8315 *((union node **) nn) = copynode(*((const union node **) no));
8316 } else if ((*p & NODE_MBRMASK) == NODE_CHARPTR) { /* string */
8317 *((const char **) nn) = nodesavestr(*((const char **) no));
8318 } else if (*p & NODE_NODELIST) { /* nodelist */
8319 *((struct nodelist **) nn)
8320 = copynodelist(*((const struct nodelist **) no));
8321 } else { /* integer */
8322 *((int *) nn) = *((int *) no);
8324 } while (!(*p++ & NODE_NOMORE));
8327 #else /* COPYNODE_TABLE */
8328 static union node *copynode(const union node *n)
8335 funcblock = (char *) funcblock + nodesize[n->type];
8342 new->nbinary.ch2 = copynode(n->nbinary.ch2);
8343 new->nbinary.ch1 = copynode(n->nbinary.ch1);
8346 new->ncmd.redirect = copynode(n->ncmd.redirect);
8347 new->ncmd.args = copynode(n->ncmd.args);
8348 new->ncmd.assign = copynode(n->ncmd.assign);
8349 new->ncmd.backgnd = n->ncmd.backgnd;
8352 new->npipe.cmdlist = copynodelist(n->npipe.cmdlist);
8353 new->npipe.backgnd = n->npipe.backgnd;
8358 new->nredir.redirect = copynode(n->nredir.redirect);
8359 new->nredir.n = copynode(n->nredir.n);
8362 new->nif.elsepart = copynode(n->nif.elsepart);
8363 new->nif.ifpart = copynode(n->nif.ifpart);
8364 new->nif.test = copynode(n->nif.test);
8367 new->nfor.var = nodesavestr(n->nfor.var);
8368 new->nfor.body = copynode(n->nfor.body);
8369 new->nfor.args = copynode(n->nfor.args);
8372 new->ncase.cases = copynode(n->ncase.cases);
8373 new->ncase.expr = copynode(n->ncase.expr);
8376 new->nclist.body = copynode(n->nclist.body);
8377 new->nclist.pattern = copynode(n->nclist.pattern);
8378 new->nclist.next = copynode(n->nclist.next);
8382 new->narg.backquote = copynodelist(n->narg.backquote);
8383 new->narg.text = nodesavestr(n->narg.text);
8384 new->narg.next = copynode(n->narg.next);
8391 new->nfile.fname = copynode(n->nfile.fname);
8392 new->nfile.fd = n->nfile.fd;
8393 new->nfile.next = copynode(n->nfile.next);
8397 new->ndup.vname = copynode(n->ndup.vname);
8398 new->ndup.dupfd = n->ndup.dupfd;
8399 new->ndup.fd = n->ndup.fd;
8400 new->ndup.next = copynode(n->ndup.next);
8404 new->nhere.doc = copynode(n->nhere.doc);
8405 new->nhere.fd = n->nhere.fd;
8406 new->nhere.next = copynode(n->nhere.next);
8409 new->nnot.com = copynode(n->nnot.com);
8412 new->type = n->type;
8415 #endif /* COPYNODE_TABLE */
8417 #ifdef CALCSIZE_TABLE
8418 static void calcsize(const union node *n)
8420 const unsigned char *p;
8424 funcblocksize += (int) nodesize[n->type];
8426 p = copynode_ops + (int) copynode_ops_index[n->type];
8428 const char *no = ((const char *) n) + ((int) (*p & NODE_OFFSETMASK));
8430 if (!(*p & NODE_MBRMASK)) { /* standard node */
8431 calcsize(*((const union node **) no));
8432 } else if ((*p & NODE_MBRMASK) == NODE_CHARPTR) { /* string */
8433 funcstringsize += strlen(*((const char **) no)) + 1;
8434 } else if (*p & NODE_NODELIST) { /* nodelist */
8435 sizenodelist(*((const struct nodelist **) no));
8436 } /* else integer -- ignore */
8437 } while (!(*p++ & NODE_NOMORE));
8439 #else /* CALCSIZE_TABLE */
8440 static void calcsize(const union node *n)
8444 funcblocksize += nodesize[n->type];
8451 calcsize(n->nbinary.ch2);
8452 calcsize(n->nbinary.ch1);
8455 calcsize(n->ncmd.redirect);
8456 calcsize(n->ncmd.args);
8457 calcsize(n->ncmd.assign);
8460 sizenodelist(n->npipe.cmdlist);
8465 calcsize(n->nredir.redirect);
8466 calcsize(n->nredir.n);
8469 calcsize(n->nif.elsepart);
8470 calcsize(n->nif.ifpart);
8471 calcsize(n->nif.test);
8474 funcstringsize += strlen(n->nfor.var) + 1;
8475 calcsize(n->nfor.body);
8476 calcsize(n->nfor.args);
8479 calcsize(n->ncase.cases);
8480 calcsize(n->ncase.expr);
8483 calcsize(n->nclist.body);
8484 calcsize(n->nclist.pattern);
8485 calcsize(n->nclist.next);
8489 sizenodelist(n->narg.backquote);
8490 funcstringsize += strlen(n->narg.text) + 1;
8491 calcsize(n->narg.next);
8498 calcsize(n->nfile.fname);
8499 calcsize(n->nfile.next);
8503 calcsize(n->ndup.vname);
8504 calcsize(n->ndup.next);
8508 calcsize(n->nhere.doc);
8509 calcsize(n->nhere.next);
8512 calcsize(n->nnot.com);
8516 #endif /* CALCSIZE_TABLE */
8518 static void sizenodelist(const struct nodelist *lp)
8521 funcblocksize += ALIGN(sizeof(struct nodelist));
8528 static struct nodelist *copynodelist(const struct nodelist *lp)
8530 struct nodelist *start;
8531 struct nodelist **lpp;
8536 funcblock = (char *) funcblock + ALIGN(sizeof(struct nodelist));
8537 (*lpp)->n = copynode(lp->n);
8539 lpp = &(*lpp)->next;
8546 static char *nodesavestr(const char *s)
8549 char *q = funcstring;
8550 char *rtn = funcstring;
8552 while ((*q++ = *p++) != '\0')
8558 #ifdef CONFIG_ASH_GETOPTS
8559 static int getopts(char *, char *, char **, int *, int *);
8563 * Process the shell command line arguments.
8566 static void procargs(int argc, char **argv)
8573 for (i = 0; i < NOPTS; i++)
8576 if (*argptr == NULL && minusc == NULL)
8578 if (iflag == 2 && sflag == 1 && isatty(0) && isatty(1))
8582 for (i = 0; i < NOPTS; i++)
8583 if (optent_val(i) == 2)
8586 if (sflag == 0 && minusc == NULL) {
8587 commandname = argv[0];
8589 setinputfile(arg0, 0);
8592 /* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
8593 if (argptr && minusc && *argptr)
8596 shellparam.p = argptr;
8597 shellparam.optind = 1;
8598 shellparam.optoff = -1;
8599 /* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
8601 shellparam.nparam++;
8610 * Process shell options. The global variable argptr contains a pointer
8611 * to the argument list; we advance it past the options.
8614 static inline void minus_o(const char *name, int val)
8619 out1str("Current option settings\n");
8620 for (i = 0; i < NOPTS; i++)
8621 printf("%-16s%s\n", optent_name(optlist[i]),
8622 optent_val(i) ? "on" : "off");
8624 for (i = 0; i < NOPTS; i++)
8625 if (equal(name, optent_name(optlist[i]))) {
8626 setoption(optent_letter(optlist[i]), val);
8629 error("Illegal option -o %s", name);
8634 static void options(int cmdline)
8642 while ((p = *argptr) != NULL) {
8644 if ((c = *p++) == '-') {
8646 if (p[0] == '\0' || (p[0] == '-' && p[1] == '\0')) {
8648 /* "-" means turn off -x and -v */
8651 /* "--" means reset params */
8652 else if (*argptr == NULL)
8655 break; /* "-" or "--" terminates options */
8657 } else if (c == '+') {
8663 while ((c = *p++) != '\0') {
8664 if (c == 'c' && cmdline) {
8667 #ifdef NOHACK /* removing this code allows sh -ce 'foo' for compat */
8671 if (q == NULL || minusc != NULL)
8672 error("Bad -c option");
8677 } else if (c == 'o') {
8678 minus_o(*argptr, val);
8681 } else if (cmdline && (c == '-')) { // long options
8682 if (strcmp(p, "login") == 0)
8693 static void setoption(int flag, int val)
8697 for (i = 0; i < NOPTS; i++)
8698 if (optent_letter(optlist[i]) == flag) {
8699 optent_val(i) = val;
8701 /* #%$ hack for ksh semantics */
8704 else if (flag == 'E')
8709 error("Illegal option -%c", flag);
8716 * Set the shell parameters.
8719 static void setparam(char **argv)
8725 for (nparam = 0; argv[nparam]; nparam++);
8726 ap = newparam = xmalloc((nparam + 1) * sizeof *ap);
8728 *ap++ = xstrdup(*argv++);
8731 freeparam(&shellparam);
8732 shellparam.malloc = 1;
8733 shellparam.nparam = nparam;
8734 shellparam.p = newparam;
8735 shellparam.optind = 1;
8736 shellparam.optoff = -1;
8741 * Free the list of positional parameters.
8744 static void freeparam(volatile struct shparam *param)
8748 if (param->malloc) {
8749 for (ap = param->p; *ap; ap++)
8758 * The shift builtin command.
8761 static int shiftcmd(int argc, char **argv)
8768 n = number(argv[1]);
8769 if (n > shellparam.nparam)
8770 error("can't shift that many");
8772 shellparam.nparam -= n;
8773 for (ap1 = shellparam.p; --n >= 0; ap1++) {
8774 if (shellparam.malloc)
8778 while ((*ap2++ = *ap1++) != NULL);
8779 shellparam.optind = 1;
8780 shellparam.optoff = -1;
8788 * The set command builtin.
8791 static int setcmd(int argc, char **argv)
8794 return showvarscmd(argc, argv);
8798 if (*argptr != NULL) {
8806 static void getoptsreset(const char *value)
8808 shellparam.optind = number(value);
8809 shellparam.optoff = -1;
8812 #ifdef CONFIG_LOCALE_SUPPORT
8813 static void change_lc_all(const char *value)
8815 if (value != 0 && *value != 0)
8816 setlocale(LC_ALL, value);
8819 static void change_lc_ctype(const char *value)
8821 if (value != 0 && *value != 0)
8822 setlocale(LC_CTYPE, value);
8827 #ifdef CONFIG_ASH_GETOPTS
8829 * The getopts builtin. Shellparam.optnext points to the next argument
8830 * to be processed. Shellparam.optptr points to the next character to
8831 * be processed in the current argument. If shellparam.optnext is NULL,
8832 * then it's the first time getopts has been called.
8835 static int getoptscmd(int argc, char **argv)
8840 error("Usage: getopts optstring var [arg]");
8841 else if (argc == 3) {
8842 optbase = shellparam.p;
8843 if (shellparam.optind > shellparam.nparam + 1) {
8844 shellparam.optind = 1;
8845 shellparam.optoff = -1;
8849 if (shellparam.optind > argc - 2) {
8850 shellparam.optind = 1;
8851 shellparam.optoff = -1;
8855 return getopts(argv[1], argv[2], optbase, &shellparam.optind,
8856 &shellparam.optoff);
8860 * Safe version of setvar, returns 1 on success 0 on failure.
8863 static int setvarsafe(const char *name, const char *val, int flags)
8865 struct jmploc jmploc;
8866 struct jmploc *volatile savehandler = handler;
8873 if (setjmp(jmploc.loc))
8877 setvar(name, val, flags);
8879 handler = savehandler;
8884 getopts(char *optstr, char *optvar, char **optfirst, int *myoptind,
8892 char **optnext = optfirst + *myoptind - 1;
8894 if (*myoptind <= 1 || *optoff < 0 || !(*(optnext - 1)) ||
8895 strlen(*(optnext - 1)) < *optoff)
8898 p = *(optnext - 1) + *optoff;
8899 if (p == NULL || *p == '\0') {
8900 /* Current word is done, advance */
8901 if (optnext == NULL)
8904 if (p == NULL || *p != '-' || *++p == '\0') {
8906 *myoptind = optnext - optfirst + 1;
8912 if (p[0] == '-' && p[1] == '\0') /* check for "--" */
8917 for (q = optstr; *q != c;) {
8919 if (optstr[0] == ':') {
8922 err |= setvarsafe("OPTARG", s, 0);
8924 out2fmt("Illegal option -%c\n", c);
8925 (void) unsetvar("OPTARG");
8935 if (*p == '\0' && (p = *optnext) == NULL) {
8936 if (optstr[0] == ':') {
8939 err |= setvarsafe("OPTARG", s, 0);
8942 out2fmt("No arg for -%c option\n", c);
8943 (void) unsetvar("OPTARG");
8951 setvarsafe("OPTARG", p, 0);
8954 setvarsafe("OPTARG", "", 0);
8955 *myoptind = optnext - optfirst + 1;
8962 *optoff = p ? p - *(optnext - 1) : -1;
8963 snprintf(s, sizeof(s), "%d", *myoptind);
8964 err |= setvarsafe("OPTIND", s, VNOFUNC);
8967 err |= setvarsafe(optvar, s, 0);
8978 * XXX - should get rid of. have all builtins use getopt(3). the
8979 * library getopt must have the BSD extension static variable "optreset"
8980 * otherwise it can't be used within the shell safely.
8982 * Standard option processing (a la getopt) for builtin routines. The
8983 * only argument that is passed to nextopt is the option string; the
8984 * other arguments are unnecessary. It return the character, or '\0' on
8988 static int nextopt(const char *optstring)
8994 if ((p = optptr) == NULL || *p == '\0') {
8996 if (p == NULL || *p != '-' || *++p == '\0')
8999 if (p[0] == '-' && p[1] == '\0') /* check for "--" */
9003 for (q = optstring; *q != c;) {
9005 error("Illegal option -%c", c);
9010 if (*p == '\0' && (p = *argptr++) == NULL)
9011 error("No arg for -%c option", c);
9019 static void flushall()
9027 static void out2fmt(const char *fmt, ...)
9032 vfprintf(stderr, fmt, ap);
9037 * Version of write which resumes after a signal is caught.
9040 static int xwrite(int fd, const char *buf, int nbytes)
9049 i = write(fd, buf, n);
9055 } else if (i == 0) {
9058 } else if (errno != EINTR) {
9066 * Shell command parser.
9069 #define EOFMARKLEN 79
9074 struct heredoc *next; /* next here document in list */
9075 union node *here; /* redirection node */
9076 char *eofmark; /* string indicating end of input */
9077 int striptabs; /* if set, strip leading tabs */
9080 static struct heredoc *heredoclist; /* list of here documents to read */
9081 static int parsebackquote; /* nonzero if we are inside backquotes */
9082 static int doprompt; /* if set, prompt the user */
9083 static int needprompt; /* true if interactive and at start of line */
9084 static int lasttoken; /* last token read */
9086 static char *wordtext; /* text of last word returned by readtoken */
9088 static struct nodelist *backquotelist;
9089 static union node *redirnode;
9090 static struct heredoc *heredoc;
9091 static int quoteflag; /* set if (part of) last token was quoted */
9092 static int startlinno; /* line # where last token started */
9095 static union node *list(int);
9096 static union node *andor(void);
9097 static union node *pipeline(void);
9098 static union node *command(void);
9099 static union node *simplecmd(union node **rpp, union node *redir);
9100 static void parsefname(void);
9101 static void parseheredoc(void);
9102 static char peektoken(void);
9103 static int readtoken(void);
9104 static int xxreadtoken(void);
9105 static int readtoken1(int, int, const char *, int);
9106 static int noexpand(char *);
9107 static void synexpect(int) __attribute__ ((noreturn));
9108 static void synerror(const char *) __attribute__ ((noreturn));
9109 static void setprompt(int);
9113 * Read and parse a command. Returns NEOF on end of file. (NULL is a
9114 * valid parse tree indicating a blank line.)
9117 static union node *parsecmd(int interact)
9122 doprompt = interact;
9138 static union node *list(int nlflag)
9140 union node *n1, *n2, *n3;
9144 if (nlflag == 0 && peektoken())
9150 if (tok == TBACKGND) {
9151 if (n2->type == NCMD || n2->type == NPIPE) {
9152 n2->ncmd.backgnd = 1;
9153 } else if (n2->type == NREDIR) {
9154 n2->type = NBACKGND;
9156 n3 = (union node *) stalloc(sizeof(struct nredir));
9157 n3->type = NBACKGND;
9159 n3->nredir.redirect = NULL;
9166 n3 = (union node *) stalloc(sizeof(struct nbinary));
9168 n3->nbinary.ch1 = n1;
9169 n3->nbinary.ch2 = n2;
9193 pungetc(); /* push back EOF on input */
9206 static union node *andor()
9208 union node *n1, *n2, *n3;
9214 if ((t = readtoken()) == TAND) {
9216 } else if (t == TOR) {
9224 n3 = (union node *) stalloc(sizeof(struct nbinary));
9226 n3->nbinary.ch1 = n1;
9227 n3->nbinary.ch2 = n2;
9234 static union node *pipeline()
9236 union node *n1, *n2, *pipenode;
9237 struct nodelist *lp, *prev;
9241 TRACE(("pipeline: entered\n"));
9242 if (readtoken() == TNOT) {
9248 if (readtoken() == TPIPE) {
9249 pipenode = (union node *) stalloc(sizeof(struct npipe));
9250 pipenode->type = NPIPE;
9251 pipenode->npipe.backgnd = 0;
9252 lp = (struct nodelist *) stalloc(sizeof(struct nodelist));
9253 pipenode->npipe.cmdlist = lp;
9257 lp = (struct nodelist *) stalloc(sizeof(struct nodelist));
9261 } while (readtoken() == TPIPE);
9267 n2 = (union node *) stalloc(sizeof(struct nnot));
9277 static union node *command(void)
9279 union node *n1, *n2;
9280 union node *ap, **app;
9281 union node *cp, **cpp;
9282 union node *redir, **rpp;
9289 /* Check for redirection which may precede command */
9290 while (readtoken() == TREDIR) {
9291 *rpp = n2 = redirnode;
9292 rpp = &n2->nfile.next;
9297 switch (readtoken()) {
9299 n1 = (union node *) stalloc(sizeof(struct nif));
9301 n1->nif.test = list(0);
9302 if (readtoken() != TTHEN)
9304 n1->nif.ifpart = list(0);
9306 while (readtoken() == TELIF) {
9307 n2->nif.elsepart = (union node *) stalloc(sizeof(struct nif));
9308 n2 = n2->nif.elsepart;
9310 n2->nif.test = list(0);
9311 if (readtoken() != TTHEN)
9313 n2->nif.ifpart = list(0);
9315 if (lasttoken == TELSE)
9316 n2->nif.elsepart = list(0);
9318 n2->nif.elsepart = NULL;
9321 if (readtoken() != TFI)
9328 n1 = (union node *) stalloc(sizeof(struct nbinary));
9329 n1->type = (lasttoken == TWHILE) ? NWHILE : NUNTIL;
9330 n1->nbinary.ch1 = list(0);
9331 if ((got = readtoken()) != TDO) {
9332 TRACE(("expecting DO got %s %s\n", tokname(got),
9333 got == TWORD ? wordtext : ""));
9336 n1->nbinary.ch2 = list(0);
9337 if (readtoken() != TDONE)
9343 if (readtoken() != TWORD || quoteflag || !goodname(wordtext))
9344 synerror("Bad for loop variable");
9345 n1 = (union node *) stalloc(sizeof(struct nfor));
9347 n1->nfor.var = wordtext;
9349 if (readtoken() == TIN) {
9351 while (readtoken() == TWORD) {
9352 n2 = (union node *) stalloc(sizeof(struct narg));
9354 n2->narg.text = wordtext;
9355 n2->narg.backquote = backquotelist;
9357 app = &n2->narg.next;
9361 if (lasttoken != TNL && lasttoken != TSEMI)
9364 static char argvars[5] = { CTLVAR, VSNORMAL | VSQUOTE,
9367 n2 = (union node *) stalloc(sizeof(struct narg));
9369 n2->narg.text = argvars;
9370 n2->narg.backquote = NULL;
9371 n2->narg.next = NULL;
9374 * Newline or semicolon here is optional (but note
9375 * that the original Bourne shell only allowed NL).
9377 if (lasttoken != TNL && lasttoken != TSEMI)
9381 if (readtoken() != TDO)
9383 n1->nfor.body = list(0);
9384 if (readtoken() != TDONE)
9389 n1 = (union node *) stalloc(sizeof(struct ncase));
9391 if (readtoken() != TWORD)
9393 n1->ncase.expr = n2 = (union node *) stalloc(sizeof(struct narg));
9395 n2->narg.text = wordtext;
9396 n2->narg.backquote = backquotelist;
9397 n2->narg.next = NULL;
9400 } while (readtoken() == TNL);
9401 if (lasttoken != TIN)
9402 synerror("expecting \"in\"");
9403 cpp = &n1->ncase.cases;
9404 checkkwd = 2, readtoken();
9406 if (lasttoken == TLP)
9408 *cpp = cp = (union node *) stalloc(sizeof(struct nclist));
9410 app = &cp->nclist.pattern;
9412 *app = ap = (union node *) stalloc(sizeof(struct narg));
9414 ap->narg.text = wordtext;
9415 ap->narg.backquote = backquotelist;
9416 if (checkkwd = 2, readtoken() != TPIPE)
9418 app = &ap->narg.next;
9421 ap->narg.next = NULL;
9422 if (lasttoken != TRP)
9424 cp->nclist.body = list(0);
9427 if ((t = readtoken()) != TESAC) {
9429 synexpect(TENDCASE);
9431 checkkwd = 2, readtoken();
9433 cpp = &cp->nclist.next;
9434 } while (lasttoken != TESAC);
9439 n1 = (union node *) stalloc(sizeof(struct nredir));
9440 n1->type = NSUBSHELL;
9441 n1->nredir.n = list(0);
9442 n1->nredir.redirect = NULL;
9443 if (readtoken() != TRP)
9449 if (readtoken() != TEND)
9453 /* Handle an empty command like other simple commands. */
9462 * An empty command before a ; doesn't make much sense, and
9463 * should certainly be disallowed in the case of `if ;'.
9469 n1 = simplecmd(rpp, redir);
9476 /* Now check for redirection which may follow command */
9477 while (readtoken() == TREDIR) {
9478 *rpp = n2 = redirnode;
9479 rpp = &n2->nfile.next;
9485 if (n1->type != NSUBSHELL) {
9486 n2 = (union node *) stalloc(sizeof(struct nredir));
9491 n1->nredir.redirect = redir;
9498 static union node *simplecmd(union node **rpp, union node *redir)
9500 union node *args, **app;
9501 union node *n = NULL;
9502 union node *vars, **vpp;
9503 union node **orig_rpp;
9510 /* If we don't have any redirections already, then we must reset
9511 rpp to be the address of the local redir variable. */
9514 /* We save the incoming value, because we need this for shell
9515 functions. There can not be a redirect or an argument between
9516 the function name and the open parenthesis. */
9521 switch (readtoken()) {
9524 n = (union node *) stalloc(sizeof(struct narg));
9526 n->narg.text = wordtext;
9527 n->narg.backquote = backquotelist;
9528 if (lasttoken == TWORD) {
9530 app = &n->narg.next;
9533 vpp = &n->narg.next;
9537 *rpp = n = redirnode;
9538 rpp = &n->nfile.next;
9539 parsefname(); /* read name of redirection file */
9542 if (args && app == &args->narg.next && !vars && rpp == orig_rpp) {
9543 /* We have a function */
9544 if (readtoken() != TRP)
9548 n->narg.next = command();
9561 n = (union node *) stalloc(sizeof(struct ncmd));
9563 n->ncmd.backgnd = 0;
9564 n->ncmd.args = args;
9565 n->ncmd.assign = vars;
9566 n->ncmd.redirect = redir;
9570 static union node *makename(void)
9574 n = (union node *) stalloc(sizeof(struct narg));
9576 n->narg.next = NULL;
9577 n->narg.text = wordtext;
9578 n->narg.backquote = backquotelist;
9582 static void fixredir(union node *n, const char *text, int err)
9584 TRACE(("Fix redir %s %d\n", text, err));
9586 n->ndup.vname = NULL;
9588 if (is_digit(text[0]) && text[1] == '\0')
9589 n->ndup.dupfd = digit_val(text[0]);
9590 else if (text[0] == '-' && text[1] == '\0')
9595 synerror("Bad fd number");
9597 n->ndup.vname = makename();
9602 static void parsefname(void)
9604 union node *n = redirnode;
9606 if (readtoken() != TWORD)
9608 if (n->type == NHERE) {
9609 struct heredoc *here = heredoc;
9615 TRACE(("Here document %d\n", n->type));
9616 if (here->striptabs) {
9617 while (*wordtext == '\t')
9620 if (!noexpand(wordtext) || (i = strlen(wordtext)) == 0
9622 synerror("Illegal eof marker for << redirection");
9623 rmescapes(wordtext);
9624 here->eofmark = wordtext;
9626 if (heredoclist == NULL)
9629 for (p = heredoclist; p->next; p = p->next);
9632 } else if (n->type == NTOFD || n->type == NFROMFD) {
9633 fixredir(n, wordtext, 0);
9635 n->nfile.fname = makename();
9641 * Input any here documents.
9644 static void parseheredoc()
9646 struct heredoc *here;
9649 while (heredoclist) {
9651 heredoclist = here->next;
9656 readtoken1(pgetc(), here->here->type == NHERE ? SQSYNTAX : DQSYNTAX,
9657 here->eofmark, here->striptabs);
9658 n = (union node *) stalloc(sizeof(struct narg));
9659 n->narg.type = NARG;
9660 n->narg.next = NULL;
9661 n->narg.text = wordtext;
9662 n->narg.backquote = backquotelist;
9663 here->here->nhere.doc = n;
9667 static char peektoken()
9673 return tokname_array[t][0];
9676 static int readtoken()
9680 int savecheckalias = checkalias;
9682 #ifdef CONFIG_ASH_ALIAS
9683 int savecheckkwd = checkkwd;
9688 int alreadyseen = tokpushback;
9691 #ifdef CONFIG_ASH_ALIAS
9697 checkalias = savecheckalias;
9703 if (checkkwd == 2) {
9712 * check for keywords
9714 if (t == TWORD && !quoteflag) {
9715 const char *const *pp;
9717 if ((pp = findkwd(wordtext))) {
9718 lasttoken = t = pp - tokname_array;
9719 TRACE(("keyword %s recognized\n", tokname(t)));
9730 } else if (checkalias == 2 && isassignment(wordtext)) {
9731 lasttoken = t = TASSIGN;
9732 } else if (checkalias) {
9733 #ifdef CONFIG_ASH_ALIAS
9734 if (!quoteflag && (ap = *__lookupalias(wordtext)) != NULL
9735 && !(ap->flag & ALIASINUSE)) {
9737 pushstring(ap->val, strlen(ap->val), ap);
9739 checkkwd = savecheckkwd;
9748 TRACE(("token %s %s\n", tokname(t), t == TWORD
9749 || t == TASSIGN ? wordtext : ""));
9751 TRACE(("reread token %s %s\n", tokname(t), t == TWORD
9752 || t == TASSIGN ? wordtext : ""));
9759 * Read the next input token.
9760 * If the token is a word, we set backquotelist to the list of cmds in
9761 * backquotes. We set quoteflag to true if any part of the word was
9763 * If the token is TREDIR, then we set redirnode to a structure containing
9765 * In all cases, the variable startlinno is set to the number of the line
9766 * on which the token starts.
9768 * [Change comment: here documents and internal procedures]
9769 * [Readtoken shouldn't have any arguments. Perhaps we should make the
9770 * word parsing code into a separate routine. In this case, readtoken
9771 * doesn't need to have any internal procedures, but parseword does.
9772 * We could also make parseoperator in essence the main routine, and
9773 * have parseword (readtoken1?) handle both words and redirection.]
9776 #define NEW_xxreadtoken
9777 #ifdef NEW_xxreadtoken
9779 static const char xxreadtoken_chars[] = "\n()&|;"; /* singles must be first! */
9780 static const char xxreadtoken_tokens[] = {
9781 TNL, TLP, TRP, /* only single occurrence allowed */
9782 TBACKGND, TPIPE, TSEMI, /* if single occurrence */
9783 TEOF, /* corresponds to trailing nul */
9784 TAND, TOR, TENDCASE, /* if double occurrence */
9787 #define xxreadtoken_doubles \
9788 (sizeof(xxreadtoken_tokens) - sizeof(xxreadtoken_chars))
9789 #define xxreadtoken_singles \
9790 (sizeof(xxreadtoken_chars) - xxreadtoken_doubles - 1)
9792 static int xxreadtoken()
9804 startlinno = plinno;
9805 for (;;) { /* until token or start of word found */
9808 if ((c != ' ') && (c != '\t')
9809 #ifdef CONFIG_ASH_ALIAS
9814 while ((c = pgetc()) != '\n' && c != PEOF);
9816 } else if (c == '\\') {
9817 if (pgetc() != '\n') {
9821 startlinno = ++plinno;
9822 setprompt(doprompt ? 2 : 0);
9825 = xxreadtoken_chars + sizeof(xxreadtoken_chars) - 1;
9830 needprompt = doprompt;
9833 p = strchr(xxreadtoken_chars, c);
9836 return readtoken1(c, BASESYNTAX, (char *) NULL, 0);
9839 if (p - xxreadtoken_chars >= xxreadtoken_singles) {
9840 if (pgetc() == *p) { /* double occurrence? */
9841 p += xxreadtoken_doubles + 1;
9848 return lasttoken = xxreadtoken_tokens[p - xxreadtoken_chars];
9856 #define RETURN(token) return lasttoken = token
9858 static int xxreadtoken()
9870 startlinno = plinno;
9871 for (;;) { /* until token or start of word found */
9876 #ifdef CONFIG_ASH_ALIAS
9881 while ((c = pgetc()) != '\n' && c != PEOF);
9885 if (pgetc() == '\n') {
9886 startlinno = ++plinno;
9897 needprompt = doprompt;
9925 return readtoken1(c, BASESYNTAX, (char *) NULL, 0);
9931 * If eofmark is NULL, read a word or a redirection symbol. If eofmark
9932 * is not NULL, read a here document. In the latter case, eofmark is the
9933 * word which marks the end of the document and striptabs is true if
9934 * leading tabs should be stripped from the document. The argument firstc
9935 * is the first character of the input token or document.
9937 * Because C does not have internal subroutines, I have simulated them
9938 * using goto's to implement the subroutine linkage. The following macros
9939 * will run code that appears at the end of readtoken1.
9942 #define CHECKEND() {goto checkend; checkend_return:;}
9943 #define PARSEREDIR() {goto parseredir; parseredir_return:;}
9944 #define PARSESUB() {goto parsesub; parsesub_return:;}
9945 #define PARSEBACKQOLD() {oldstyle = 1; goto parsebackq; parsebackq_oldreturn:;}
9946 #define PARSEBACKQNEW() {oldstyle = 0; goto parsebackq; parsebackq_newreturn:;}
9947 #define PARSEARITH() {goto parsearith; parsearith_return:;}
9950 readtoken1(int firstc, int syntax, const char *eofmark, int striptabs)
9955 char line[EOFMARKLEN + 1];
9956 struct nodelist *bqlist;
9959 int varnest; /* levels of variables expansion */
9960 int arinest; /* levels of arithmetic expansion */
9961 int parenlevel; /* levels of parens in arithmetic */
9962 int dqvarnest; /* levels of variables expansion within double quotes */
9964 int prevsyntax; /* syntax before arithmetic */
9967 /* Avoid longjmp clobbering */
9980 startlinno = plinno;
9982 if (syntax == DQSYNTAX)
9992 loop:{ /* for each line, until end of word */
9993 CHECKEND(); /* set c to PEOF if at end of here document */
9994 for (;;) { /* until end of line or end of word */
9995 CHECKSTRSPACE(3, out); /* permit 3 calls to USTPUTC */
9996 switch (SIT(c, syntax)) {
9997 case CNL: /* '\n' */
9998 if (syntax == BASESYNTAX)
9999 goto endword; /* exit outer loop */
10007 goto loop; /* continue outer loop */
10012 if ((eofmark == NULL || dblquote) && dqvarnest == 0)
10013 USTPUTC(CTLESC, out);
10016 case CBACK: /* backslash */
10019 USTPUTC('\\', out);
10021 } else if (c == '\n') {
10027 if (dblquote && c != '\\' && c != '`' && c != '$'
10028 && (c != '"' || eofmark != NULL))
10029 USTPUTC('\\', out);
10030 if (SIT(c, SQSYNTAX) == CCTL)
10031 USTPUTC(CTLESC, out);
10032 else if (eofmark == NULL)
10033 USTPUTC(CTLQUOTEMARK, out);
10039 if (eofmark == NULL)
10040 USTPUTC(CTLQUOTEMARK, out);
10044 if (eofmark == NULL)
10045 USTPUTC(CTLQUOTEMARK, out);
10050 if (eofmark != NULL && arinest == 0 && varnest == 0) {
10054 syntax = ARISYNTAX;
10056 } else if (eofmark == NULL && dqvarnest == 0) {
10057 syntax = BASESYNTAX;
10063 case CVAR: /* '$' */
10064 PARSESUB(); /* parse substitution */
10066 case CENDVAR: /* '}' */
10069 if (dqvarnest > 0) {
10072 USTPUTC(CTLENDVAR, out);
10077 #ifdef CONFIG_ASH_MATH_SUPPORT
10078 case CLP: /* '(' in arithmetic */
10082 case CRP: /* ')' in arithmetic */
10083 if (parenlevel > 0) {
10087 if (pgetc() == ')') {
10088 if (--arinest == 0) {
10089 USTPUTC(CTLENDARI, out);
10090 syntax = prevsyntax;
10091 if (syntax == DQSYNTAX)
10099 * unbalanced parens
10100 * (don't 2nd guess - no error)
10108 case CBQUOTE: /* '`' */
10112 goto endword; /* exit outer loop */
10117 goto endword; /* exit outer loop */
10118 #ifdef CONFIG_ASH_ALIAS
10128 if (syntax == ARISYNTAX)
10129 synerror("Missing '))'");
10130 if (syntax != BASESYNTAX && !parsebackquote && eofmark == NULL)
10131 synerror("Unterminated quoted string");
10132 if (varnest != 0) {
10133 startlinno = plinno;
10134 synerror("Missing '}'");
10136 USTPUTC('\0', out);
10137 len = out - stackblock();
10138 out = stackblock();
10139 if (eofmark == NULL) {
10140 if ((c == '>' || c == '<')
10141 && quotef == 0 && len <= 2 && (*out == '\0' || is_digit(*out))) {
10143 return lasttoken = TREDIR;
10148 quoteflag = quotef;
10149 backquotelist = bqlist;
10150 grabstackblock(len);
10152 return lasttoken = TWORD;
10153 /* end of readtoken routine */
10158 * Check to see whether we are at the end of the here document. When this
10159 * is called, c is set to the first character of the next input line. If
10160 * we are at the end of the here document, this routine sets the c to PEOF.
10165 #ifdef CONFIG_ASH_ALIAS
10171 while (c == '\t') {
10175 if (c == *eofmark) {
10176 if (pfgets(line, sizeof line) != NULL) {
10180 for (q = eofmark + 1; *q && *p == *q; p++, q++);
10181 if (*p == '\n' && *q == '\0') {
10184 needprompt = doprompt;
10186 pushstring(line, strlen(line), NULL);
10191 goto checkend_return;
10196 * Parse a redirection operator. The variable "out" points to a string
10197 * specifying the fd to be redirected. The variable "c" contains the
10198 * first character of the redirection operator.
10205 np = (union node *) stalloc(sizeof(struct nfile));
10210 np->type = NAPPEND;
10219 } else { /* c == '<' */
10221 switch (c = pgetc()) {
10223 if (sizeof(struct nfile) != sizeof(struct nhere)) {
10224 np = (union node *) stalloc(sizeof(struct nhere));
10228 heredoc = (struct heredoc *) stalloc(sizeof(struct heredoc));
10229 heredoc->here = np;
10230 if ((c = pgetc()) == '-') {
10231 heredoc->striptabs = 1;
10233 heredoc->striptabs = 0;
10239 np->type = NFROMFD;
10243 np->type = NFROMTO;
10253 np->nfile.fd = digit_val(fd);
10255 goto parseredir_return;
10260 * Parse a substitution. At this point, we have read the dollar sign
10261 * and nothing else.
10269 static const char types[] = "}-+?=";
10273 (c != '(' && c != '{' && !is_name(c) && !is_special(c))
10277 } else if (c == '(') { /* $(command) or $((arith)) */
10278 if (pgetc() == '(') {
10285 USTPUTC(CTLVAR, out);
10286 typeloc = out - stackblock();
10287 USTPUTC(VSNORMAL, out);
10288 subtype = VSNORMAL;
10292 if ((c = pgetc()) == '}')
10295 subtype = VSLENGTH;
10299 if (c > PEOA && is_name(c)) {
10303 } while (c > PEOA && is_in_name(c));
10304 } else if (is_digit(c)) {
10308 } while (is_digit(c));
10309 } else if (is_special(c)) {
10313 badsub:synerror("Bad substitution");
10317 if (subtype == 0) {
10322 /*FALLTHROUGH*/ default:
10323 p = strchr(types, c);
10326 subtype = p - types + VSNORMAL;
10333 subtype = c == '#' ? VSTRIMLEFT : VSTRIMRIGHT;
10345 if (dblquote || arinest)
10347 *(stackblock() + typeloc) = subtype | flags;
10348 if (subtype != VSNORMAL) {
10355 goto parsesub_return;
10360 * Called to parse command substitutions. Newstyle is set if the command
10361 * is enclosed inside $(...); nlpp is a pointer to the head of the linked
10362 * list of commands (passed by reference), and savelen is the number of
10363 * characters on the top of the stack which must be preserved.
10367 struct nodelist **nlpp;
10370 char *volatile str;
10371 struct jmploc jmploc;
10372 struct jmploc *volatile savehandler;
10377 (void) &saveprompt;
10380 savepbq = parsebackquote;
10381 if (setjmp(jmploc.loc)) {
10383 parsebackquote = 0;
10384 handler = savehandler;
10385 longjmp(handler->loc, 1);
10389 savelen = out - stackblock();
10391 str = xmalloc(savelen);
10392 memcpy(str, stackblock(), savelen);
10394 savehandler = handler;
10398 /* We must read until the closing backquote, giving special
10399 treatment to some slashes, and then push the string and
10400 reread it as input, interpreting it normally. */
10407 STARTSTACKSTR(pout);
10413 switch (pc = pgetc()) {
10418 if ((pc = pgetc()) == '\n') {
10425 * If eating a newline, avoid putting
10426 * the newline into the new character
10427 * stream (via the STPUTC after the
10432 if (pc != '\\' && pc != '`' && pc != '$'
10433 && (!dblquote || pc != '"'))
10434 STPUTC('\\', pout);
10441 #ifdef CONFIG_ASH_ALIAS
10444 startlinno = plinno;
10445 synerror("EOF in backquote substitution");
10449 needprompt = doprompt;
10458 STPUTC('\0', pout);
10459 psavelen = pout - stackblock();
10460 if (psavelen > 0) {
10461 pstr = grabstackstr(pout);
10462 setinputstring(pstr);
10467 nlpp = &(*nlpp)->next;
10468 *nlpp = (struct nodelist *) stalloc(sizeof(struct nodelist));
10469 (*nlpp)->next = NULL;
10470 parsebackquote = oldstyle;
10473 saveprompt = doprompt;
10480 doprompt = saveprompt;
10482 if (readtoken() != TRP)
10489 * Start reading from old file again, ignoring any pushed back
10490 * tokens left from the backquote parsing
10495 while (stackblocksize() <= savelen)
10497 STARTSTACKSTR(out);
10499 memcpy(out, str, savelen);
10500 STADJUST(savelen, out);
10506 parsebackquote = savepbq;
10507 handler = savehandler;
10508 if (arinest || dblquote)
10509 USTPUTC(CTLBACKQ | CTLQUOTE, out);
10511 USTPUTC(CTLBACKQ, out);
10513 goto parsebackq_oldreturn;
10515 goto parsebackq_newreturn;
10519 * Parse an arithmetic expansion (indicate start of one and set state)
10523 if (++arinest == 1) {
10524 prevsyntax = syntax;
10525 syntax = ARISYNTAX;
10526 USTPUTC(CTLARI, out);
10533 * we collapse embedded arithmetic expansion to
10534 * parenthesis, which should be equivalent
10538 goto parsearith_return;
10541 } /* end of readtoken */
10545 * Returns true if the text contains nothing to expand (no dollar signs
10549 static int noexpand(char *text)
10555 while ((c = *p++) != '\0') {
10556 if (c == CTLQUOTEMARK)
10560 else if (SIT(c, BASESYNTAX) == CCTL)
10568 * Return true if the argument is a legal variable name (a letter or
10569 * underscore followed by zero or more letters, underscores, and digits).
10572 static int goodname(const char *name)
10580 if (!is_in_name(*p))
10588 * Called when an unexpected token is read during the parse. The argument
10589 * is the token that is expected, or -1 if more than one type of token can
10590 * occur at this point.
10593 static void synexpect(int token)
10598 l = sprintf(msg, "%s unexpected", tokname(lasttoken));
10600 sprintf(msg + l, " (expecting %s)", tokname(token));
10606 static void synerror(const char *msg)
10609 out2fmt("%s: %d: ", commandname, startlinno);
10610 out2fmt("Syntax error: %s\n", msg);
10611 error((char *) NULL);
10617 * called by editline -- any expansions to the prompt
10618 * should be added here.
10620 static void setprompt(int whichprompt)
10624 switch (whichprompt) {
10639 * Code for dealing with input/output redirection.
10642 #define EMPTY -2 /* marks an unused slot in redirtab */
10644 # define PIPESIZE 4096 /* amount of buffering in a pipe */
10646 # define PIPESIZE PIPE_BUF
10651 * Open a file in noclobber mode.
10652 * The code was copied from bash.
10654 static inline int noclobberopen(const char *fname)
10657 struct stat finfo, finfo2;
10660 * If the file exists and is a regular file, return an error
10663 r = stat(fname, &finfo);
10664 if (r == 0 && S_ISREG(finfo.st_mode)) {
10670 * If the file was not present (r != 0), make sure we open it
10671 * exclusively so that if it is created before we open it, our open
10672 * will fail. Make sure that we do not truncate an existing file.
10673 * Note that we don't turn on O_EXCL unless the stat failed -- if the
10674 * file was not a regular file, we leave O_EXCL off.
10677 return open(fname, O_WRONLY | O_CREAT | O_EXCL, 0666);
10678 fd = open(fname, O_WRONLY | O_CREAT, 0666);
10680 /* If the open failed, return the file descriptor right away. */
10685 * OK, the open succeeded, but the file may have been changed from a
10686 * non-regular file to a regular file between the stat and the open.
10687 * We are assuming that the O_EXCL open handles the case where FILENAME
10688 * did not exist and is symlinked to an existing file between the stat
10693 * If we can open it and fstat the file descriptor, and neither check
10694 * revealed that it was a regular file, and the file has not been
10695 * replaced, return the file descriptor.
10697 if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode) &&
10698 finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino)
10701 /* The file has been replaced. badness. */
10708 * Handle here documents. Normally we fork off a process to write the
10709 * data to a pipe. If the document is short, we can stuff the data in
10710 * the pipe without forking.
10713 static inline int openhere(const union node *redir)
10719 error("Pipe call failed");
10720 if (redir->type == NHERE) {
10721 len = strlen(redir->nhere.doc->narg.text);
10722 if (len <= PIPESIZE) {
10723 xwrite(pip[1], redir->nhere.doc->narg.text, len);
10727 if (forkshell((struct job *) NULL, (union node *) NULL, FORK_NOJOB) == 0) {
10729 signal(SIGINT, SIG_IGN);
10730 signal(SIGQUIT, SIG_IGN);
10731 signal(SIGHUP, SIG_IGN);
10733 signal(SIGTSTP, SIG_IGN);
10735 signal(SIGPIPE, SIG_DFL);
10736 if (redir->type == NHERE)
10737 xwrite(pip[1], redir->nhere.doc->narg.text, len);
10739 expandhere(redir->nhere.doc, pip[1]);
10748 static inline int openredirect(const union node *redir)
10753 switch (redir->nfile.type) {
10755 fname = redir->nfile.expfname;
10756 if ((f = open(fname, O_RDONLY)) < 0)
10760 fname = redir->nfile.expfname;
10761 if ((f = open(fname, O_RDWR | O_CREAT | O_TRUNC, 0666)) < 0)
10765 /* Take care of noclobber mode. */
10767 fname = redir->nfile.expfname;
10768 if ((f = noclobberopen(fname)) < 0)
10773 fname = redir->nfile.expfname;
10775 if ((f = open(fname, O_WRONLY | O_CREAT | O_TRUNC, 0666)) < 0)
10778 if ((f = creat(fname, 0666)) < 0)
10783 fname = redir->nfile.expfname;
10785 if ((f = open(fname, O_WRONLY | O_CREAT | O_APPEND, 0666)) < 0)
10788 if ((f = open(fname, O_WRONLY)) < 0 && (f = creat(fname, 0666)) < 0)
10790 lseek(f, (off_t) 0, 2);
10797 /* Fall through to eliminate warning. */
10804 f = openhere(redir);
10810 error("cannot create %s: %s", fname, errmsg(errno, E_CREAT));
10812 error("cannot open %s: %s", fname, errmsg(errno, E_OPEN));
10817 * Process a list of redirection commands. If the REDIR_PUSH flag is set,
10818 * old file descriptors are stashed away so that the redirection can be
10819 * undone by calling popredir. If the REDIR_BACKQ flag is set, then the
10820 * standard output, and the standard error if it becomes a duplicate of
10824 static void redirect(union node *redir, int flags)
10827 struct redirtab *sv = NULL;
10832 int fd1dup = flags & REDIR_BACKQ;; /* stdout `cmd` redir to pipe */
10834 TRACE(("redirect(%s) called\n",
10835 flags & REDIR_PUSH ? "REDIR_PUSH" : "NO_REDIR_PUSH"));
10836 if (flags & REDIR_PUSH) {
10837 sv = xmalloc(sizeof(struct redirtab));
10838 for (i = 0; i < 10; i++)
10839 sv->renamed[i] = EMPTY;
10840 sv->next = redirlist;
10843 for (n = redir; n; n = n->nfile.next) {
10846 if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD) &&
10847 n->ndup.dupfd == fd)
10848 continue; /* redirect from/to same file descriptor */
10851 newfd = openredirect(n);
10852 if ((flags & REDIR_PUSH) && sv->renamed[fd] == EMPTY) {
10855 } else if ((i = fcntl(fd, F_DUPFD, 10)) == -1) {
10859 dupredirect(n, newfd, fd1dup);
10869 error("%d: %m", fd);
10875 if (flags & REDIR_PUSH) {
10876 sv->renamed[fd] = i;
10879 } else if (fd != newfd) {
10885 dupredirect(n, newfd, fd1dup);
10891 static void dupredirect(const union node *redir, int f, int fd1dup)
10893 int fd = redir->nfile.fd;
10897 if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) {
10898 if (redir->ndup.dupfd >= 0) { /* if not ">&-" */
10899 if (redir->ndup.dupfd != 1 || fd1dup != 1)
10900 dup_as_newfd(redir->ndup.dupfd, fd);
10906 dup_as_newfd(f, fd);
10915 * Undo the effects of the last redirection.
10918 static void popredir(void)
10920 struct redirtab *rp = redirlist;
10924 for (i = 0; i < 10; i++) {
10925 if (rp->renamed[i] != EMPTY) {
10929 if (rp->renamed[i] >= 0) {
10930 dup_as_newfd(rp->renamed[i], i);
10931 close(rp->renamed[i]);
10935 redirlist = rp->next;
10941 * Discard all saved file descriptors.
10944 static void clearredir(void)
10946 struct redirtab *rp;
10949 for (rp = redirlist; rp; rp = rp->next) {
10950 for (i = 0; i < 10; i++) {
10951 if (rp->renamed[i] >= 0) {
10952 close(rp->renamed[i]);
10954 rp->renamed[i] = EMPTY;
10961 * Copy a file descriptor to be >= to. Returns -1
10962 * if the source file descriptor is closed, EMPTY if there are no unused
10963 * file descriptors left.
10966 static int dup_as_newfd(int from, int to)
10970 newfd = fcntl(from, F_DUPFD, to);
10972 if (errno == EMFILE)
10975 error("%d: %m", from);
10985 static void shtree(union node *, int, char *, FILE *);
10986 static void shcmd(union node *, FILE *);
10987 static void sharg(union node *, FILE *);
10988 static void indent(int, char *, FILE *);
10989 static void trstring(char *);
10993 static void showtree(node * n)
10995 trputs("showtree called\n");
10996 shtree(n, 1, NULL, stdout);
11000 static void shtree(union node *n, int ind, char *pfx, FILE * fp)
11002 struct nodelist *lp;
11008 indent(ind, pfx, fp);
11019 shtree(n->nbinary.ch1, ind, NULL, fp);
11022 shtree(n->nbinary.ch2, ind, NULL, fp);
11030 for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
11035 if (n->npipe.backgnd)
11041 fprintf(fp, "<node type %d>", n->type);
11049 static void shcmd(union node *cmd, FILE * fp)
11057 for (np = cmd->ncmd.args; np; np = np->narg.next) {
11063 for (np = cmd->ncmd.redirect; np; np = np->nfile.next) {
11069 if ((np->nfile.type <= NFROMFD) && (np->nfile.type >= NTO)) {
11070 s = redir_strings[np->nfile.type - NTO];
11076 switch (np->nfile.type) {
11111 if (np->nfile.fd != dftfd)
11112 fprintf(fp, "%d", np->nfile.fd);
11114 if (np->nfile.type == NTOFD || np->nfile.type == NFROMFD) {
11115 fprintf(fp, "%d", np->ndup.dupfd);
11117 sharg(np->nfile.fname, fp);
11124 static void sharg(union node *arg, FILE * fp)
11127 struct nodelist *bqlist;
11130 if (arg->type != NARG) {
11131 printf("<node type %d>\n", arg->type);
11135 bqlist = arg->narg.backquote;
11136 for (p = arg->narg.text; *p; p++) {
11145 if (subtype == VSLENGTH)
11151 if (subtype & VSNUL)
11154 switch (subtype & VSTYPE) {
11173 case VSTRIMLEFTMAX:
11180 case VSTRIMRIGHTMAX:
11187 printf("<subtype %d>", subtype);
11194 case CTLBACKQ | CTLQUOTE:
11197 shtree(bqlist->n, -1, NULL, fp);
11208 static void indent(int amount, char *pfx, FILE * fp)
11212 for (i = 0; i < amount; i++) {
11213 if (pfx && i == amount - 1)
11222 static int debug = 1;
11224 static int debug = 0;
11228 static void trputc(int c)
11230 if (tracefile == NULL)
11232 putc(c, tracefile);
11237 static void trace(const char *fmt, ...)
11242 if (tracefile != NULL) {
11243 (void) vfprintf(tracefile, fmt, va);
11244 if (strchr(fmt, '\n'))
11245 (void) fflush(tracefile);
11251 static void trputs(const char *s)
11253 if (tracefile == NULL)
11255 fputs(s, tracefile);
11256 if (strchr(s, '\n'))
11261 static void trstring(char *s)
11266 if (tracefile == NULL)
11268 putc('"', tracefile);
11269 for (p = s; *p; p++) {
11292 case CTLVAR + CTLQUOTE:
11298 case CTLBACKQ + CTLQUOTE:
11301 backslash:putc('\\', tracefile);
11302 putc(c, tracefile);
11305 if (*p >= ' ' && *p <= '~')
11306 putc(*p, tracefile);
11308 putc('\\', tracefile);
11309 putc(*p >> 6 & 03, tracefile);
11310 putc(*p >> 3 & 07, tracefile);
11311 putc(*p & 07, tracefile);
11316 putc('"', tracefile);
11320 static void trargs(char **ap)
11322 if (tracefile == NULL)
11327 putc(' ', tracefile);
11329 putc('\n', tracefile);
11335 static void opentrace()
11345 #ifdef not_this_way
11349 if ((p = getenv("HOME")) == NULL) {
11350 if (geteuid() == 0)
11356 strcat(s, "/trace");
11359 strcpy(s, "./trace");
11360 #endif /* not_this_way */
11361 if ((tracefile = wfopen(s, "a")) == NULL)
11364 if ((flags = fcntl(fileno(tracefile), F_GETFL, 0)) >= 0)
11365 fcntl(fileno(tracefile), F_SETFL, flags | O_APPEND);
11367 fputs("\nTracing started.\n", tracefile);
11374 * The trap builtin.
11377 static int trapcmd(int argc, char **argv)
11384 for (signo = 0; signo < NSIG; signo++) {
11385 if (trap[signo] != NULL) {
11389 p = single_quote(trap[signo]);
11390 sn = sys_siglist[signo];
11392 sn = u_signal_names(0, &signo, 0);
11395 printf("trap -- %s %s\n", p, sn);
11407 if ((signo = decode_signal(*ap, 0)) < 0)
11408 error("%s: bad trap", *ap);
11411 if (action[0] == '-' && action[1] == '\0')
11414 action = xstrdup(action);
11417 trap[signo] = action;
11428 * Set the signal handler for the specified signal. The routine figures
11429 * out what it should be set to.
11432 static void setsignal(int signo)
11436 struct sigaction act;
11438 if ((t = trap[signo]) == NULL)
11440 else if (*t != '\0')
11444 if (rootshell && action == S_DFL) {
11447 if (iflag || minusc || sflag == 0)
11463 #ifdef CONFIG_ASH_JOB_CONTROL
11473 t = &sigmode[signo - 1];
11476 * current setting unknown
11478 if (sigaction(signo, 0, &act) == -1) {
11480 * Pretend it worked; maybe we should give a warning
11481 * here, but other shells don't. We don't alter
11482 * sigmode, so that we retry every time.
11486 if (act.sa_handler == SIG_IGN) {
11487 if (mflag && (signo == SIGTSTP ||
11488 signo == SIGTTIN || signo == SIGTTOU)) {
11489 *t = S_IGN; /* don't hard ignore these */
11493 *t = S_RESET; /* force to be set */
11496 if (*t == S_HARD_IGN || *t == action)
11498 act.sa_handler = ((action == S_CATCH) ? onsig
11499 : ((action == S_IGN) ? SIG_IGN : SIG_DFL));
11502 sigemptyset(&act.sa_mask);
11503 sigaction(signo, &act, 0);
11510 static void ignoresig(int signo)
11512 if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
11513 signal(signo, SIG_IGN);
11515 sigmode[signo - 1] = S_HARD_IGN;
11523 static void onsig(int signo)
11525 if (signo == SIGINT && trap[SIGINT] == NULL) {
11529 gotsig[signo - 1] = 1;
11535 * Called to execute a trap. Perhaps we should avoid entering new trap
11536 * handlers while we are executing a trap handler.
11539 static void dotrap(void)
11545 for (i = 1;; i++) {
11552 savestatus = exitstatus;
11553 evalstring(trap[i], 0);
11554 exitstatus = savestatus;
11561 * Called to exit the shell.
11564 static void exitshell(int status)
11566 struct jmploc loc1, loc2;
11569 TRACE(("exitshell(%d) pid=%d\n", status, getpid()));
11570 if (setjmp(loc1.loc)) {
11573 if (setjmp(loc2.loc)) {
11577 if ((p = trap[0]) != NULL && *p != '\0') {
11581 l1:handler = &loc2; /* probably unnecessary */
11583 #ifdef CONFIG_ASH_JOB_CONTROL
11590 static int decode_signal(const char *string, int minsig)
11593 const char *name = u_signal_names(string, &signo, minsig);
11595 return name ? signo : -1;
11598 static struct var **hashvar(const char *);
11599 static void showvars(const char *, int, int);
11600 static struct var **findvar(struct var **, const char *);
11603 * Initialize the varable symbol tables and import the environment
11607 * This routine initializes the builtin variables. It is called when the
11608 * shell is initialized and again when a shell procedure is spawned.
11611 static void initvar()
11613 const struct varinit *ip;
11617 for (ip = varinit; (vp = ip->var) != NULL; ip++) {
11618 if ((vp->flags & VEXPORT) == 0) {
11619 vpp = hashvar(ip->text);
11622 vp->text = xstrdup(ip->text);
11623 vp->flags = ip->flags;
11624 vp->func = ip->func;
11627 #if !defined(CONFIG_FEATURE_COMMAND_EDITING) || !defined(CONFIG_FEATURE_SH_FANCY_PROMPT)
11629 * PS1 depends on uid
11631 if ((vps1.flags & VEXPORT) == 0) {
11632 vpp = hashvar("PS1=$ ");
11635 vps1.text = xstrdup(geteuid()? "PS1=$ " : "PS1=# ");
11636 vps1.flags = VSTRFIXED | VTEXTFIXED;
11642 * Set the value of a variable. The flags argument is ored with the
11643 * flags of the variable. If val is NULL, the variable is unset.
11646 static void setvar(const char *name, const char *val, int flags)
11661 if (!is_in_name(*p)) {
11662 if (*p == '\0' || *p == '=')
11668 namelen = p - name;
11670 error("%.*s: bad variable name", namelen, name);
11671 len = namelen + 2; /* 2 is space for '=' and '\0' */
11675 len += vallen = strlen(val);
11678 nameeq = xmalloc(len);
11679 memcpy(nameeq, name, namelen);
11680 nameeq[namelen] = '=';
11682 memcpy(nameeq + namelen + 1, val, vallen + 1);
11684 nameeq[namelen + 1] = '\0';
11686 setvareq(nameeq, flags);
11693 * Same as setvar except that the variable and value are passed in
11694 * the first argument as name=value. Since the first argument will
11695 * be actually stored in the table, it should not be a string that
11699 static void setvareq(char *s, int flags)
11701 struct var *vp, **vpp;
11704 flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1));
11705 if ((vp = *findvar(vpp, s))) {
11706 if (vp->flags & VREADONLY) {
11707 size_t len = strchr(s, '=') - s;
11709 error("%.*s: is read only", len, s);
11713 if (vp->func && (flags & VNOFUNC) == 0)
11714 (*vp->func) (strchr(s, '=') + 1);
11716 if ((vp->flags & (VTEXTFIXED | VSTACK)) == 0)
11719 vp->flags &= ~(VTEXTFIXED | VSTACK | VUNSET);
11720 vp->flags |= flags;
11723 #ifdef CONFIG_ASH_MAIL
11725 * We could roll this to a function, to handle it as
11726 * a regular variable function callback, but why bother?
11728 if (iflag && (vp == &vmpath || (vp == &vmail && !mpathset())))
11735 vp = xmalloc(sizeof(*vp));
11746 * Process a linked list of variable assignments.
11749 static void listsetvar(struct strlist *mylist)
11751 struct strlist *lp;
11754 for (lp = mylist; lp; lp = lp->next) {
11755 setvareq(xstrdup(lp->text), 0);
11763 * Find the value of a variable. Returns NULL if not set.
11766 static const char *lookupvar(const char *name)
11770 if ((v = *findvar(hashvar(name), name)) && !(v->flags & VUNSET)) {
11771 return strchr(v->text, '=') + 1;
11779 * Search the environment of a builtin command.
11782 static const char *bltinlookup(const char *name)
11784 const struct strlist *sp;
11786 for (sp = cmdenviron; sp; sp = sp->next) {
11787 if (varequal(sp->text, name))
11788 return strchr(sp->text, '=') + 1;
11790 return lookupvar(name);
11796 * Generate a list of exported variables. This routine is used to construct
11797 * the third argument to execve when executing a program.
11800 static char **environment()
11809 for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
11810 for (vp = *vpp; vp; vp = vp->next)
11811 if (vp->flags & VEXPORT)
11814 ep = env = stalloc((nenv + 1) * sizeof *env);
11815 for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
11816 for (vp = *vpp; vp; vp = vp->next)
11817 if (vp->flags & VEXPORT)
11826 * Command to list all variables which are set. Currently this command
11827 * is invoked from the set command when the set command is called without
11831 static int showvarscmd(int argc, char **argv)
11833 showvars(nullstr, VUNSET, VUNSET);
11840 * The export and readonly commands.
11843 static int exportcmd(int argc, char **argv)
11848 int flag = argv[0][0] == 'r' ? VREADONLY : VEXPORT;
11851 listsetvar(cmdenviron);
11852 pflag = (nextopt("p") == 'p');
11853 if (argc > 1 && !pflag) {
11854 while ((name = *argptr++) != NULL) {
11855 if ((p = strchr(name, '=')) != NULL) {
11858 if ((vp = *findvar(hashvar(name), name))) {
11863 setvar(name, p, flag);
11867 showvars(argv[0], flag, 0);
11874 * The "local" command.
11877 /* funcnest nonzero if we are currently evaluating a function */
11879 static int localcmd(int argc, char **argv)
11884 error("Not in a function");
11885 while ((name = *argptr++) != NULL) {
11893 * Make a variable a local variable. When a variable is made local, it's
11894 * value and flags are saved in a localvar structure. The saved values
11895 * will be restored when the shell function returns. We handle the name
11896 * "-" as a special case.
11899 static void mklocal(char *name)
11901 struct localvar *lvp;
11906 lvp = xmalloc(sizeof(struct localvar));
11907 if (name[0] == '-' && name[1] == '\0') {
11910 p = xmalloc(sizeof optet_vals);
11911 lvp->text = memcpy(p, optet_vals, sizeof optet_vals);
11914 vpp = hashvar(name);
11915 vp = *findvar(vpp, name);
11917 if (strchr(name, '='))
11918 setvareq(xstrdup(name), VSTRFIXED);
11920 setvar(name, NULL, VSTRFIXED);
11921 vp = *vpp; /* the new variable */
11923 lvp->flags = VUNSET;
11925 lvp->text = vp->text;
11926 lvp->flags = vp->flags;
11927 vp->flags |= VSTRFIXED | VTEXTFIXED;
11928 if (strchr(name, '='))
11929 setvareq(xstrdup(name), 0);
11933 lvp->next = localvars;
11940 * Called after a function returns.
11943 static void poplocalvars()
11945 struct localvar *lvp;
11948 while ((lvp = localvars) != NULL) {
11949 localvars = lvp->next;
11951 if (vp == NULL) { /* $- saved */
11952 memcpy(optet_vals, lvp->text, sizeof optet_vals);
11954 } else if ((lvp->flags & (VUNSET | VSTRFIXED)) == VUNSET) {
11955 (void) unsetvar(vp->text);
11957 if ((vp->flags & VTEXTFIXED) == 0)
11959 vp->flags = lvp->flags;
11960 vp->text = lvp->text;
11967 static int setvarcmd(int argc, char **argv)
11970 return unsetcmd(argc, argv);
11971 else if (argc == 3)
11972 setvar(argv[1], argv[2], 0);
11974 error("List assignment not implemented");
11980 * The unset builtin command. We unset the function before we unset the
11981 * variable to allow a function to be unset when there is a readonly variable
11982 * with the same name.
11985 static int unsetcmd(int argc, char **argv)
11993 while ((i = nextopt("vf")) != '\0') {
11999 if (flg_func == 0 && flg_var == 0)
12002 for (ap = argptr; *ap; ap++) {
12006 ret |= unsetvar(*ap);
12013 * Unset the specified variable.
12016 static int unsetvar(const char *s)
12021 vpp = findvar(hashvar(s), s);
12024 if (vp->flags & VREADONLY)
12027 if (*(strchr(vp->text, '=') + 1) != '\0')
12028 setvar(s, nullstr, 0);
12029 vp->flags &= ~VEXPORT;
12030 vp->flags |= VUNSET;
12031 if ((vp->flags & VSTRFIXED) == 0) {
12032 if ((vp->flags & VTEXTFIXED) == 0)
12047 * Find the appropriate entry in the hash table from the name.
12050 static struct var **hashvar(const char *p)
12052 unsigned int hashval;
12054 hashval = ((unsigned char) *p) << 4;
12055 while (*p && *p != '=')
12056 hashval += (unsigned char) *p++;
12057 return &vartab[hashval % VTABSIZE];
12063 * Returns true if the two strings specify the same varable. The first
12064 * variable name is terminated by '='; the second may be terminated by
12065 * either '=' or '\0'.
12068 static int varequal(const char *p, const char *q)
12070 while (*p == *q++) {
12074 if (*p == '=' && *(q - 1) == '\0')
12079 static void showvars(const char *myprefix, int mask, int xor)
12083 const char *sep = myprefix == nullstr ? myprefix : spcstr;
12085 for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
12086 for (vp = *vpp; vp; vp = vp->next) {
12087 if ((vp->flags & mask) ^ xor) {
12091 p = strchr(vp->text, '=') + 1;
12092 len = p - vp->text;
12093 p = single_quote(p);
12095 printf("%s%s%.*s%s\n", myprefix, sep, len, vp->text, p);
12102 static struct var **findvar(struct var **vpp, const char *name)
12104 for (; *vpp; vpp = &(*vpp)->next) {
12105 if (varequal((*vpp)->text, name)) {
12113 * Copyright (c) 1999 Herbert Xu <herbert@debian.org>
12114 * This file contains code for the times builtin.
12116 static int timescmd(int argc, char **argv)
12119 long int clk_tck = sysconf(_SC_CLK_TCK);
12122 printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n",
12123 (int) (buf.tms_utime / clk_tck / 60),
12124 ((double) buf.tms_utime) / clk_tck,
12125 (int) (buf.tms_stime / clk_tck / 60),
12126 ((double) buf.tms_stime) / clk_tck,
12127 (int) (buf.tms_cutime / clk_tck / 60),
12128 ((double) buf.tms_cutime) / clk_tck,
12129 (int) (buf.tms_cstime / clk_tck / 60),
12130 ((double) buf.tms_cstime) / clk_tck);
12134 #ifdef CONFIG_ASH_MATH_SUPPORT
12135 /* The let builtin. */
12136 int letcmd(int argc, char **argv)
12142 char *tmp, *expression, p[13];
12144 expression = strchr(argv[1], '=');
12146 /* Cannot use 'error()' here, or the return code
12147 * will be incorrect */
12148 out2fmt("sh: let: syntax error: \"%s\"\n", argv[1]);
12151 *expression = '\0';
12152 tmp = ++expression;
12153 result = arith(tmp, &errcode);
12155 /* Cannot use 'error()' here, or the return code
12156 * will be incorrect */
12157 out2fmt("sh: let: ");
12159 out2fmt("divide by zero");
12161 out2fmt("syntax error: \"%s=%s\"\n", argv[1], expression);
12164 snprintf(p, 12, "%ld", result);
12165 setvar(argv[1], xstrdup(p), 0);
12166 } else if (argc >= 3)
12167 synerror("invalid operand");
12175 * Copyright (c) 1989, 1991, 1993, 1994
12176 * The Regents of the University of California. All rights reserved.
12178 * This code is derived from software contributed to Berkeley by
12179 * Kenneth Almquist.
12181 * Redistribution and use in source and binary forms, with or without
12182 * modification, are permitted provided that the following conditions
12184 * 1. Redistributions of source code must retain the above copyright
12185 * notice, this list of conditions and the following disclaimer.
12186 * 2. Redistributions in binary form must reproduce the above copyright
12187 * notice, this list of conditions and the following disclaimer in the
12188 * documentation and/or other materials provided with the distribution.
12190 * 3. <BSD Advertising Clause omitted per the July 22, 1999 licensing change
12191 * ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change>
12193 * 4. Neither the name of the University nor the names of its contributors
12194 * may be used to endorse or promote products derived from this software
12195 * without specific prior written permission.
12197 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
12198 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
12199 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
12200 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
12201 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
12202 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
12203 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
12204 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
12205 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
12206 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF