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 /* These defines allow you to adjust the feature set to be compiled
37 * into the ash shell. As a rule, enabling these options will make
38 * ash get bigger... With all of these options off, ash adds about
39 * 60k to busybox on an x86 system.*/
42 /* Enable job control. This allows you to run jobs in the background,
43 * which is great when ash is being used as an interactive shell, but
44 * it completely useless for is all you are doing is running scripts.
45 * This adds about 2.5k on an x86 system. */
48 /* This enables alias support in ash. If you want to support things
49 * like "alias ls='ls -l'" with ash, enable this. This is only useful
50 * when ash is used as an intractive shell. This adds about 1.5k */
53 /* If you need ash to act as a full Posix shell, with full math
54 * support, enable this. This adds a bit over 2k an x86 system. */
55 //#undef ASH_MATH_SUPPORT
56 #define ASH_MATH_SUPPORT
58 /* Getopts is used by shell procedures to parse positional parameters.
59 * You probably want to leave this disabled, and use the busybox getopt
60 * applet if you want to do this sort of thing. There are some scripts
61 * out there that use it, so it you need it, enable. Most people will
62 * leave this disabled. This adds 1k on an x86 system. */
65 /* This allows you to override shell builtins and use whatever is on
66 * the filesystem. This is most useful when ash is acting as a
67 * standalone shell. Adds about 272 bytes. */
71 /* Optimize size vs speed as size */
72 #define ASH_OPTIMIZE_FOR_SIZE
74 /* Enable this to compile in extra debugging noise. When debugging is
75 * on, debugging info will be written to $HOME/trace and a quit signal
76 * will generate a core dump. */
79 /* These are here to work with glibc -- Don't change these... */
101 #include <sys/stat.h>
102 #include <sys/cdefs.h>
103 #include <sys/ioctl.h>
104 #include <sys/param.h>
105 #include <sys/resource.h>
106 #include <sys/time.h>
107 #include <sys/times.h>
108 #include <sys/types.h>
109 #include <sys/wait.h>
112 #if !defined(FNMATCH_BROKEN)
115 #if !defined(GLOB_BROKEN)
127 * This file was generated by the mksyntax program.
131 #define CWORD 0 /* character is nothing special */
132 #define CNL 1 /* newline character */
133 #define CBACK 2 /* a backslash character */
134 #define CSQUOTE 3 /* single quote */
135 #define CDQUOTE 4 /* double quote */
136 #define CENDQUOTE 5 /* a terminating quote */
137 #define CBQUOTE 6 /* backwards single quote */
138 #define CVAR 7 /* a dollar sign */
139 #define CENDVAR 8 /* a '}' character */
140 #define CLP 9 /* a left paren in arithmetic */
141 #define CRP 10 /* a right paren in arithmetic */
142 #define CENDFILE 11 /* end of file */
143 #define CCTL 12 /* like CWORD, except it must be escaped */
144 #define CSPCL 13 /* these terminate a word */
145 #define CIGN 14 /* character should be ignored */
165 #define TENDBQUOTE 13
185 /* control characters in argument strings */
186 #define CTLESC '\201'
187 #define CTLVAR '\202'
188 #define CTLENDVAR '\203'
189 #define CTLBACKQ '\204'
190 #define CTLQUOTE 01 /* ored with CTLBACKQ code if in quotes */
191 /* CTLBACKQ | CTLQUOTE == '\205' */
192 #define CTLARI '\206'
193 #define CTLENDARI '\207'
194 #define CTLQUOTEMARK '\210'
197 #define is_digit(c) ((c)>='0' && (c)<='9')
198 #define is_name(c) (((c) < CTLESC || (c) > CTLENDARI) && ((c) == '_' || isalpha((unsigned char) (c))))
199 #define is_in_name(c) (((c) < CTLESC || (c) > CTLENDARI) && ((c) == '_' || isalnum((unsigned char) (c))))
202 * is_special(c) evaluates to 1 for c in "!#$*-0123456789?@"; 0 otherwise
203 * (assuming ascii char codes, as the original implementation did)
205 #define is_special(c) \
206 ( (((unsigned int)c) - 33 < 32) \
207 && ((0xc1ff920dUL >> (((unsigned int)c) - 33)) & 1))
209 #define digit_val(c) ((c) - '0')
212 #define _DIAGASSERT(x)
216 #define S_DFL 1 /* default signal handling (SIG_DFL) */
217 #define S_CATCH 2 /* signal is caught */
218 #define S_IGN 3 /* signal is ignored (SIG_IGN) */
219 #define S_HARD_IGN 4 /* signal is ignored permenantly */
220 #define S_RESET 5 /* temporary - to reset a hard ignored sig */
223 /* variable substitution byte (follows CTLVAR) */
224 #define VSTYPE 0x0f /* type of variable substitution */
225 #define VSNUL 0x10 /* colon--treat the empty string as unset */
226 #define VSQUOTE 0x80 /* inside double quotes--suppress splitting */
228 /* values of VSTYPE field */
229 #define VSNORMAL 0x1 /* normal variable: $var or ${var} */
230 #define VSMINUS 0x2 /* ${var-text} */
231 #define VSPLUS 0x3 /* ${var+text} */
232 #define VSQUESTION 0x4 /* ${var?message} */
233 #define VSASSIGN 0x5 /* ${var=text} */
234 #define VSTRIMLEFT 0x6 /* ${var#pattern} */
235 #define VSTRIMLEFTMAX 0x7 /* ${var##pattern} */
236 #define VSTRIMRIGHT 0x8 /* ${var%pattern} */
237 #define VSTRIMRIGHTMAX 0x9 /* ${var%%pattern} */
238 #define VSLENGTH 0xa /* ${#var} */
240 /* flags passed to redirect */
241 #define REDIR_PUSH 01 /* save previous values of file descriptors */
242 #define REDIR_BACKQ 02 /* save the command output to pipe */
245 * BSD setjmp saves the signal mask, which violates ANSI C and takes time,
246 * so we use _setjmp instead.
250 #define setjmp(jmploc) _setjmp(jmploc)
251 #define longjmp(jmploc, val) _longjmp(jmploc, val)
255 * Most machines require the value returned from malloc to be aligned
256 * in some way. The following macro will get this right on many machines.
265 #define ALIGN(nbytes) (((nbytes) + sizeof(union align) - 1) & ~(sizeof(union align) - 1))
268 #ifdef BB_LOCALE_SUPPORT
270 static void change_lc_all(const char *value);
271 static void change_lc_ctype(const char *value);
275 * These macros allow the user to suspend the handling of interrupt signals
276 * over a period of time. This is similar to SIGHOLD to or sigblock, but
277 * much more efficient and portable. (But hacking the kernel is so much
278 * more fun than worrying about efficiency and portability. :-))
281 static void onint (void);
282 static volatile int suppressint;
283 static volatile int intpending;
285 #define INTOFF suppressint++
286 #ifndef ASH_OPTIMIZE_FOR_SIZE
287 #define INTON { if (--suppressint == 0 && intpending) onint(); }
288 #define FORCEINTON {suppressint = 0; if (intpending) onint();}
290 static void __inton (void);
291 static void forceinton (void);
292 #define INTON __inton()
293 #define FORCEINTON forceinton()
296 #define CLEAR_PENDING_INT intpending = 0
297 #define int_pending() intpending
300 typedef void *pointer;
302 #define NULL (void *)0
305 static inline pointer ckmalloc (int sz) { return xmalloc(sz); }
306 static inline pointer ckrealloc(void *p, int sz) { return xrealloc(p, sz); }
307 static inline char * savestr (const char *s) { return xstrdup(s); }
309 static pointer stalloc (int);
310 static void stunalloc (pointer);
311 static void ungrabstackstr (char *, char *);
312 static char * growstackstr(void);
313 static char * makestrspace(size_t newlen);
314 static char *sstrdup (const char *);
317 * Parse trees for commands are allocated in lifo order, so we use a stack
318 * to make this more efficient, and also to avoid all sorts of exception
319 * handling code to handle interrupts in the middle of a parse.
321 * The size 504 was chosen because the Ultrix malloc handles that size
325 #define MINSIZE 504 /* minimum size of a block */
329 struct stack_block *prev;
333 static struct stack_block stackbase;
334 static struct stack_block *stackp = &stackbase;
335 static struct stackmark *markp;
336 static char *stacknxt = stackbase.space;
337 static int stacknleft = MINSIZE;
340 #define equal(s1, s2) (strcmp(s1, s2) == 0)
342 #define stackblock() stacknxt
343 #define stackblocksize() stacknleft
344 #define STARTSTACKSTR(p) p = stackblock(), sstrnleft = stackblocksize()
346 #define STPUTC(c, p) (--sstrnleft >= 0? (*p++ = (c)) : (p = growstackstr(), *p++ = (c)))
347 #define CHECKSTRSPACE(n, p) { if (sstrnleft < n) p = makestrspace(n); }
348 #define STACKSTRNUL(p) (sstrnleft == 0? (p = growstackstr(), *p = '\0') : (*p = '\0'))
351 #define USTPUTC(c, p) (--sstrnleft, *p++ = (c))
352 #define STUNPUTC(p) (++sstrnleft, --p)
353 #define STTOPC(p) p[-1]
354 #define STADJUST(amount, p) (p += (amount), sstrnleft -= (amount))
355 #define grabstackstr(p) stalloc(stackblocksize() - sstrnleft)
357 #define ckfree(p) free((pointer)(p))
361 #define TRACE(param) trace param
362 static void trace (const char *, ...);
363 static void trargs (char **);
364 static void showtree (union node *);
365 static void trputc (int);
366 static void trputs (const char *);
367 static void opentrace (void);
402 #define EXP_FULL 0x1 /* perform word splitting & file globbing */
403 #define EXP_TILDE 0x2 /* do normal tilde expansion */
404 #define EXP_VARTILDE 0x4 /* expand tildes in an assignment */
405 #define EXP_REDIR 0x8 /* file glob for a redirection (1 match only) */
406 #define EXP_CASE 0x10 /* keeps quotes around for CASE pattern */
407 #define EXP_RECORD 0x20 /* need to record arguments for ifs breakup */
412 static char optet_vals[NOPTS];
414 static const char * const optlist[NOPTS] = {
433 #define optent_name(optent) (optent+1)
434 #define optent_letter(optent) optent[0]
435 #define optent_val(optent) optet_vals[optent]
437 #define eflag optent_val(0)
438 #define fflag optent_val(1)
439 #define Iflag optent_val(2)
440 #define iflag optent_val(3)
441 #define mflag optent_val(4)
442 #define nflag optent_val(5)
443 #define sflag optent_val(6)
444 #define xflag optent_val(7)
445 #define vflag optent_val(8)
446 #define Vflag optent_val(9)
447 #define Eflag optent_val(10)
448 #define Cflag optent_val(11)
449 #define aflag optent_val(12)
450 #define bflag optent_val(13)
451 #define uflag optent_val(14)
452 #define qflag optent_val(15)
455 /* Mode argument to forkshell. Don't change FORK_FG or FORK_BG. */
473 union node *redirect;
480 struct nodelist *cmdlist;
487 union node *redirect;
495 union node *elsepart;
526 struct nodelist *backquote;
564 struct nbinary nbinary;
567 struct nredir nredir;
571 struct nclist nclist;
581 struct nodelist *next;
585 struct backcmd { /* result of evalbackcmd */
586 int fd; /* file descriptor to read from */
587 char *buf; /* buffer */
588 int nleft; /* number of chars in buffer */
589 struct job *jp; /* job structure for command */
597 const struct builtincmd *cmd;
602 struct strlist *next;
608 struct strlist *list;
609 struct strlist **lastp;
613 struct strpush *prev; /* preceding string on stack */
617 struct alias *ap; /* if push was associated with an alias */
619 char *string; /* remember the string since it may change */
623 struct parsefile *prev; /* preceding file on stack */
624 int linno; /* current line */
625 int fd; /* file descriptor (or -1 if string) */
626 int nleft; /* number of chars left in this line */
627 int lleft; /* number of chars left in this buffer */
628 char *nextc; /* next char in buffer */
629 char *buf; /* input buffer */
630 struct strpush *strpush; /* for pushing strings at this level */
631 struct strpush basestrpush; /* so pushing one is fast */
635 struct stack_block *stackp;
638 struct stackmark *marknext;
642 int nparam; /* # of positional parameters (without $0) */
643 unsigned char malloc; /* if parameter list dynamically allocated */
644 char **p; /* parameter list */
645 int optind; /* next parameter to be processed by getopts */
646 int optoff; /* used by getopts */
650 * When commands are first encountered, they are entered in a hash table.
651 * This ensures that a full path search will not have to be done for them
652 * on each invocation.
654 * We should investigate converting to a linear search, even though that
655 * would make the command name "hash" a misnomer.
657 #define CMDTABLESIZE 31 /* should be prime */
658 #define ARB 1 /* actual size determined at run time */
663 struct tblentry *next; /* next entry in hash chain */
664 union param param; /* definition of builtin function */
665 short cmdtype; /* index identifying command */
666 char rehash; /* if set, cd done since entry created */
667 char cmdname[ARB]; /* name of command */
671 static struct tblentry *cmdtable[CMDTABLESIZE];
672 static int builtinloc = -1; /* index in path of %builtin, or -1 */
673 static int exerrno = 0; /* Last exec error */
676 static void tryexec (char *, char **, char **);
677 static void printentry (struct tblentry *, int);
678 static void clearcmdentry (int);
679 static struct tblentry *cmdlookup (const char *, int);
680 static void delete_cmd_entry (void);
681 static int path_change (const char *, int *);
684 static void flushall (void);
685 static void out2fmt (const char *, ...)
686 __attribute__((__format__(__printf__,1,2)));
687 static int xwrite (int, const char *, int);
689 static inline void outstr (const char *p, FILE *file) { fputs(p, file); }
690 static void out1str(const char *p) { outstr(p, stdout); }
691 static void out2str(const char *p) { outstr(p, stderr); }
693 #ifndef ASH_OPTIMIZE_FOR_SIZE
694 #define out2c(c) putc((c), stderr)
696 static void out2c(int c) { putc(c, stderr); }
700 #ifdef ASH_OPTIMIZE_FOR_SIZE
701 #define USE_SIT_FUNCTION
704 /* number syntax index */
705 #define BASESYNTAX 0 /* not in quotes */
706 #define DQSYNTAX 1 /* in double quotes */
707 #define SQSYNTAX 2 /* in single quotes */
708 #define ARISYNTAX 3 /* in arithmetic */
710 static const char S_I_T[][4] = {
711 /* 0 */ { CSPCL, CIGN, CIGN, CIGN }, /* PEOA */
712 /* 1 */ { CSPCL, CWORD, CWORD, CWORD }, /* ' ' */
713 /* 2 */ { CNL, CNL, CNL, CNL }, /* \n */
714 /* 3 */ { CWORD, CCTL, CCTL, CWORD }, /* !*-/:=?[]~ */
715 /* 4 */ { CDQUOTE, CENDQUOTE, CWORD, CDQUOTE }, /* '"' */
716 /* 5 */ { CVAR, CVAR, CWORD, CVAR }, /* $ */
717 /* 6 */ { CSQUOTE, CWORD, CENDQUOTE, CSQUOTE }, /* "'" */
718 /* 7 */ { CSPCL, CWORD, CWORD, CLP }, /* ( */
719 /* 8 */ { CSPCL, CWORD, CWORD, CRP }, /* ) */
720 /* 9 */ { CBACK, CBACK, CCTL, CBACK }, /* \ */
721 /* 10 */ { CBQUOTE, CBQUOTE, CWORD, CBQUOTE }, /* ` */
722 /* 11 */ { CENDVAR, CENDVAR, CWORD, CENDVAR }, /* } */
723 #ifndef USE_SIT_FUNCTION
724 /* 12 */ { CENDFILE, CENDFILE, CENDFILE, CENDFILE }, /* PEOF */
725 /* 13 */ { CWORD, CWORD, CWORD, CWORD }, /* 0-9A-Za-z */
726 /* 14 */ { CCTL, CCTL, CCTL, CCTL } /* CTLESC ... */
730 #ifdef USE_SIT_FUNCTION
732 #define U_C(c) ((unsigned char)(c))
734 static int SIT(int c, int syntax)
736 static const char spec_symbls[]="\t\n !\"$&'()*-/:;<=>?[\\]`|}~";
737 static const char syntax_index_table [] = {
738 1, 2, 1, 3, 4, 5, 1, 6, /* "\t\n !\"$&'" */
739 7, 8, 3, 3, 3, 3, 1, 1, /* "()*-/:;<" */
740 3, 1, 3, 3, 9, 3,10, 1, /* "=>?[\\]`|" */
745 if(c==PEOF) /* 2^8+2 */
747 if(c==PEOA) /* 2^8+1 */
749 else if(U_C(c)>=U_C(CTLESC) && U_C(c)<=U_C(CTLQUOTEMARK))
752 s = strchr(spec_symbls, c);
755 indx = syntax_index_table[(s-spec_symbls)];
757 return S_I_T[indx][syntax];
760 #else /* USE_SIT_FUNCTION */
762 #define SIT(c, syntax) S_I_T[(int)syntax_index_table[((int)c)+SYNBASE]][syntax]
764 #define CSPCL_CIGN_CIGN_CIGN 0
765 #define CSPCL_CWORD_CWORD_CWORD 1
766 #define CNL_CNL_CNL_CNL 2
767 #define CWORD_CCTL_CCTL_CWORD 3
768 #define CDQUOTE_CENDQUOTE_CWORD_CDQUOTE 4
769 #define CVAR_CVAR_CWORD_CVAR 5
770 #define CSQUOTE_CWORD_CENDQUOTE_CSQUOTE 6
771 #define CSPCL_CWORD_CWORD_CLP 7
772 #define CSPCL_CWORD_CWORD_CRP 8
773 #define CBACK_CBACK_CCTL_CBACK 9
774 #define CBQUOTE_CBQUOTE_CWORD_CBQUOTE 10
775 #define CENDVAR_CENDVAR_CWORD_CENDVAR 11
776 #define CENDFILE_CENDFILE_CENDFILE_CENDFILE 12
777 #define CWORD_CWORD_CWORD_CWORD 13
778 #define CCTL_CCTL_CCTL_CCTL 14
780 static const char syntax_index_table[258] = {
781 /* BASESYNTAX_DQSYNTAX_SQSYNTAX_ARISYNTAX */
782 /* 0 -130 PEOF */ CENDFILE_CENDFILE_CENDFILE_CENDFILE,
783 /* 1 -129 PEOA */ CSPCL_CIGN_CIGN_CIGN,
784 /* 2 -128 0xff */ CWORD_CWORD_CWORD_CWORD,
785 /* 3 -127 */ CCTL_CCTL_CCTL_CCTL, /* CTLQUOTEMARK */
786 /* 4 -126 */ CCTL_CCTL_CCTL_CCTL,
787 /* 5 -125 */ CCTL_CCTL_CCTL_CCTL,
788 /* 6 -124 */ CCTL_CCTL_CCTL_CCTL,
789 /* 7 -123 */ CCTL_CCTL_CCTL_CCTL,
790 /* 8 -122 */ CCTL_CCTL_CCTL_CCTL,
791 /* 9 -121 */ CCTL_CCTL_CCTL_CCTL,
792 /* 10 -120 */ CCTL_CCTL_CCTL_CCTL, /* CTLESC */
793 /* 11 -119 */ CWORD_CWORD_CWORD_CWORD,
794 /* 12 -118 */ CWORD_CWORD_CWORD_CWORD,
795 /* 13 -117 */ CWORD_CWORD_CWORD_CWORD,
796 /* 14 -116 */ CWORD_CWORD_CWORD_CWORD,
797 /* 15 -115 */ CWORD_CWORD_CWORD_CWORD,
798 /* 16 -114 */ CWORD_CWORD_CWORD_CWORD,
799 /* 17 -113 */ CWORD_CWORD_CWORD_CWORD,
800 /* 18 -112 */ CWORD_CWORD_CWORD_CWORD,
801 /* 19 -111 */ CWORD_CWORD_CWORD_CWORD,
802 /* 20 -110 */ CWORD_CWORD_CWORD_CWORD,
803 /* 21 -109 */ CWORD_CWORD_CWORD_CWORD,
804 /* 22 -108 */ CWORD_CWORD_CWORD_CWORD,
805 /* 23 -107 */ CWORD_CWORD_CWORD_CWORD,
806 /* 24 -106 */ CWORD_CWORD_CWORD_CWORD,
807 /* 25 -105 */ CWORD_CWORD_CWORD_CWORD,
808 /* 26 -104 */ CWORD_CWORD_CWORD_CWORD,
809 /* 27 -103 */ CWORD_CWORD_CWORD_CWORD,
810 /* 28 -102 */ CWORD_CWORD_CWORD_CWORD,
811 /* 29 -101 */ CWORD_CWORD_CWORD_CWORD,
812 /* 30 -100 */ CWORD_CWORD_CWORD_CWORD,
813 /* 31 -99 */ CWORD_CWORD_CWORD_CWORD,
814 /* 32 -98 */ CWORD_CWORD_CWORD_CWORD,
815 /* 33 -97 */ CWORD_CWORD_CWORD_CWORD,
816 /* 34 -96 */ CWORD_CWORD_CWORD_CWORD,
817 /* 35 -95 */ CWORD_CWORD_CWORD_CWORD,
818 /* 36 -94 */ CWORD_CWORD_CWORD_CWORD,
819 /* 37 -93 */ CWORD_CWORD_CWORD_CWORD,
820 /* 38 -92 */ CWORD_CWORD_CWORD_CWORD,
821 /* 39 -91 */ CWORD_CWORD_CWORD_CWORD,
822 /* 40 -90 */ CWORD_CWORD_CWORD_CWORD,
823 /* 41 -89 */ CWORD_CWORD_CWORD_CWORD,
824 /* 42 -88 */ CWORD_CWORD_CWORD_CWORD,
825 /* 43 -87 */ CWORD_CWORD_CWORD_CWORD,
826 /* 44 -86 */ CWORD_CWORD_CWORD_CWORD,
827 /* 45 -85 */ CWORD_CWORD_CWORD_CWORD,
828 /* 46 -84 */ CWORD_CWORD_CWORD_CWORD,
829 /* 47 -83 */ CWORD_CWORD_CWORD_CWORD,
830 /* 48 -82 */ CWORD_CWORD_CWORD_CWORD,
831 /* 49 -81 */ CWORD_CWORD_CWORD_CWORD,
832 /* 50 -80 */ CWORD_CWORD_CWORD_CWORD,
833 /* 51 -79 */ CWORD_CWORD_CWORD_CWORD,
834 /* 52 -78 */ CWORD_CWORD_CWORD_CWORD,
835 /* 53 -77 */ CWORD_CWORD_CWORD_CWORD,
836 /* 54 -76 */ CWORD_CWORD_CWORD_CWORD,
837 /* 55 -75 */ CWORD_CWORD_CWORD_CWORD,
838 /* 56 -74 */ CWORD_CWORD_CWORD_CWORD,
839 /* 57 -73 */ CWORD_CWORD_CWORD_CWORD,
840 /* 58 -72 */ CWORD_CWORD_CWORD_CWORD,
841 /* 59 -71 */ CWORD_CWORD_CWORD_CWORD,
842 /* 60 -70 */ CWORD_CWORD_CWORD_CWORD,
843 /* 61 -69 */ CWORD_CWORD_CWORD_CWORD,
844 /* 62 -68 */ CWORD_CWORD_CWORD_CWORD,
845 /* 63 -67 */ CWORD_CWORD_CWORD_CWORD,
846 /* 64 -66 */ CWORD_CWORD_CWORD_CWORD,
847 /* 65 -65 */ CWORD_CWORD_CWORD_CWORD,
848 /* 66 -64 */ CWORD_CWORD_CWORD_CWORD,
849 /* 67 -63 */ CWORD_CWORD_CWORD_CWORD,
850 /* 68 -62 */ CWORD_CWORD_CWORD_CWORD,
851 /* 69 -61 */ CWORD_CWORD_CWORD_CWORD,
852 /* 70 -60 */ CWORD_CWORD_CWORD_CWORD,
853 /* 71 -59 */ CWORD_CWORD_CWORD_CWORD,
854 /* 72 -58 */ CWORD_CWORD_CWORD_CWORD,
855 /* 73 -57 */ CWORD_CWORD_CWORD_CWORD,
856 /* 74 -56 */ CWORD_CWORD_CWORD_CWORD,
857 /* 75 -55 */ CWORD_CWORD_CWORD_CWORD,
858 /* 76 -54 */ CWORD_CWORD_CWORD_CWORD,
859 /* 77 -53 */ CWORD_CWORD_CWORD_CWORD,
860 /* 78 -52 */ CWORD_CWORD_CWORD_CWORD,
861 /* 79 -51 */ CWORD_CWORD_CWORD_CWORD,
862 /* 80 -50 */ CWORD_CWORD_CWORD_CWORD,
863 /* 81 -49 */ CWORD_CWORD_CWORD_CWORD,
864 /* 82 -48 */ CWORD_CWORD_CWORD_CWORD,
865 /* 83 -47 */ CWORD_CWORD_CWORD_CWORD,
866 /* 84 -46 */ CWORD_CWORD_CWORD_CWORD,
867 /* 85 -45 */ CWORD_CWORD_CWORD_CWORD,
868 /* 86 -44 */ CWORD_CWORD_CWORD_CWORD,
869 /* 87 -43 */ CWORD_CWORD_CWORD_CWORD,
870 /* 88 -42 */ CWORD_CWORD_CWORD_CWORD,
871 /* 89 -41 */ CWORD_CWORD_CWORD_CWORD,
872 /* 90 -40 */ CWORD_CWORD_CWORD_CWORD,
873 /* 91 -39 */ CWORD_CWORD_CWORD_CWORD,
874 /* 92 -38 */ CWORD_CWORD_CWORD_CWORD,
875 /* 93 -37 */ CWORD_CWORD_CWORD_CWORD,
876 /* 94 -36 */ CWORD_CWORD_CWORD_CWORD,
877 /* 95 -35 */ CWORD_CWORD_CWORD_CWORD,
878 /* 96 -34 */ CWORD_CWORD_CWORD_CWORD,
879 /* 97 -33 */ CWORD_CWORD_CWORD_CWORD,
880 /* 98 -32 */ CWORD_CWORD_CWORD_CWORD,
881 /* 99 -31 */ CWORD_CWORD_CWORD_CWORD,
882 /* 100 -30 */ CWORD_CWORD_CWORD_CWORD,
883 /* 101 -29 */ CWORD_CWORD_CWORD_CWORD,
884 /* 102 -28 */ CWORD_CWORD_CWORD_CWORD,
885 /* 103 -27 */ CWORD_CWORD_CWORD_CWORD,
886 /* 104 -26 */ CWORD_CWORD_CWORD_CWORD,
887 /* 105 -25 */ CWORD_CWORD_CWORD_CWORD,
888 /* 106 -24 */ CWORD_CWORD_CWORD_CWORD,
889 /* 107 -23 */ CWORD_CWORD_CWORD_CWORD,
890 /* 108 -22 */ CWORD_CWORD_CWORD_CWORD,
891 /* 109 -21 */ CWORD_CWORD_CWORD_CWORD,
892 /* 110 -20 */ CWORD_CWORD_CWORD_CWORD,
893 /* 111 -19 */ CWORD_CWORD_CWORD_CWORD,
894 /* 112 -18 */ CWORD_CWORD_CWORD_CWORD,
895 /* 113 -17 */ CWORD_CWORD_CWORD_CWORD,
896 /* 114 -16 */ CWORD_CWORD_CWORD_CWORD,
897 /* 115 -15 */ CWORD_CWORD_CWORD_CWORD,
898 /* 116 -14 */ CWORD_CWORD_CWORD_CWORD,
899 /* 117 -13 */ CWORD_CWORD_CWORD_CWORD,
900 /* 118 -12 */ CWORD_CWORD_CWORD_CWORD,
901 /* 119 -11 */ CWORD_CWORD_CWORD_CWORD,
902 /* 120 -10 */ CWORD_CWORD_CWORD_CWORD,
903 /* 121 -9 */ CWORD_CWORD_CWORD_CWORD,
904 /* 122 -8 */ CWORD_CWORD_CWORD_CWORD,
905 /* 123 -7 */ CWORD_CWORD_CWORD_CWORD,
906 /* 124 -6 */ CWORD_CWORD_CWORD_CWORD,
907 /* 125 -5 */ CWORD_CWORD_CWORD_CWORD,
908 /* 126 -4 */ CWORD_CWORD_CWORD_CWORD,
909 /* 127 -3 */ CWORD_CWORD_CWORD_CWORD,
910 /* 128 -2 */ CWORD_CWORD_CWORD_CWORD,
911 /* 129 -1 */ CWORD_CWORD_CWORD_CWORD,
912 /* 130 0 */ CWORD_CWORD_CWORD_CWORD,
913 /* 131 1 */ CWORD_CWORD_CWORD_CWORD,
914 /* 132 2 */ CWORD_CWORD_CWORD_CWORD,
915 /* 133 3 */ CWORD_CWORD_CWORD_CWORD,
916 /* 134 4 */ CWORD_CWORD_CWORD_CWORD,
917 /* 135 5 */ CWORD_CWORD_CWORD_CWORD,
918 /* 136 6 */ CWORD_CWORD_CWORD_CWORD,
919 /* 137 7 */ CWORD_CWORD_CWORD_CWORD,
920 /* 138 8 */ CWORD_CWORD_CWORD_CWORD,
921 /* 139 9 "\t" */ CSPCL_CWORD_CWORD_CWORD,
922 /* 140 10 "\n" */ CNL_CNL_CNL_CNL,
923 /* 141 11 */ CWORD_CWORD_CWORD_CWORD,
924 /* 142 12 */ CWORD_CWORD_CWORD_CWORD,
925 /* 143 13 */ CWORD_CWORD_CWORD_CWORD,
926 /* 144 14 */ CWORD_CWORD_CWORD_CWORD,
927 /* 145 15 */ CWORD_CWORD_CWORD_CWORD,
928 /* 146 16 */ CWORD_CWORD_CWORD_CWORD,
929 /* 147 17 */ CWORD_CWORD_CWORD_CWORD,
930 /* 148 18 */ CWORD_CWORD_CWORD_CWORD,
931 /* 149 19 */ CWORD_CWORD_CWORD_CWORD,
932 /* 150 20 */ CWORD_CWORD_CWORD_CWORD,
933 /* 151 21 */ CWORD_CWORD_CWORD_CWORD,
934 /* 152 22 */ CWORD_CWORD_CWORD_CWORD,
935 /* 153 23 */ CWORD_CWORD_CWORD_CWORD,
936 /* 154 24 */ CWORD_CWORD_CWORD_CWORD,
937 /* 155 25 */ CWORD_CWORD_CWORD_CWORD,
938 /* 156 26 */ CWORD_CWORD_CWORD_CWORD,
939 /* 157 27 */ CWORD_CWORD_CWORD_CWORD,
940 /* 158 28 */ CWORD_CWORD_CWORD_CWORD,
941 /* 159 29 */ CWORD_CWORD_CWORD_CWORD,
942 /* 160 30 */ CWORD_CWORD_CWORD_CWORD,
943 /* 161 31 */ CWORD_CWORD_CWORD_CWORD,
944 /* 162 32 " " */ CSPCL_CWORD_CWORD_CWORD,
945 /* 163 33 "!" */ CWORD_CCTL_CCTL_CWORD,
946 /* 164 34 """ */ CDQUOTE_CENDQUOTE_CWORD_CDQUOTE,
947 /* 165 35 "#" */ CWORD_CWORD_CWORD_CWORD,
948 /* 166 36 "$" */ CVAR_CVAR_CWORD_CVAR,
949 /* 167 37 "%" */ CWORD_CWORD_CWORD_CWORD,
950 /* 168 38 "&" */ CSPCL_CWORD_CWORD_CWORD,
951 /* 169 39 "'" */ CSQUOTE_CWORD_CENDQUOTE_CSQUOTE,
952 /* 170 40 "(" */ CSPCL_CWORD_CWORD_CLP,
953 /* 171 41 ")" */ CSPCL_CWORD_CWORD_CRP,
954 /* 172 42 "*" */ CWORD_CCTL_CCTL_CWORD,
955 /* 173 43 "+" */ CWORD_CWORD_CWORD_CWORD,
956 /* 174 44 "," */ CWORD_CWORD_CWORD_CWORD,
957 /* 175 45 "-" */ CWORD_CCTL_CCTL_CWORD,
958 /* 176 46 "." */ CWORD_CWORD_CWORD_CWORD,
959 /* 177 47 "/" */ CWORD_CCTL_CCTL_CWORD,
960 /* 178 48 "0" */ CWORD_CWORD_CWORD_CWORD,
961 /* 179 49 "1" */ CWORD_CWORD_CWORD_CWORD,
962 /* 180 50 "2" */ CWORD_CWORD_CWORD_CWORD,
963 /* 181 51 "3" */ CWORD_CWORD_CWORD_CWORD,
964 /* 182 52 "4" */ CWORD_CWORD_CWORD_CWORD,
965 /* 183 53 "5" */ CWORD_CWORD_CWORD_CWORD,
966 /* 184 54 "6" */ CWORD_CWORD_CWORD_CWORD,
967 /* 185 55 "7" */ CWORD_CWORD_CWORD_CWORD,
968 /* 186 56 "8" */ CWORD_CWORD_CWORD_CWORD,
969 /* 187 57 "9" */ CWORD_CWORD_CWORD_CWORD,
970 /* 188 58 ":" */ CWORD_CCTL_CCTL_CWORD,
971 /* 189 59 ";" */ CSPCL_CWORD_CWORD_CWORD,
972 /* 190 60 "<" */ CSPCL_CWORD_CWORD_CWORD,
973 /* 191 61 "=" */ CWORD_CCTL_CCTL_CWORD,
974 /* 192 62 ">" */ CSPCL_CWORD_CWORD_CWORD,
975 /* 193 63 "?" */ CWORD_CCTL_CCTL_CWORD,
976 /* 194 64 "@" */ CWORD_CWORD_CWORD_CWORD,
977 /* 195 65 "A" */ CWORD_CWORD_CWORD_CWORD,
978 /* 196 66 "B" */ CWORD_CWORD_CWORD_CWORD,
979 /* 197 67 "C" */ CWORD_CWORD_CWORD_CWORD,
980 /* 198 68 "D" */ CWORD_CWORD_CWORD_CWORD,
981 /* 199 69 "E" */ CWORD_CWORD_CWORD_CWORD,
982 /* 200 70 "F" */ CWORD_CWORD_CWORD_CWORD,
983 /* 201 71 "G" */ CWORD_CWORD_CWORD_CWORD,
984 /* 202 72 "H" */ CWORD_CWORD_CWORD_CWORD,
985 /* 203 73 "I" */ CWORD_CWORD_CWORD_CWORD,
986 /* 204 74 "J" */ CWORD_CWORD_CWORD_CWORD,
987 /* 205 75 "K" */ CWORD_CWORD_CWORD_CWORD,
988 /* 206 76 "L" */ CWORD_CWORD_CWORD_CWORD,
989 /* 207 77 "M" */ CWORD_CWORD_CWORD_CWORD,
990 /* 208 78 "N" */ CWORD_CWORD_CWORD_CWORD,
991 /* 209 79 "O" */ CWORD_CWORD_CWORD_CWORD,
992 /* 210 80 "P" */ CWORD_CWORD_CWORD_CWORD,
993 /* 211 81 "Q" */ CWORD_CWORD_CWORD_CWORD,
994 /* 212 82 "R" */ CWORD_CWORD_CWORD_CWORD,
995 /* 213 83 "S" */ CWORD_CWORD_CWORD_CWORD,
996 /* 214 84 "T" */ CWORD_CWORD_CWORD_CWORD,
997 /* 215 85 "U" */ CWORD_CWORD_CWORD_CWORD,
998 /* 216 86 "V" */ CWORD_CWORD_CWORD_CWORD,
999 /* 217 87 "W" */ CWORD_CWORD_CWORD_CWORD,
1000 /* 218 88 "X" */ CWORD_CWORD_CWORD_CWORD,
1001 /* 219 89 "Y" */ CWORD_CWORD_CWORD_CWORD,
1002 /* 220 90 "Z" */ CWORD_CWORD_CWORD_CWORD,
1003 /* 221 91 "[" */ CWORD_CCTL_CCTL_CWORD,
1004 /* 222 92 "\" */ CBACK_CBACK_CCTL_CBACK,
1005 /* 223 93 "]" */ CWORD_CCTL_CCTL_CWORD,
1006 /* 224 94 "^" */ CWORD_CWORD_CWORD_CWORD,
1007 /* 225 95 "_" */ CWORD_CWORD_CWORD_CWORD,
1008 /* 226 96 "`" */ CBQUOTE_CBQUOTE_CWORD_CBQUOTE,
1009 /* 227 97 "a" */ CWORD_CWORD_CWORD_CWORD,
1010 /* 228 98 "b" */ CWORD_CWORD_CWORD_CWORD,
1011 /* 229 99 "c" */ CWORD_CWORD_CWORD_CWORD,
1012 /* 230 100 "d" */ CWORD_CWORD_CWORD_CWORD,
1013 /* 231 101 "e" */ CWORD_CWORD_CWORD_CWORD,
1014 /* 232 102 "f" */ CWORD_CWORD_CWORD_CWORD,
1015 /* 233 103 "g" */ CWORD_CWORD_CWORD_CWORD,
1016 /* 234 104 "h" */ CWORD_CWORD_CWORD_CWORD,
1017 /* 235 105 "i" */ CWORD_CWORD_CWORD_CWORD,
1018 /* 236 106 "j" */ CWORD_CWORD_CWORD_CWORD,
1019 /* 237 107 "k" */ CWORD_CWORD_CWORD_CWORD,
1020 /* 238 108 "l" */ CWORD_CWORD_CWORD_CWORD,
1021 /* 239 109 "m" */ CWORD_CWORD_CWORD_CWORD,
1022 /* 240 110 "n" */ CWORD_CWORD_CWORD_CWORD,
1023 /* 241 111 "o" */ CWORD_CWORD_CWORD_CWORD,
1024 /* 242 112 "p" */ CWORD_CWORD_CWORD_CWORD,
1025 /* 243 113 "q" */ CWORD_CWORD_CWORD_CWORD,
1026 /* 244 114 "r" */ CWORD_CWORD_CWORD_CWORD,
1027 /* 245 115 "s" */ CWORD_CWORD_CWORD_CWORD,
1028 /* 246 116 "t" */ CWORD_CWORD_CWORD_CWORD,
1029 /* 247 117 "u" */ CWORD_CWORD_CWORD_CWORD,
1030 /* 248 118 "v" */ CWORD_CWORD_CWORD_CWORD,
1031 /* 249 119 "w" */ CWORD_CWORD_CWORD_CWORD,
1032 /* 250 120 "x" */ CWORD_CWORD_CWORD_CWORD,
1033 /* 251 121 "y" */ CWORD_CWORD_CWORD_CWORD,
1034 /* 252 122 "z" */ CWORD_CWORD_CWORD_CWORD,
1035 /* 253 123 "{" */ CWORD_CWORD_CWORD_CWORD,
1036 /* 254 124 "|" */ CSPCL_CWORD_CWORD_CWORD,
1037 /* 255 125 "}" */ CENDVAR_CENDVAR_CWORD_CENDVAR,
1038 /* 256 126 "~" */ CWORD_CCTL_CCTL_CWORD,
1039 /* 257 127 */ CWORD_CWORD_CWORD_CWORD,
1042 #endif /* USE_SIT_FUNCTION */
1045 /* first char is indicating which tokens mark the end of a list */
1046 static const char *const tokname_array[] = {
1061 #define KWDOFFSET 14
1062 /* the following are keywords */
1081 static const char *tokname(int tok)
1083 static char buf[16];
1087 sprintf(buf+(tok>=TSEMI), "%s%c",
1088 tokname_array[tok]+1, (tok>=TSEMI ? '"' : 0));
1092 static int plinno = 1; /* input line number */
1094 static int parselleft; /* copy of parsefile->lleft */
1096 static struct parsefile basepf; /* top level input file */
1097 static char basebuf[BUFSIZ]; /* buffer for top level input file */
1098 static struct parsefile *parsefile = &basepf; /* current input file */
1101 * NEOF is returned by parsecmd when it encounters an end of file. It
1102 * must be distinct from NULL, so we use the address of a variable that
1103 * happens to be handy.
1106 static int tokpushback; /* last token pushed back */
1107 #define NEOF ((union node *)&tokpushback)
1108 static int checkkwd; /* 1 == check for kwds, 2 == also eat newlines */
1111 static void error (const char *, ...) __attribute__((__noreturn__));
1112 static void exerror (int, const char *, ...) __attribute__((__noreturn__));
1113 static void shellexec (char **, char **, const char *, int)
1114 __attribute__((noreturn));
1115 static void exitshell (int) __attribute__((noreturn));
1117 static int goodname(const char *);
1118 static void ignoresig (int);
1119 static void onsig (int);
1120 static void dotrap (void);
1121 static int decode_signal (const char *, int);
1123 static void shprocvar(void);
1124 static void deletefuncs(void);
1125 static void setparam (char **);
1126 static void freeparam (volatile struct shparam *);
1128 /* reasons for skipping commands (see comment on breakcmd routine) */
1134 /* values of cmdtype */
1135 #define CMDUNKNOWN -1 /* no entry in table for command */
1136 #define CMDNORMAL 0 /* command is an executable program */
1137 #define CMDBUILTIN 1 /* command is a shell builtin */
1138 #define CMDFUNCTION 2 /* command is a shell function */
1140 #define DO_ERR 1 /* find_command prints errors */
1141 #define DO_ABS 2 /* find_command checks absolute paths */
1142 #define DO_NOFUN 4 /* find_command ignores functions */
1143 #define DO_BRUTE 8 /* find_command ignores hash table */
1150 #define VEXPORT 0x01 /* variable is exported */
1151 #define VREADONLY 0x02 /* variable cannot be modified */
1152 #define VSTRFIXED 0x04 /* variable struct is staticly allocated */
1153 #define VTEXTFIXED 0x08 /* text is staticly allocated */
1154 #define VSTACK 0x10 /* text is allocated on the stack */
1155 #define VUNSET 0x20 /* the variable is not set */
1156 #define VNOFUNC 0x40 /* don't call the callback function */
1160 struct var *next; /* next entry in hash list */
1161 int flags; /* flags are defined above */
1162 char *text; /* name=value */
1163 void (*func) (const char *);
1164 /* function to be called when */
1165 /* the variable gets set/unset */
1169 struct localvar *next; /* next local variable in list */
1170 struct var *vp; /* the variable that was made local */
1171 int flags; /* saved flags */
1172 char *text; /* saved text */
1176 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
1177 #define rmescapes(p) _rmescapes((p), 0)
1178 static char *_rmescapes (char *, int);
1180 static void rmescapes (char *);
1183 static int casematch (union node *, const char *);
1184 static void clearredir(void);
1185 static void popstring(void);
1186 static void readcmdfile (const char *);
1188 static int number (const char *);
1189 static int is_number (const char *, int *num);
1190 static char *single_quote (const char *);
1191 static int nextopt (const char *);
1193 static void redirect (union node *, int);
1194 static void popredir (void);
1195 static int dup_as_newfd (int, int);
1197 static void changepath(const char *newval);
1198 static void getoptsreset(const char *value);
1201 static int parsenleft; /* copy of parsefile->nleft */
1202 static char *parsenextc; /* copy of parsefile->nextc */
1203 static int rootpid; /* pid of main shell */
1204 static int rootshell; /* true if we aren't a child of the main shell */
1206 static const char spcstr[] = " ";
1207 static const char snlfmt[] = "%s\n";
1209 static int sstrnleft;
1210 static int herefd = -1;
1212 static struct localvar *localvars;
1214 static struct var vifs;
1215 static struct var vmail;
1216 static struct var vmpath;
1217 static struct var vpath;
1218 static struct var vps1;
1219 static struct var vps2;
1220 static struct var voptind;
1221 #ifdef BB_LOCALE_SUPPORT
1222 static struct var vlc_all;
1223 static struct var vlc_ctype;
1230 void (*func) (const char *);
1233 static const char defpathvar[] =
1234 "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
1235 #define defpath (defpathvar + 5)
1238 static const char defifsvar[] = "IFS= \t\n";
1239 #define defifs (defifsvar + 4)
1241 static const char defifs[] = " \t\n";
1244 static const struct varinit varinit[] = {
1246 { &vifs, VSTRFIXED|VTEXTFIXED, defifsvar,
1248 { &vifs, VSTRFIXED|VTEXTFIXED|VUNSET, "IFS=",
1251 { &vmail, VSTRFIXED|VTEXTFIXED|VUNSET, "MAIL=",
1253 { &vmpath, VSTRFIXED|VTEXTFIXED|VUNSET, "MAILPATH=",
1255 { &vpath, VSTRFIXED|VTEXTFIXED, defpathvar,
1258 * vps1 depends on uid
1260 { &vps2, VSTRFIXED|VTEXTFIXED, "PS2=> ",
1262 { &voptind, VSTRFIXED|VTEXTFIXED, "OPTIND=1",
1264 #ifdef BB_LOCALE_SUPPORT
1265 { &vlc_all, VSTRFIXED|VTEXTFIXED|VUNSET, "LC_ALL=",
1267 { &vlc_ctype, VSTRFIXED|VTEXTFIXED|VUNSET, "LC_CTYPE=",
1276 static struct var *vartab[VTABSIZE];
1279 * The following macros access the values of the above variables.
1280 * They have to skip over the name. They return the null string
1281 * for unset variables.
1284 #define ifsval() (vifs.text + 4)
1285 #define ifsset() ((vifs.flags & VUNSET) == 0)
1286 #define mailval() (vmail.text + 5)
1287 #define mpathval() (vmpath.text + 9)
1288 #define pathval() (vpath.text + 5)
1289 #define ps1val() (vps1.text + 4)
1290 #define ps2val() (vps2.text + 4)
1291 #define optindval() (voptind.text + 7)
1293 #define mpathset() ((vmpath.flags & VUNSET) == 0)
1295 static void initvar (void);
1296 static void setvar (const char *, const char *, int);
1297 static void setvareq (char *, int);
1298 static void listsetvar (struct strlist *);
1299 static const char *lookupvar (const char *);
1300 static const char *bltinlookup (const char *);
1301 static char **environment (void);
1302 static int showvarscmd (int, char **);
1303 static void mklocal (char *);
1304 static void poplocalvars (void);
1305 static int unsetvar (const char *);
1306 static int varequal (const char *, const char *);
1309 static char *arg0; /* value of $0 */
1310 static struct shparam shellparam; /* current positional parameters */
1311 static char **argptr; /* argument list for builtin commands */
1312 static char *optionarg; /* set by nextopt (like getopt) */
1313 static char *optptr; /* used by nextopt */
1314 static char *minusc; /* argument to -c option */
1319 #define ALIASINUSE 1
1331 static struct alias *atab[ATABSIZE];
1333 static void setalias (char *, char *);
1334 static struct alias **hashalias (const char *);
1335 static struct alias *freealias (struct alias *);
1336 static struct alias **__lookupalias (const char *);
1342 struct alias *ap, **app;
1344 app = __lookupalias(name);
1348 if (!(ap->flag & ALIASINUSE)) {
1351 ap->val = savestr(val);
1352 ap->flag &= ~ALIASDEAD;
1355 ap = ckmalloc(sizeof (struct alias));
1356 ap->name = savestr(name);
1357 ap->val = savestr(val);
1370 app = __lookupalias(name);
1374 *app = freealias(*app);
1385 struct alias *ap, **app;
1389 for (i = 0; i < ATABSIZE; i++) {
1391 for (ap = *app; ap; ap = *app) {
1392 *app = freealias(*app);
1401 static struct alias *
1402 lookupalias(const char *name, int check)
1404 struct alias *ap = *__lookupalias(name);
1406 if (check && ap && (ap->flag & ALIASINUSE))
1412 printalias(const struct alias *ap) {
1415 p = single_quote(ap->val);
1416 printf("alias %s=%s\n", ap->name, p);
1422 * TODO - sort output
1425 aliascmd(int argc, char **argv)
1434 for (i = 0; i < ATABSIZE; i++)
1435 for (ap = atab[i]; ap; ap = ap->next) {
1440 while ((n = *++argv) != NULL) {
1441 if ((v = strchr(n+1, '=')) == NULL) { /* n+1: funny ksh stuff */
1442 if ((ap = *__lookupalias(n)) == NULL) {
1443 out2fmt("%s: %s not found\n", "alias", n);
1458 unaliascmd(int argc, char **argv)
1462 while ((i = nextopt("a")) != '\0') {
1468 for (i = 0; *argptr; argptr++) {
1469 if (unalias(*argptr)) {
1470 out2fmt("%s: %s not found\n", "unalias", *argptr);
1478 static struct alias **
1482 unsigned int hashval;
1487 return &atab[hashval % ATABSIZE];
1490 static struct alias *
1491 freealias(struct alias *ap) {
1494 if (ap->flag & ALIASINUSE) {
1495 ap->flag |= ALIASDEAD;
1507 static struct alias **
1508 __lookupalias(const char *name) {
1509 struct alias **app = hashalias(name);
1511 for (; *app; app = &(*app)->next) {
1512 if (equal(name, (*app)->name)) {
1521 #ifdef ASH_MATH_SUPPORT
1522 /* The generated file arith.c has been replaced with a custom hand
1523 * written implementation written by Aaron Lehmann <aaronl@vitelus.com>.
1524 * This is now part of libbb, so that it can be used by all the shells
1526 #define ARITH_NUM 257
1527 #define ARITH_LPAREN 258
1528 #define ARITH_RPAREN 259
1529 #define ARITH_OR 260
1530 #define ARITH_AND 261
1531 #define ARITH_BOR 262
1532 #define ARITH_BXOR 263
1533 #define ARITH_BAND 264
1534 #define ARITH_EQ 265
1535 #define ARITH_NE 266
1536 #define ARITH_LT 267
1537 #define ARITH_GT 268
1538 #define ARITH_GE 269
1539 #define ARITH_LE 270
1540 #define ARITH_LSHIFT 271
1541 #define ARITH_RSHIFT 272
1542 #define ARITH_ADD 273
1543 #define ARITH_SUB 274
1544 #define ARITH_MUL 275
1545 #define ARITH_DIV 276
1546 #define ARITH_REM 277
1547 #define ARITH_UNARYMINUS 278
1548 #define ARITH_UNARYPLUS 279
1549 #define ARITH_NOT 280
1550 #define ARITH_BNOT 281
1552 static void expari (int);
1555 static char *trap[NSIG]; /* trap handler commands */
1556 static char sigmode[NSIG - 1]; /* current value of signal */
1557 static char gotsig[NSIG - 1]; /* indicates specified signal received */
1558 static int pendingsigs; /* indicates some signal received */
1561 * This file was generated by the mkbuiltins program.
1565 static int bgcmd (int, char **);
1566 static int fgcmd (int, char **);
1567 static int killcmd (int, char **);
1569 static int bltincmd (int, char **);
1570 static int cdcmd (int, char **);
1571 static int breakcmd (int, char **);
1573 static int commandcmd (int, char **);
1575 static int dotcmd (int, char **);
1576 static int evalcmd (int, char **);
1577 static int execcmd (int, char **);
1578 static int exitcmd (int, char **);
1579 static int exportcmd (int, char **);
1580 static int histcmd (int, char **);
1581 static int hashcmd (int, char **);
1582 static int helpcmd (int, char **);
1583 static int jobscmd (int, char **);
1584 static int localcmd (int, char **);
1586 static int pwdcmd (int, char **);
1588 static int readcmd (int, char **);
1589 static int returncmd (int, char **);
1590 static int setcmd (int, char **);
1591 static int setvarcmd (int, char **);
1592 static int shiftcmd (int, char **);
1593 static int trapcmd (int, char **);
1594 static int umaskcmd (int, char **);
1596 static int aliascmd (int, char **);
1597 static int unaliascmd (int, char **);
1599 static int unsetcmd (int, char **);
1600 static int waitcmd (int, char **);
1601 static int ulimitcmd (int, char **);
1602 static int timescmd (int, char **);
1603 #ifdef ASH_MATH_SUPPORT
1604 static int letcmd (int, char **);
1606 static int typecmd (int, char **);
1608 static int getoptscmd (int, char **);
1611 #ifndef BB_TRUE_FALSE
1612 static int true_main (int, char **);
1613 static int false_main (int, char **);
1616 static void setpwd (const char *, int);
1619 #define BUILTIN_NOSPEC "0"
1620 #define BUILTIN_SPECIAL "1"
1621 #define BUILTIN_REGULAR "2"
1622 #define BUILTIN_ASSIGN "4"
1623 #define BUILTIN_SPEC_ASSG "5"
1624 #define BUILTIN_REG_ASSG "6"
1626 #define IS_BUILTIN_SPECIAL(builtincmd) ((builtincmd)->name[0] & 1)
1627 #define IS_BUILTIN_REGULAR(builtincmd) ((builtincmd)->name[0] & 2)
1628 #define IS_BUILTIN_ASSIGN(builtincmd) ((builtincmd)->name[0] & 4)
1632 int (*const builtinfunc) (int, char **);
1637 /* It is CRUCIAL that this listing be kept in ascii order, otherwise
1638 * the binary search in find_builtin() will stop working. If you value
1639 * your kneecaps, you'll be sure to *make sure* that any changes made
1640 * to this array result in the listing remaining in ascii order. You
1643 static const struct builtincmd builtincmds[] = {
1644 { BUILTIN_SPECIAL ".", dotcmd }, /* first, see declare DOTCMD */
1645 { BUILTIN_SPECIAL ":", true_main },
1647 { BUILTIN_REG_ASSG "alias", aliascmd },
1650 { BUILTIN_REGULAR "bg", bgcmd },
1652 { BUILTIN_SPECIAL "break", breakcmd },
1653 { BUILTIN_SPECIAL "builtin", bltincmd },
1654 { BUILTIN_REGULAR "cd", cdcmd },
1655 { BUILTIN_NOSPEC "chdir", cdcmd },
1657 { BUILTIN_REGULAR "command", commandcmd },
1659 { BUILTIN_SPECIAL "continue", breakcmd },
1660 { BUILTIN_SPECIAL "eval", evalcmd },
1661 { BUILTIN_SPECIAL "exec", execcmd },
1662 { BUILTIN_SPECIAL "exit", exitcmd },
1663 { BUILTIN_SPEC_ASSG "export", exportcmd },
1664 { BUILTIN_REGULAR "false", false_main },
1665 { BUILTIN_REGULAR "fc", histcmd },
1667 { BUILTIN_REGULAR "fg", fgcmd },
1670 { BUILTIN_REGULAR "getopts", getoptscmd },
1672 { BUILTIN_NOSPEC "hash", hashcmd },
1673 { BUILTIN_NOSPEC "help", helpcmd },
1674 { BUILTIN_REGULAR "jobs", jobscmd },
1676 { BUILTIN_REGULAR "kill", killcmd },
1678 #ifdef ASH_MATH_SUPPORT
1679 { BUILTIN_REGULAR "let", letcmd },
1681 { BUILTIN_ASSIGN "local", localcmd },
1683 { BUILTIN_NOSPEC "pwd", pwdcmd },
1685 { BUILTIN_REGULAR "read", readcmd },
1686 { BUILTIN_SPEC_ASSG "readonly", exportcmd },
1687 { BUILTIN_SPECIAL "return", returncmd },
1688 { BUILTIN_SPECIAL "set", setcmd },
1689 { BUILTIN_NOSPEC "setvar", setvarcmd },
1690 { BUILTIN_SPECIAL "shift", shiftcmd },
1691 { BUILTIN_SPECIAL "times", timescmd },
1692 { BUILTIN_SPECIAL "trap", trapcmd },
1693 { BUILTIN_REGULAR "true", true_main },
1694 { BUILTIN_NOSPEC "type", typecmd },
1695 { BUILTIN_NOSPEC "ulimit", ulimitcmd },
1696 { BUILTIN_REGULAR "umask", umaskcmd },
1698 { BUILTIN_REGULAR "unalias", unaliascmd },
1700 { BUILTIN_SPECIAL "unset", unsetcmd },
1701 { BUILTIN_REGULAR "wait", waitcmd },
1703 #define NUMBUILTINS (sizeof (builtincmds) / sizeof (struct builtincmd) )
1705 #define DOTCMD &builtincmds[0]
1706 static struct builtincmd *BLTINCMD;
1707 static struct builtincmd *EXECCMD;
1708 static struct builtincmd *EVALCMD;
1711 #define JOBSTOPPED 1 /* all procs are stopped */
1712 #define JOBDONE 2 /* all procs are completed */
1715 * A job structure contains information about a job. A job is either a
1716 * single process or a set of processes contained in a pipeline. In the
1717 * latter case, pidlist will be non-NULL, and will point to a -1 terminated
1722 pid_t pid; /* process id */
1723 int status; /* status flags (defined above) */
1724 char *cmd; /* text of command being run */
1728 static int job_warning; /* user was warned about stopped jobs */
1731 static void setjobctl(int enable);
1733 #define setjobctl(on) /* do nothing */
1738 struct procstat ps0; /* status of process */
1739 struct procstat *ps; /* status or processes when more than one */
1740 short nprocs; /* number of processes */
1741 short pgrp; /* process group of this job */
1742 char state; /* true if job is finished */
1743 char used; /* true if this entry is in used */
1744 char changed; /* true if status has changed */
1746 char jobctl; /* job running under job control */
1750 static struct job *jobtab; /* array of jobs */
1751 static int njobs; /* size of array */
1752 static int backgndpid = -1; /* pid of last background process */
1754 static int initialpgrp; /* pgrp of shell on invocation */
1755 static int curjob; /* current job */
1758 static int intreceived;
1760 static struct job *makejob (const union node *, int);
1761 static int forkshell (struct job *, const union node *, int);
1762 static int waitforjob (struct job *);
1764 static int docd (char *, int);
1765 static char *getcomponent (void);
1766 static void updatepwd (const char *);
1767 static void getpwd (void);
1769 static char *padvance (const char **, const char *);
1771 static char nullstr[1]; /* zero length string */
1772 static char *curdir = nullstr; /* current working directory */
1773 static char *cdcomppath;
1787 if ((dest = *argptr) == NULL && (dest = bltinlookup("HOME")) == NULL)
1788 error("HOME not set");
1791 if (dest[0] == '-' && dest[1] == '\0') {
1792 dest = bltinlookup("OLDPWD");
1793 if (!dest || !*dest) {
1802 if (*dest == '/' || (path = bltinlookup("CDPATH")) == NULL)
1804 while ((p = padvance(&path, dest)) != NULL) {
1805 if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) {
1810 if (p[0] == '.' && p[1] == '/' && p[2] != '\0')
1812 print = strcmp(p, dest);
1814 if (docd(p, print) >= 0)
1819 error("can't cd to %s", dest);
1825 * Actually do the chdir. In an interactive shell, print the
1826 * directory name if "print" is nonzero.
1841 TRACE(("docd(\"%s\", %d) called\n", dest, print));
1844 * Check each component of the path. If we find a symlink or
1845 * something we can't stat, clear curdir to force a getcwd()
1846 * next time we get the value of the current directory.
1849 cdcomppath = sstrdup(dest);
1856 while ((q = getcomponent()) != NULL) {
1857 if (q[0] == '\0' || (q[0] == '.' && q[1] == '\0'))
1865 if (equal(component, ".."))
1868 if ((lstat(stackblock(), &statb) < 0)
1869 || (S_ISLNK(statb.st_mode))) {
1877 if (chdir(dest) < 0) {
1881 updatepwd(badstat ? NULL : dest);
1884 printf(snlfmt, curdir);
1890 * Get the next component of the path name pointed to by cdcomppath.
1891 * This routine overwrites the string pointed to by cdcomppath.
1899 if ((p = cdcomppath) == NULL)
1902 while (*p != '/' && *p != '\0')
1916 * Update curdir (the name of the current directory) in response to a
1917 * cd command. We also call hashcd to let the routines in exec.c know
1918 * that the current directory has changed.
1921 static void hashcd (void);
1924 updatepwd(const char *dir)
1930 hashcd(); /* update command hash table */
1933 * If our argument is NULL, we don't know the current directory
1934 * any more because we traversed a symbolic link or something
1935 * we couldn't stat().
1937 if (dir == NULL || curdir == nullstr) {
1942 cdcomppath = sstrdup(dir);
1951 while ((p = getcomponent()) != NULL) {
1952 if (equal(p, "..")) {
1953 while (new > stackblock() && (STUNPUTC(new), *new) != '/');
1954 } else if (*p != '\0' && ! equal(p, ".")) {
1960 if (new == stackblock())
1963 setpwd(stackblock(), 1);
1973 printf(snlfmt, curdir);
1979 * Find out what the current directory is. If we already know the current
1980 * directory, this routine returns immediately.
1985 curdir = xgetcwd(0);
1991 setpwd(const char *val, int setold)
1994 setvar("OLDPWD", curdir, VEXPORT);
1997 if (curdir != nullstr) {
2004 curdir = savestr(val);
2007 setvar("PWD", curdir, VEXPORT);
2011 * Errors and exceptions.
2015 * Code to handle exceptions in C.
2019 * We enclose jmp_buf in a structure so that we can declare pointers to
2020 * jump locations. The global variable handler contains the location to
2021 * jump to when an exception occurs, and the global variable exception
2022 * contains a code identifying the exeception. To implement nested
2023 * exception handlers, the user should save the value of handler on entry
2024 * to an inner scope, set handler to point to a jmploc structure for the
2025 * inner scope, and restore handler on exit from the scope.
2033 #define EXINT 0 /* SIGINT received */
2034 #define EXERROR 1 /* a generic error */
2035 #define EXSHELLPROC 2 /* execute a shell procedure */
2036 #define EXEXEC 3 /* command execution failed */
2038 static struct jmploc *handler;
2039 static int exception;
2041 static void exverror (int, const char *, va_list)
2042 __attribute__((__noreturn__));
2045 * Called to raise an exception. Since C doesn't include exceptions, we
2046 * just do a longjmp to the exception handler. The type of exception is
2047 * stored in the global variable "exception".
2050 static void exraise (int) __attribute__((__noreturn__));
2056 if (handler == NULL)
2061 longjmp(handler->loc, 1);
2066 * Called from trap.c when a SIGINT is received. (If the user specifies
2067 * that SIGINT is to be trapped or ignored using the trap builtin, then
2068 * this routine is not called.) Suppressint is nonzero when interrupts
2069 * are held using the INTOFF macro. The call to _exit is necessary because
2070 * there is a short period after a fork before the signal handlers are
2071 * set to the appropriate value for the child. (The test for iflag is
2072 * just defensive programming.)
2084 sigemptyset(&mysigset);
2085 sigprocmask(SIG_SETMASK, &mysigset, NULL);
2086 if (rootshell && iflag)
2089 signal(SIGINT, SIG_DFL);
2096 static char *commandname; /* currently executing command */
2099 * Exverror is called to raise the error exception. If the first argument
2100 * is not NULL then error prints an error message using printf style
2101 * formatting. It then raises the error exception.
2104 exverror(int cond, const char *msg, va_list ap)
2111 TRACE(("exverror(%d, \"%s\") pid=%d\n", cond, msg, getpid()));
2113 TRACE(("exverror(%d, NULL) pid=%d\n", cond, getpid()));
2117 out2fmt("%s: ", commandname);
2118 vfprintf(stderr, msg, ap);
2127 error(const char *msg, ...)
2131 exverror(EXERROR, msg, ap);
2138 exerror(int cond, const char *msg, ...)
2142 exverror(cond, msg, ap);
2150 * Table of error messages.
2154 short errcode; /* error number */
2155 char action; /* operation which encountered the error */
2159 * Types of operations (passed to the errmsg routine).
2162 #define E_OPEN 01 /* opening a file */
2163 #define E_CREAT 02 /* creating a file */
2164 #define E_EXEC 04 /* executing a program */
2166 #define ALL (E_OPEN|E_CREAT|E_EXEC)
2168 static const struct errname errormsg[] = {
2173 { ENOENT, E_CREAT },
2175 { ENOTDIR, E_OPEN },
2176 { ENOTDIR, E_CREAT },
2177 { ENOTDIR, E_EXEC },
2179 { EEXIST, E_CREAT },
2218 { ELIBACC, E_EXEC },
2222 #define ERRNAME_SIZE (sizeof(errormsg)/sizeof(struct errname))
2225 * Return a string describing an error. The returned string may be a
2226 * pointer to a static buffer that will be overwritten on the next call.
2227 * Action describes the operation that got the error.
2231 errmsg(int e, int action)
2233 struct errname const *ep;
2234 static char buf[12];
2236 for (ep = errormsg ; ep < errormsg+ERRNAME_SIZE; ep++) {
2237 if (ep->errcode == e && (ep->action & action) != 0)
2241 snprintf(buf, sizeof buf, "error %d", e);
2246 #ifdef ASH_OPTIMIZE_FOR_SIZE
2249 if (--suppressint == 0 && intpending) {
2253 static void forceinton (void) {
2260 /* flags in argument to evaltree */
2261 #define EV_EXIT 01 /* exit after evaluating tree */
2262 #define EV_TESTED 02 /* exit status is checked; ignore -e flag */
2263 #define EV_BACKCMD 04 /* command executing within back quotes */
2265 static int evalskip; /* set if we are skipping commands */
2266 static int skipcount; /* number of levels to skip */
2267 static int loopnest; /* current loop nesting level */
2268 static int funcnest; /* depth of function calls */
2271 static struct strlist *cmdenviron; /* environment for builtin command */
2272 static int exitstatus; /* exit status of last command */
2273 static int oexitstatus; /* saved exit status */
2275 static void evalsubshell (const union node *, int);
2276 static void expredir (union node *);
2277 static void prehash (union node *);
2278 static void eprintlist (struct strlist *);
2280 static union node *parsecmd(int);
2282 * Called to reset things after an exception.
2286 * The eval commmand.
2288 static void evalstring (char *, int);
2302 STARTSTACKSTR(concat);
2306 STPUTC(*p++, concat);
2307 if ((p = *ap++) == NULL)
2309 STPUTC(' ', concat);
2311 STPUTC('\0', concat);
2312 p = grabstackstr(concat);
2314 evalstring(p, EV_TESTED);
2320 * Execute a command or commands contained in a string.
2323 static void evaltree (union node *, int);
2324 static void setinputstring (char *);
2325 static void popfile (void);
2326 static void setstackmark(struct stackmark *mark);
2327 static void popstackmark(struct stackmark *mark);
2331 evalstring(char *s, int flag)
2334 struct stackmark smark;
2336 setstackmark(&smark);
2338 while ((n = parsecmd(0)) != NEOF) {
2340 popstackmark(&smark);
2343 popstackmark(&smark);
2346 static struct builtincmd *find_builtin (const char *);
2347 static void expandarg (union node *, struct arglist *, int);
2348 static void calcsize (const union node *);
2349 static union node *copynode (const union node *);
2352 * Make a copy of a parse tree.
2355 static int funcblocksize; /* size of structures in function */
2356 static int funcstringsize; /* size of strings in node */
2357 static pointer funcblock; /* block to allocate function from */
2358 static char *funcstring; /* block to allocate strings from */
2361 static inline union node *
2362 copyfunc(union node *n)
2369 funcblock = ckmalloc(funcblocksize + funcstringsize);
2370 funcstring = (char *) funcblock + funcblocksize;
2375 * Free a parse tree.
2379 freefunc(union node *n)
2387 * Add a new command entry, replacing any existing command entry for
2392 addcmdentry(char *name, struct cmdentry *entry)
2394 struct tblentry *cmdp;
2397 cmdp = cmdlookup(name, 1);
2398 if (cmdp->cmdtype == CMDFUNCTION) {
2399 freefunc(cmdp->param.func);
2401 cmdp->cmdtype = entry->cmdtype;
2402 cmdp->param = entry->u;
2407 evalloop(const union node *n, int flags)
2414 evaltree(n->nbinary.ch1, EV_TESTED);
2416 skipping: if (evalskip == SKIPCONT && --skipcount <= 0) {
2420 if (evalskip == SKIPBREAK && --skipcount <= 0)
2424 if (n->type == NWHILE) {
2425 if (exitstatus != 0)
2428 if (exitstatus == 0)
2431 evaltree(n->nbinary.ch2, flags & EV_TESTED);
2432 status = exitstatus;
2437 exitstatus = status;
2441 evalfor(const union node *n, int flags)
2443 struct arglist arglist;
2446 struct stackmark smark;
2448 setstackmark(&smark);
2449 arglist.lastp = &arglist.list;
2450 for (argp = n->nfor.args ; argp ; argp = argp->narg.next) {
2451 oexitstatus = exitstatus;
2452 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE | EXP_RECORD);
2456 *arglist.lastp = NULL;
2460 for (sp = arglist.list ; sp ; sp = sp->next) {
2461 setvar(n->nfor.var, sp->text, 0);
2462 evaltree(n->nfor.body, flags & EV_TESTED);
2464 if (evalskip == SKIPCONT && --skipcount <= 0) {
2468 if (evalskip == SKIPBREAK && --skipcount <= 0)
2475 popstackmark(&smark);
2479 evalcase(const union node *n, int flags)
2483 struct arglist arglist;
2484 struct stackmark smark;
2486 setstackmark(&smark);
2487 arglist.lastp = &arglist.list;
2488 oexitstatus = exitstatus;
2489 expandarg(n->ncase.expr, &arglist, EXP_TILDE);
2490 for (cp = n->ncase.cases ; cp && evalskip == 0 ; cp = cp->nclist.next) {
2491 for (patp = cp->nclist.pattern ; patp ; patp = patp->narg.next) {
2492 if (casematch(patp, arglist.list->text)) {
2493 if (evalskip == 0) {
2494 evaltree(cp->nclist.body, flags);
2501 popstackmark(&smark);
2505 * Evaluate a pipeline. All the processes in the pipeline are children
2506 * of the process creating the pipeline. (This differs from some versions
2507 * of the shell, which make the last process in a pipeline the parent
2511 static inline void evalpipe(union node *n)
2514 struct nodelist *lp;
2519 TRACE(("evalpipe(0x%lx) called\n", (long)n));
2521 for (lp = n->npipe.cmdlist ; lp ; lp = lp->next)
2524 jp = makejob(n, pipelen);
2526 for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
2530 if (pipe(pip) < 0) {
2532 error("Pipe call failed");
2535 if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) {
2539 dup_as_newfd(prevfd, 0);
2551 dup_as_newfd(pip[1], 1);
2555 evaltree(lp->n, EV_EXIT);
2563 if (n->npipe.backgnd == 0) {
2565 exitstatus = waitforjob(jp);
2566 TRACE(("evalpipe: job done exit status %d\n", exitstatus));
2571 static void find_command (const char *, struct cmdentry *, int, const char *);
2574 isassignment(const char *word) {
2575 if (!is_name(*word)) {
2580 } while (is_in_name(*word));
2581 return *word == '=';
2586 evalcommand(union node *cmd, int flags)
2588 struct stackmark smark;
2590 struct arglist arglist;
2591 struct arglist varlist;
2597 struct cmdentry cmdentry;
2599 char *volatile savecmdname;
2600 volatile struct shparam saveparam;
2601 struct localvar *volatile savelocalvars;
2605 const struct builtincmd *firstbltin;
2606 struct jmploc *volatile savehandler;
2607 struct jmploc jmploc;
2609 /* Avoid longjmp clobbering */
2616 /* First expand the arguments. */
2617 TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
2618 setstackmark(&smark);
2619 arglist.lastp = &arglist.list;
2620 varlist.lastp = &varlist.list;
2622 oexitstatus = exitstatus;
2625 for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
2626 expandarg(argp, &varlist, EXP_VARTILDE);
2629 argp = cmd->ncmd.args; argp && !arglist.list;
2630 argp = argp->narg.next
2632 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
2635 struct builtincmd *bcmd;
2637 bcmd = find_builtin(arglist.list->text);
2638 pseudovarflag = bcmd && IS_BUILTIN_ASSIGN(bcmd);
2639 for (; argp; argp = argp->narg.next) {
2640 if (pseudovarflag && isassignment(argp->narg.text)) {
2641 expandarg(argp, &arglist, EXP_VARTILDE);
2644 expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
2647 *arglist.lastp = NULL;
2648 *varlist.lastp = NULL;
2649 expredir(cmd->ncmd.redirect);
2651 for (sp = arglist.list ; sp ; sp = sp->next)
2653 argv = stalloc(sizeof (char *) * (argc + 1));
2655 for (sp = arglist.list ; sp ; sp = sp->next) {
2656 TRACE(("evalcommand arg: %s\n", sp->text));
2661 if (iflag && funcnest == 0 && argc > 0)
2665 /* Print the command if xflag is set. */
2668 eprintlist(varlist.list);
2669 eprintlist(arglist.list);
2673 /* Now locate the command. */
2675 cmdentry.cmdtype = CMDBUILTIN;
2676 firstbltin = cmdentry.u.cmd = BLTINCMD;
2678 const char *oldpath;
2679 int findflag = DO_ERR;
2683 * Modify the command lookup path, if a PATH= assignment
2686 for (sp = varlist.list ; sp ; sp = sp->next)
2687 if (varequal(sp->text, defpathvar)) {
2688 path = sp->text + 5;
2689 findflag |= DO_BRUTE;
2692 oldfindflag = findflag;
2695 find_command(argv[0], &cmdentry, findflag, path);
2696 if (cmdentry.cmdtype == CMDUNKNOWN) { /* command not found */
2700 /* implement bltin and command here */
2701 if (cmdentry.cmdtype != CMDBUILTIN) {
2705 firstbltin = cmdentry.u.cmd;
2707 if (cmdentry.u.cmd == BLTINCMD) {
2709 struct builtincmd *bcmd;
2714 if (!(bcmd = find_builtin(*argv))) {
2715 out2fmt("%s: not found\n", *argv);
2719 cmdentry.u.cmd = bcmd;
2720 if (bcmd != BLTINCMD)
2724 if (cmdentry.u.cmd == find_builtin("command")) {
2729 if (*argv[0] == '-') {
2730 if (!equal(argv[0], "-p")) {
2740 findflag |= DO_BRUTE;
2743 findflag = oldfindflag;
2745 findflag |= DO_NOFUN;
2753 /* Fork off a child process if necessary. */
2754 if (cmd->ncmd.backgnd
2755 || (cmdentry.cmdtype == CMDNORMAL && (flags & EV_EXIT) == 0)
2757 jp = makejob(cmd, 1);
2758 mode = cmd->ncmd.backgnd;
2759 if (forkshell(jp, cmd, mode) != 0)
2760 goto parent; /* at end of routine */
2764 /* This is the child process if a fork occurred. */
2765 /* Execute the command. */
2766 if (cmdentry.cmdtype == CMDFUNCTION) {
2768 trputs("Shell function: "); trargs(argv);
2770 exitstatus = oexitstatus;
2771 redirect(cmd->ncmd.redirect, REDIR_PUSH);
2772 saveparam = shellparam;
2773 shellparam.malloc = 0;
2774 shellparam.nparam = argc - 1;
2775 shellparam.p = argv + 1;
2777 savelocalvars = localvars;
2780 if (setjmp(jmploc.loc)) {
2781 if (exception == EXSHELLPROC) {
2782 freeparam((volatile struct shparam *)
2785 saveparam.optind = shellparam.optind;
2786 saveparam.optoff = shellparam.optoff;
2787 freeparam(&shellparam);
2788 shellparam = saveparam;
2791 localvars = savelocalvars;
2792 handler = savehandler;
2793 longjmp(handler->loc, 1);
2795 savehandler = handler;
2797 for (sp = varlist.list ; sp ; sp = sp->next)
2800 evaltree(cmdentry.u.func, flags & EV_TESTED);
2804 localvars = savelocalvars;
2805 saveparam.optind = shellparam.optind;
2806 saveparam.optoff = shellparam.optoff;
2807 freeparam(&shellparam);
2808 shellparam = saveparam;
2809 handler = savehandler;
2812 if (evalskip == SKIPFUNC) {
2816 if (flags & EV_EXIT)
2817 exitshell(exitstatus);
2818 } else if (cmdentry.cmdtype == CMDBUILTIN) {
2820 trputs("builtin command: "); trargs(argv);
2822 mode = (cmdentry.u.cmd == EXECCMD)? 0 : REDIR_PUSH;
2823 redirect(cmd->ncmd.redirect, mode);
2824 savecmdname = commandname;
2825 if (IS_BUILTIN_SPECIAL(firstbltin)) {
2826 listsetvar(varlist.list);
2828 cmdenviron = varlist.list;
2831 if (setjmp(jmploc.loc)) {
2833 exitstatus = (e == EXINT)? SIGINT+128 : 2;
2836 savehandler = handler;
2838 commandname = argv[0];
2840 optptr = NULL; /* initialize nextopt */
2841 exitstatus = (*cmdentry.u.cmd->builtinfunc)(argc, argv);
2845 if (e != EXSHELLPROC) {
2846 commandname = savecmdname;
2847 if (flags & EV_EXIT)
2848 exitshell(exitstatus);
2850 handler = savehandler;
2852 if ((e != EXERROR && e != EXEXEC)
2853 || cmdentry.u.cmd == BLTINCMD
2854 || cmdentry.u.cmd == DOTCMD
2855 || cmdentry.u.cmd == EVALCMD
2856 || cmdentry.u.cmd == EXECCMD)
2860 if (cmdentry.u.cmd != EXECCMD)
2864 trputs("normal command: "); trargs(argv);
2866 redirect(cmd->ncmd.redirect, 0);
2868 for (sp = varlist.list ; sp ; sp = sp->next)
2869 setvareq(sp->text, VEXPORT|VSTACK);
2870 envp = environment();
2871 shellexec(argv, envp, path, cmdentry.u.index);
2875 parent: /* parent process gets here (if we forked) */
2876 if (mode == 0) { /* argument to fork */
2878 exitstatus = waitforjob(jp);
2884 setvar("_", lastarg, 0);
2885 popstackmark(&smark);
2889 * Evaluate a parse tree. The value is left in the global variable
2899 TRACE(("evaltree(NULL) called\n"));
2902 TRACE(("evaltree(0x%lx: %d) called\n", (long)n, n->type));
2905 evaltree(n->nbinary.ch1, flags & EV_TESTED);
2908 evaltree(n->nbinary.ch2, flags);
2911 evaltree(n->nbinary.ch1, EV_TESTED);
2912 if (evalskip || exitstatus != 0)
2914 evaltree(n->nbinary.ch2, flags);
2917 evaltree(n->nbinary.ch1, EV_TESTED);
2918 if (evalskip || exitstatus == 0)
2920 evaltree(n->nbinary.ch2, flags);
2923 expredir(n->nredir.redirect);
2924 redirect(n->nredir.redirect, REDIR_PUSH);
2925 evaltree(n->nredir.n, flags);
2929 evalsubshell(n, flags);
2932 evalsubshell(n, flags);
2935 evaltree(n->nif.test, EV_TESTED);
2938 if (exitstatus == 0)
2939 evaltree(n->nif.ifpart, flags);
2940 else if (n->nif.elsepart)
2941 evaltree(n->nif.elsepart, flags);
2957 struct builtincmd *bcmd;
2958 struct cmdentry entry;
2960 (bcmd = find_builtin(n->narg.text)) &&
2961 IS_BUILTIN_SPECIAL(bcmd)
2963 out2fmt("%s is a special built-in\n", n->narg.text);
2967 entry.cmdtype = CMDFUNCTION;
2968 entry.u.func = copyfunc(n->narg.next);
2969 addcmdentry(n->narg.text, &entry);
2974 evaltree(n->nnot.com, EV_TESTED);
2975 exitstatus = !exitstatus;
2983 evalcommand(n, flags);
2988 printf("Node type = %d\n", n->type);
2997 (checkexit && eflag && exitstatus && !(flags & EV_TESTED))
2999 exitshell(exitstatus);
3003 * Kick off a subshell to evaluate a tree.
3007 evalsubshell(const union node *n, int flags)
3010 int backgnd = (n->type == NBACKGND);
3012 expredir(n->nredir.redirect);
3014 if (forkshell(jp, n, backgnd) == 0) {
3016 flags &=~ EV_TESTED;
3017 redirect(n->nredir.redirect, 0);
3018 evaltree(n->nredir.n, flags | EV_EXIT); /* never returns */
3022 exitstatus = waitforjob(jp);
3028 * Compute the names of the files in a redirection list.
3031 static void fixredir(union node *n, const char *text, int err);
3034 expredir(union node *n)
3038 for (redir = n ; redir ; redir = redir->nfile.next) {
3040 fn.lastp = &fn.list;
3041 oexitstatus = exitstatus;
3042 switch (redir->type) {
3048 expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
3049 redir->nfile.expfname = fn.list->text;
3053 if (redir->ndup.vname) {
3054 expandarg(redir->ndup.vname, &fn, EXP_FULL | EXP_TILDE);
3055 fixredir(redir, fn.list->text, 1);
3064 * Execute a command inside back quotes. If it's a builtin command, we
3065 * want to save its output in a block obtained from malloc. Otherwise
3066 * we fork off a subprocess and get the output of the command via a pipe.
3067 * Should be called with interrupts off.
3071 evalbackcmd(union node *n, struct backcmd *result)
3075 struct stackmark smark; /* unnecessary */
3077 setstackmark(&smark);
3088 error("Pipe call failed");
3090 if (forkshell(jp, n, FORK_NOJOB) == 0) {
3095 dup_as_newfd(pip[1], 1);
3099 evaltree(n, EV_EXIT);
3102 result->fd = pip[0];
3105 popstackmark(&smark);
3106 TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n",
3107 result->fd, result->buf, result->nleft, result->jp));
3112 * Execute a simple command.
3116 * Search for a command. This is called before we fork so that the
3117 * location of the command will be available in the parent as well as
3118 * the child. The check for "goodname" is an overly conservative
3119 * check that the name will not be subject to expansion.
3126 struct cmdentry entry;
3128 if (n->type == NCMD && n->ncmd.args)
3129 if (goodname(n->ncmd.args->narg.text))
3130 find_command(n->ncmd.args->narg.text, &entry, 0,
3136 * Builtin commands. Builtin commands whose functions are closely
3137 * tied to evaluation are implemented here.
3141 * No command given, or a bltin command with no arguments. Set the
3142 * specified variables.
3146 bltincmd(argc, argv)
3151 * Preserve exitstatus of a previous possible redirection
3159 * Handle break and continue commands. Break, continue, and return are
3160 * all handled by setting the evalskip flag. The evaluation routines
3161 * above all check this flag, and if it is set they start skipping
3162 * commands rather than executing them. The variable skipcount is
3163 * the number of loops to break/continue, or the number of function
3164 * levels to return. (The latter is always 1.) It should probably
3165 * be an error to break out of more loops than exist, but it isn't
3166 * in the standard shell so we don't make it one here.
3170 breakcmd(argc, argv)
3174 int n = argc > 1 ? number(argv[1]) : 1;
3179 evalskip = (**argv == 'c')? SKIPCONT : SKIPBREAK;
3187 * The return command.
3191 returncmd(argc, argv)
3195 int ret = argc > 1 ? number(argv[1]) : oexitstatus;
3198 evalskip = SKIPFUNC;
3203 /* Do what ksh does; skip the rest of the file */
3204 evalskip = SKIPFILE;
3211 #ifndef BB_TRUE_FALSE
3213 false_main(argc, argv)
3222 true_main(argc, argv)
3231 * Controls whether the shell is interactive or not.
3234 static void setsignal(int signo);
3235 static void chkmail(int silent);
3239 setinteractive(int on)
3241 static int is_interactive;
3242 static int do_banner=0;
3244 if (on == is_interactive)
3250 is_interactive = on;
3251 if (do_banner==0 && is_interactive) {
3252 /* Looks like they want an interactive shell */
3253 printf( "\n\n" BB_BANNER " Built-in shell (ash)\n");
3254 printf( "Enter 'help' for a list of built-in commands.\n\n");
3262 setinteractive(iflag);
3275 iflag = 0; /* exit on error */
3278 for (sp = cmdenviron; sp ; sp = sp->next)
3279 setvareq(sp->text, VEXPORT|VSTACK);
3280 shellexec(argv + 1, environment(), pathval(), 0);
3286 eprintlist(struct strlist *sp)
3288 for (; sp; sp = sp->next) {
3289 out2fmt(" %s",sp->text);
3294 * Exec a program. Never returns. If you change this routine, you may
3295 * have to change the find_command routine as well.
3298 static const char *pathopt; /* set by padvance */
3301 shellexec(argv, envp, path, idx)
3302 char **argv, **envp;
3309 if (strchr(argv[0], '/') != NULL) {
3310 tryexec(argv[0], argv, envp);
3314 while ((cmdname = padvance(&path, argv[0])) != NULL) {
3315 if (--idx < 0 && pathopt == NULL) {
3316 tryexec(cmdname, argv, envp);
3317 if (errno != ENOENT && errno != ENOTDIR)
3324 /* Map to POSIX errors */
3336 exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC));
3341 * Clear traps on a fork.
3347 for (tp = trap ; tp < &trap[NSIG] ; tp++) {
3348 if (*tp && **tp) { /* trap not NULL or SIG_IGN */
3353 setsignal(tp - trap);
3361 initshellproc(void) {
3387 /* from options.c: */
3391 for (i = 0; i < NOPTS; i++)
3407 for (sm = sigmode ; sm < sigmode + NSIG - 1; sm++) {
3419 static int preadbuffer(void);
3420 static void pushfile (void);
3423 * Read a character from the script, returning PEOF on end of file.
3424 * Nul characters in the input are silently discarded.
3427 #ifndef ASH_OPTIMIZE_FOR_SIZE
3428 #define pgetc_macro() (--parsenleft >= 0? *parsenextc++ : preadbuffer())
3432 return pgetc_macro();
3438 return --parsenleft >= 0? *parsenextc++ : preadbuffer();
3444 return pgetc_macro();
3450 * Undo the last call to pgetc. Only one character may be pushed back.
3451 * PEOF may be pushed back.
3454 static void pungetc(void)
3463 struct parsefile *pf = parsefile;
3472 parsefile = pf->prev;
3474 parsenleft = parsefile->nleft;
3475 parselleft = parsefile->lleft;
3476 parsenextc = parsefile->nextc;
3477 plinno = parsefile->linno;
3483 * Return to top level.
3488 while (parsefile != &basepf)
3493 * Close the file(s) that the shell is reading commands from. Called
3494 * after a fork is done.
3497 static void closescript(void)
3500 if (parsefile->fd > 0) {
3501 close(parsefile->fd);
3508 * Like setinputfile, but takes an open file descriptor. Call this with
3512 static void setinputfd(int fd, int push)
3514 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
3520 while (parsefile->strpush)
3524 if (parsefile->buf == NULL)
3525 parsefile->buf = ckmalloc(BUFSIZ);
3526 parselleft = parsenleft = 0;
3532 * Set the input to take input from a file. If push is set, push the
3533 * old input onto the stack first.
3537 setinputfile(const char *fname, int push)
3543 if ((fd = open(fname, O_RDONLY)) < 0)
3544 error("Can't open %s", fname);
3546 myfileno2 = dup_as_newfd(fd, 10);
3549 error("Out of file descriptors");
3552 setinputfd(fd, push);
3558 tryexec(char *cmd, char **argv, char **envp)
3562 #ifdef BB_FEATURE_SH_STANDALONE_SHELL
3566 #ifdef BB_FEATURE_SH_APPLETS_ALWAYS_WIN
3567 name = get_last_path_component(name);
3570 for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++)
3573 for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++)
3575 run_applet_by_name(name, argc_l, argv);
3577 execve(cmd, argv, envp);
3582 setinputfile(cmd, 0);
3583 commandname = arg0 = savestr(argv[0]);
3585 exraise(EXSHELLPROC);
3590 static char *commandtext (const union node *);
3593 * Do a path search. The variable path (passed by reference) should be
3594 * set to the start of the path before the first call; padvance will update
3595 * this value as it proceeds. Successive calls to padvance will return
3596 * the possible path expansions in sequence. If an option (indicated by
3597 * a percent sign) appears in the path entry then the global variable
3598 * pathopt will be set to point to it; otherwise pathopt will be set to
3602 static const char *pathopt;
3604 static void growstackblock(void);
3608 padvance(const char **path, const char *name)
3618 for (p = start ; *p && *p != ':' && *p != '%' ; p++);
3619 len = p - start + strlen(name) + 2; /* "2" is for '/' and '\0' */
3620 while (stackblocksize() < len)
3624 memcpy(q, start, p - start);
3632 while (*p && *p != ':') p++;
3638 return stalloc(len);
3642 * Wrapper around strcmp for qsort/bsearch/...
3645 pstrcmp(const void *a, const void *b)
3647 return strcmp((const char *) a, (*(const char *const *) b) + 1);
3651 * Find a keyword is in a sorted array.
3654 static const char *const *
3655 findkwd(const char *s)
3657 return bsearch(s, tokname_array + KWDOFFSET,
3658 (sizeof(tokname_array)/sizeof(const char *)) - KWDOFFSET,
3659 sizeof(const char *), pstrcmp);
3663 /*** Command hashing code ***/
3671 struct tblentry **pp;
3672 struct tblentry *cmdp;
3675 struct cmdentry entry;
3678 const struct alias *ap;
3682 while ((c = nextopt("rvV")) != '\0') {
3686 } else if (c == 'v' || c == 'V') {
3690 if (*argptr == NULL) {
3691 for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
3692 for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
3693 if (cmdp->cmdtype != CMDBUILTIN) {
3694 printentry(cmdp, verbose);
3701 while ((name = *argptr++) != NULL) {
3702 if ((cmdp = cmdlookup(name, 0)) != NULL
3703 && (cmdp->cmdtype == CMDNORMAL
3704 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0)))
3707 /* Then look at the aliases */
3708 if ((ap = lookupalias(name, 0)) != NULL) {
3710 printf("%s is an alias for %s\n", name, ap->val);
3716 /* First look at the keywords */
3717 if (findkwd(name)!=0) {
3719 printf("%s is a shell keyword\n", name);
3721 printf(snlfmt, name);
3725 find_command(name, &entry, DO_ERR, pathval());
3726 if (entry.cmdtype == CMDUNKNOWN) c = 1;
3728 cmdp = cmdlookup(name, 0);
3729 if (cmdp) printentry(cmdp, verbose=='v');
3737 printentry(cmdp, verbose)
3738 struct tblentry *cmdp;
3745 printf("%s%s", cmdp->cmdname, (verbose ? " is " : ""));
3746 if (cmdp->cmdtype == CMDNORMAL) {
3747 idx = cmdp->param.index;
3750 name = padvance(&path, cmdp->cmdname);
3752 } while (--idx >= 0);
3755 } else if (cmdp->cmdtype == CMDBUILTIN) {
3757 out1str("a shell builtin");
3758 } else if (cmdp->cmdtype == CMDFUNCTION) {
3761 out1str("a function\n");
3762 name = commandtext(cmdp->param.func);
3763 printf("%s() {\n %s\n}", cmdp->cmdname, name);
3769 error("internal error: cmdtype %d", cmdp->cmdtype);
3772 printf(snlfmt, cmdp->rehash ? "*" : nullstr);
3777 /*** List the available builtins ***/
3780 static int helpcmd(int argc, char** argv)
3784 printf("\nBuilt-in commands:\n-------------------\n");
3785 for (col=0, i=0; i < NUMBUILTINS; i++) {
3786 col += printf("%c%s", ((col == 0) ? '\t' : ' '),
3787 builtincmds[i].name+1);
3793 #ifdef BB_FEATURE_SH_STANDALONE_SHELL
3795 extern const struct BB_applet applets[];
3796 extern const size_t NUM_APPLETS;
3798 for (i=0; i < NUM_APPLETS; i++) {
3800 col += printf("%c%s", ((col == 0) ? '\t' : ' '),
3810 return EXIT_SUCCESS;
3814 * Resolve a command name. If you change this routine, you may have to
3815 * change the shellexec routine as well.
3818 static int prefix (const char *, const char *);
3821 find_command(const char *name, struct cmdentry *entry, int act, const char *path)
3823 struct tblentry *cmdp;
3833 struct builtincmd *bcmd;
3835 /* If name contains a slash, don't use the hash table */
3836 if (strchr(name, '/') != NULL) {
3838 while (stat(name, &statb) < 0) {
3839 if (errno != ENOENT && errno != ENOTDIR)
3841 entry->cmdtype = CMDUNKNOWN;
3842 entry->u.index = -1;
3845 entry->cmdtype = CMDNORMAL;
3846 entry->u.index = -1;
3849 entry->cmdtype = CMDNORMAL;
3855 if (act & DO_BRUTE) {
3856 firstchange = path_change(path, &bltin);
3862 /* If name is in the table, and not invalidated by cd, we're done */
3863 if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->rehash == 0) {
3864 if (cmdp->cmdtype == CMDFUNCTION) {
3865 if (act & DO_NOFUN) {
3870 } else if (act & DO_BRUTE) {
3871 if ((cmdp->cmdtype == CMDNORMAL &&
3872 cmdp->param.index >= firstchange) ||
3873 (cmdp->cmdtype == CMDBUILTIN &&
3874 ((builtinloc < 0 && bltin >= 0) ?
3875 bltin : builtinloc) >= firstchange)) {
3876 /* need to recompute the entry */
3885 bcmd = find_builtin(name);
3886 regular = bcmd && IS_BUILTIN_REGULAR(bcmd);
3889 if (cmdp && (cmdp->cmdtype == CMDBUILTIN)) {
3892 } else if (act & DO_BRUTE) {
3893 if (firstchange == 0) {
3898 /* If %builtin not in path, check for builtin next */
3899 if (regular || (bltin < 0 && bcmd)) {
3902 entry->cmdtype = CMDBUILTIN;
3903 entry->u.cmd = bcmd;
3907 cmdp = cmdlookup(name, 1);
3908 cmdp->cmdtype = CMDBUILTIN;
3909 cmdp->param.cmd = bcmd;
3914 /* We have to search path. */
3915 prev = -1; /* where to start */
3916 if (cmdp && cmdp->rehash) { /* doing a rehash */
3917 if (cmdp->cmdtype == CMDBUILTIN)
3920 prev = cmdp->param.index;
3926 while ((fullname = padvance(&path, name)) != NULL) {
3927 stunalloc(fullname);
3929 if (idx >= firstchange) {
3933 if (prefix("builtin", pathopt)) {
3934 if ((bcmd = find_builtin(name))) {
3938 } else if (!(act & DO_NOFUN) &&
3939 prefix("func", pathopt)) {
3942 continue; /* ignore unimplemented options */
3945 /* if rehash, don't redo absolute path names */
3946 if (fullname[0] == '/' && idx <= prev &&
3947 idx < firstchange) {
3950 TRACE(("searchexec \"%s\": no change\n", name));
3953 while (stat(fullname, &statb) < 0) {
3954 if (errno != ENOENT && errno != ENOTDIR)
3958 e = EACCES; /* if we fail, this will be the error */
3959 if (!S_ISREG(statb.st_mode))
3961 if (pathopt) { /* this is a %func directory */
3962 stalloc(strlen(fullname) + 1);
3963 readcmdfile(fullname);
3964 if ((cmdp = cmdlookup(name, 0)) == NULL || cmdp->cmdtype != CMDFUNCTION)
3965 error("%s not defined in %s", name, fullname);
3966 stunalloc(fullname);
3969 TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
3970 /* If we aren't called with DO_BRUTE and cmdp is set, it must
3971 be a function and we're being called with DO_NOFUN */
3973 entry->cmdtype = CMDNORMAL;
3974 entry->u.index = idx;
3978 cmdp = cmdlookup(name, 1);
3979 cmdp->cmdtype = CMDNORMAL;
3980 cmdp->param.index = idx;
3985 /* We failed. If there was an entry for this command, delete it */
3986 if (cmdp && updatetbl)
3989 out2fmt("%s: %s\n", name, errmsg(e, E_EXEC));
3990 entry->cmdtype = CMDUNKNOWN;
3995 entry->cmdtype = cmdp->cmdtype;
3996 entry->u = cmdp->param;
4002 * Search the table of builtin commands.
4006 bstrcmp(const void *name, const void *b)
4008 return strcmp((const char *)name, (*(const char *const *) b)+1);
4011 static struct builtincmd *
4012 find_builtin(const char *name)
4014 struct builtincmd *bp;
4016 bp = bsearch(name, builtincmds, NUMBUILTINS, sizeof(struct builtincmd),
4024 * Called when a cd is done. Marks all commands so the next time they
4025 * are executed they will be rehashed.
4030 struct tblentry **pp;
4031 struct tblentry *cmdp;
4033 for (pp = cmdtable ; pp < &cmdtable[CMDTABLESIZE] ; pp++) {
4034 for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
4035 if (cmdp->cmdtype == CMDNORMAL
4036 || (cmdp->cmdtype == CMDBUILTIN && builtinloc >= 0))
4045 * Called before PATH is changed. The argument is the new value of PATH;
4046 * pathval() still returns the old value at this point. Called with
4051 changepath(const char *newval)
4056 firstchange = path_change(newval, &bltin);
4057 if (builtinloc < 0 && bltin >= 0)
4058 builtinloc = bltin; /* zap builtins */
4059 clearcmdentry(firstchange);
4065 * Clear out command entries. The argument specifies the first entry in
4066 * PATH which has changed.
4070 clearcmdentry(firstchange)
4073 struct tblentry **tblp;
4074 struct tblentry **pp;
4075 struct tblentry *cmdp;
4078 for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
4080 while ((cmdp = *pp) != NULL) {
4081 if ((cmdp->cmdtype == CMDNORMAL &&
4082 cmdp->param.index >= firstchange)
4083 || (cmdp->cmdtype == CMDBUILTIN &&
4084 builtinloc >= firstchange)) {
4097 * Delete all functions.
4102 struct tblentry **tblp;
4103 struct tblentry **pp;
4104 struct tblentry *cmdp;
4107 for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
4109 while ((cmdp = *pp) != NULL) {
4110 if (cmdp->cmdtype == CMDFUNCTION) {
4112 freefunc(cmdp->param.func);
4125 * Locate a command in the command hash table. If "add" is nonzero,
4126 * add the command to the table if it is not already present. The
4127 * variable "lastcmdentry" is set to point to the address of the link
4128 * pointing to the entry, so that delete_cmd_entry can delete the
4132 static struct tblentry **lastcmdentry;
4134 static struct tblentry *
4135 cmdlookup(const char *name, int add)
4139 struct tblentry *cmdp;
4140 struct tblentry **pp;
4147 pp = &cmdtable[hashval % CMDTABLESIZE];
4148 for (cmdp = *pp ; cmdp ; cmdp = cmdp->next) {
4149 if (equal(cmdp->cmdname, name))
4153 if (add && cmdp == NULL) {
4155 cmdp = *pp = ckmalloc(sizeof (struct tblentry) - ARB
4156 + strlen(name) + 1);
4158 cmdp->cmdtype = CMDUNKNOWN;
4160 strcpy(cmdp->cmdname, name);
4168 * Delete the command entry returned on the last lookup.
4172 delete_cmd_entry() {
4173 struct tblentry *cmdp;
4176 cmdp = *lastcmdentry;
4177 *lastcmdentry = cmdp->next;
4186 static const unsigned char nodesize[26] = {
4187 ALIGN(sizeof (struct nbinary)),
4188 ALIGN(sizeof (struct ncmd)),
4189 ALIGN(sizeof (struct npipe)),
4190 ALIGN(sizeof (struct nredir)),
4191 ALIGN(sizeof (struct nredir)),
4192 ALIGN(sizeof (struct nredir)),
4193 ALIGN(sizeof (struct nbinary)),
4194 ALIGN(sizeof (struct nbinary)),
4195 ALIGN(sizeof (struct nif)),
4196 ALIGN(sizeof (struct nbinary)),
4197 ALIGN(sizeof (struct nbinary)),
4198 ALIGN(sizeof (struct nfor)),
4199 ALIGN(sizeof (struct ncase)),
4200 ALIGN(sizeof (struct nclist)),
4201 ALIGN(sizeof (struct narg)),
4202 ALIGN(sizeof (struct narg)),
4203 ALIGN(sizeof (struct nfile)),
4204 ALIGN(sizeof (struct nfile)),
4205 ALIGN(sizeof (struct nfile)),
4206 ALIGN(sizeof (struct nfile)),
4207 ALIGN(sizeof (struct nfile)),
4208 ALIGN(sizeof (struct ndup)),
4209 ALIGN(sizeof (struct ndup)),
4210 ALIGN(sizeof (struct nhere)),
4211 ALIGN(sizeof (struct nhere)),
4212 ALIGN(sizeof (struct nnot)),
4218 * Delete a function if it exists.
4222 unsetfunc(char *name)
4224 struct tblentry *cmdp;
4226 if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->cmdtype == CMDFUNCTION) {
4227 freefunc(cmdp->param.func);
4234 * Locate and print what a word is...
4238 typecmd(int argc, char **argv)
4246 for (i = 1; i < argc; i++) {
4247 argv_a[0] = argv[i];
4250 err |= hashcmd(argc, argv);
4257 commandcmd(argc, argv)
4262 int default_path = 0;
4263 int verify_only = 0;
4264 int verbose_verify_only = 0;
4266 while ((c = nextopt("pvV")) != '\0')
4275 verbose_verify_only = 1;
4279 if (default_path + verify_only + verbose_verify_only > 1 ||
4282 "command [-p] command [arg ...]\n"
4283 "command {-v|-V} command\n");
4287 if (verify_only || verbose_verify_only) {
4291 argv_a[0] = *argptr;
4293 optptr = verbose_verify_only ? "v" : "V"; /* reverse special */
4294 return hashcmd(argc, argv);
4302 path_change(newval, bltin)
4306 const char *old, *new;
4312 firstchange = 9999; /* assume no change */
4318 if ((*old == '\0' && *new == ':')
4319 || (*old == ':' && *new == '\0'))
4321 old = new; /* ignore subsequent differences */
4325 if (*new == '%' && *bltin < 0 && prefix("builtin", new + 1))
4332 if (builtinloc >= 0 && *bltin < 0)
4337 * Routines to expand arguments to commands. We have to deal with
4338 * backquotes, shell variables, and file metacharacters.
4343 #define RMESCAPE_ALLOC 0x1 /* Allocate a new string */
4344 #define RMESCAPE_GLOB 0x2 /* Add backslashes for glob */
4347 * Structure specifying which parts of the string should be searched
4348 * for IFS characters.
4352 struct ifsregion *next; /* next region in list */
4353 int begoff; /* offset of start of region */
4354 int endoff; /* offset of end of region */
4355 int nulonly; /* search for nul bytes only */
4359 static char *expdest; /* output of current string */
4360 static struct nodelist *argbackq; /* list of back quote expressions */
4361 static struct ifsregion ifsfirst; /* first struct in list of ifs regions */
4362 static struct ifsregion *ifslastp; /* last struct in list */
4363 static struct arglist exparg; /* holds expanded arg list */
4365 static void argstr (char *, int);
4366 static char *exptilde (char *, int);
4367 static void expbackq (union node *, int, int);
4368 static int subevalvar (char *, char *, int, int, int, int, int);
4369 static int varisset (char *, int);
4370 static void strtodest (const char *, int, int);
4371 static void varvalue (char *, int, int);
4372 static void recordregion (int, int, int);
4373 static void removerecordregions (int);
4374 static void ifsbreakup (char *, struct arglist *);
4375 static void ifsfree (void);
4376 static void expandmeta (struct strlist *, int);
4377 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
4378 #define preglob(p) _rmescapes((p), RMESCAPE_ALLOC | RMESCAPE_GLOB)
4379 #if !defined(GLOB_BROKEN)
4380 static void addglob (const glob_t *);
4383 #if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
4384 static void expmeta (char *, char *);
4386 #if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
4387 static struct strlist *expsort (struct strlist *);
4388 static struct strlist *msort (struct strlist *, int);
4390 static int patmatch (char *, char *, int);
4391 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
4392 static int patmatch2 (char *, char *, int);
4394 static int pmatch (char *, char *, int);
4395 #define patmatch2 patmatch
4397 static char *cvtnum (int, char *);
4400 * Expand shell variables and backquotes inside a here document.
4403 /* arg: the document, fd: where to write the expanded version */
4405 expandhere(union node *arg, int fd)
4408 expandarg(arg, (struct arglist *)NULL, 0);
4409 xwrite(fd, stackblock(), expdest - stackblock());
4414 * Perform variable substitution and command substitution on an argument,
4415 * placing the resulting list of arguments in arglist. If EXP_FULL is true,
4416 * perform splitting and file name expansion. When arglist is NULL, perform
4417 * here document expansion.
4421 expandarg(arg, arglist, flag)
4423 struct arglist *arglist;
4429 argbackq = arg->narg.backquote;
4430 STARTSTACKSTR(expdest);
4431 ifsfirst.next = NULL;
4433 argstr(arg->narg.text, flag);
4434 if (arglist == NULL) {
4435 return; /* here document expanded */
4437 STPUTC('\0', expdest);
4438 p = grabstackstr(expdest);
4439 exparg.lastp = &exparg.list;
4443 if (flag & EXP_FULL) {
4444 ifsbreakup(p, &exparg);
4445 *exparg.lastp = NULL;
4446 exparg.lastp = &exparg.list;
4447 expandmeta(exparg.list, flag);
4449 if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
4451 sp = (struct strlist *)stalloc(sizeof (struct strlist));
4454 exparg.lastp = &sp->next;
4457 *exparg.lastp = NULL;
4459 *arglist->lastp = exparg.list;
4460 arglist->lastp = exparg.lastp;
4466 * Expand a variable, and return a pointer to the next character in the
4470 static inline char * evalvar(char *p, int flag)
4483 int quotes = flag & (EXP_FULL | EXP_CASE);
4486 subtype = varflags & VSTYPE;
4491 p = strchr(p, '=') + 1;
4492 again: /* jump here after setting a variable with ${var=text} */
4494 set = varisset(var, varflags & VSNUL);
4497 val = lookupvar(var);
4498 if (val == NULL || ((varflags & VSNUL) && val[0] == '\0')) {
4505 startloc = expdest - stackblock();
4506 if (set && subtype != VSPLUS) {
4507 /* insert the value of the variable */
4509 varvalue(var, varflags & VSQUOTE, flag);
4510 if (subtype == VSLENGTH) {
4511 varlen = expdest - stackblock() - startloc;
4512 STADJUST(-varlen, expdest);
4515 if (subtype == VSLENGTH) {
4516 varlen = strlen(val);
4520 varflags & VSQUOTE ?
4521 DQSYNTAX : BASESYNTAX,
4528 if (subtype == VSPLUS)
4531 easy = ((varflags & VSQUOTE) == 0 ||
4532 (*var == '@' && shellparam.nparam != 1));
4537 expdest = cvtnum(varlen, expdest);
4544 recordregion(startloc, expdest - stackblock(),
4545 varflags & VSQUOTE);
4561 case VSTRIMRIGHTMAX:
4565 * Terminate the string and start recording the pattern
4568 STPUTC('\0', expdest);
4569 patloc = expdest - stackblock();
4570 if (subevalvar(p, NULL, patloc, subtype,
4571 startloc, varflags, quotes) == 0) {
4572 int amount = (expdest - stackblock() - patloc) + 1;
4573 STADJUST(-amount, expdest);
4575 /* Remove any recorded regions beyond start of variable */
4576 removerecordregions(startloc);
4582 if (subevalvar(p, var, 0, subtype, startloc,
4583 varflags, quotes)) {
4586 * Remove any recorded regions beyond
4589 removerecordregions(startloc);
4604 if (subtype != VSNORMAL) { /* skip to end of alternative */
4607 if ((c = *p++) == CTLESC)
4609 else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
4611 argbackq = argbackq->next;
4612 } else if (c == CTLVAR) {
4613 if ((*p++ & VSTYPE) != VSNORMAL)
4615 } else if (c == CTLENDVAR) {
4626 * Perform variable and command substitution. If EXP_FULL is set, output CTLESC
4627 * characters to allow for further processing. Otherwise treat
4628 * $@ like $* since no splitting will be performed.
4637 int quotes = flag & (EXP_FULL | EXP_CASE); /* do CTLESC */
4640 if (*p == '~' && (flag & (EXP_TILDE | EXP_VARTILDE)))
4641 p = exptilde(p, flag);
4645 case CTLENDVAR: /* ??? */
4648 /* "$@" syntax adherence hack */
4649 if (p[0] == CTLVAR && p[2] == '@' && p[3] == '=')
4651 if ((flag & EXP_FULL) != 0)
4661 p = evalvar(p, flag);
4664 case CTLBACKQ|CTLQUOTE:
4665 expbackq(argbackq->n, c & CTLQUOTE, flag);
4666 argbackq = argbackq->next;
4668 #ifdef ASH_MATH_SUPPORT
4676 * sort of a hack - expand tildes in variable
4677 * assignments (after the first '=' and after ':'s).
4680 if (flag & EXP_VARTILDE && *p == '~') {
4687 p = exptilde(p, flag);
4703 char c, *startp = p;
4706 int quotes = flag & (EXP_FULL | EXP_CASE);
4708 while ((c = *p) != '\0') {
4715 if (flag & EXP_VARTILDE)
4725 if (*(startp+1) == '\0') {
4726 if ((home = lookupvar("HOME")) == NULL)
4729 if ((pw = getpwnam(startp+1)) == NULL)
4736 strtodest(home, SQSYNTAX, quotes);
4745 removerecordregions(int endoff)
4747 if (ifslastp == NULL)
4750 if (ifsfirst.endoff > endoff) {
4751 while (ifsfirst.next != NULL) {
4752 struct ifsregion *ifsp;
4754 ifsp = ifsfirst.next->next;
4755 ckfree(ifsfirst.next);
4756 ifsfirst.next = ifsp;
4759 if (ifsfirst.begoff > endoff)
4762 ifslastp = &ifsfirst;
4763 ifsfirst.endoff = endoff;
4768 ifslastp = &ifsfirst;
4769 while (ifslastp->next && ifslastp->next->begoff < endoff)
4770 ifslastp=ifslastp->next;
4771 while (ifslastp->next != NULL) {
4772 struct ifsregion *ifsp;
4774 ifsp = ifslastp->next->next;
4775 ckfree(ifslastp->next);
4776 ifslastp->next = ifsp;
4779 if (ifslastp->endoff > endoff)
4780 ifslastp->endoff = endoff;
4784 #ifdef ASH_MATH_SUPPORT
4786 * Expand arithmetic expression. Backup to start of expression,
4787 * evaluate, place result in (backed up) result, adjust string position.
4796 int quotes = flag & (EXP_FULL | EXP_CASE);
4802 * This routine is slightly over-complicated for
4803 * efficiency. First we make sure there is
4804 * enough space for the result, which may be bigger
4805 * than the expression if we add exponentation. Next we
4806 * scan backwards looking for the start of arithmetic. If the
4807 * next previous character is a CTLESC character, then we
4808 * have to rescan starting from the beginning since CTLESC
4809 * characters have to be processed left to right.
4811 CHECKSTRSPACE(10, expdest);
4812 USTPUTC('\0', expdest);
4813 start = stackblock();
4815 while (*p != CTLARI && p >= start)
4818 error("missing CTLARI (shouldn't happen)");
4819 if (p > start && *(p-1) == CTLESC)
4820 for (p = start; *p != CTLARI; p++)
4829 removerecordregions(begoff);
4832 result = arith(p+2, &errcode);
4835 error("divide by zero");
4837 error("syntax error: \"%s\"\n", p+2);
4839 snprintf(p, 12, "%d", result);
4845 recordregion(begoff, p - 1 - start, 0);
4846 result = expdest - p + 1;
4847 STADJUST(-result, expdest);
4852 * Expand stuff in backwards quotes.
4856 expbackq(cmd, quoted, flag)
4861 volatile struct backcmd in;
4865 char *dest = expdest;
4866 volatile struct ifsregion saveifs;
4867 struct ifsregion *volatile savelastp;
4868 struct nodelist *volatile saveargbackq;
4870 int startloc = dest - stackblock();
4871 int syntax = quoted ? DQSYNTAX : BASESYNTAX;
4872 volatile int saveherefd;
4873 int quotes = flag & (EXP_FULL | EXP_CASE);
4874 struct jmploc jmploc;
4875 struct jmploc *volatile savehandler;
4879 /* Avoid longjmp clobbering */
4890 savelastp = ifslastp;
4891 saveargbackq = argbackq;
4892 saveherefd = herefd;
4894 if ((ex = setjmp(jmploc.loc))) {
4897 savehandler = handler;
4900 p = grabstackstr(dest);
4901 evalbackcmd(cmd, (struct backcmd *) &in);
4902 ungrabstackstr(p, dest);
4906 ifslastp = savelastp;
4907 argbackq = saveargbackq;
4908 herefd = saveherefd;
4916 if (--in.nleft < 0) {
4919 i = safe_read(in.fd, buf, sizeof buf);
4920 TRACE(("expbackq: read returns %d\n", i));
4927 if (lastc != '\0') {
4928 if (quotes && SIT(lastc, syntax) == CCTL)
4929 STPUTC(CTLESC, dest);
4930 STPUTC(lastc, dest);
4934 /* Eat all trailing newlines */
4935 for (; dest > stackblock() && dest[-1] == '\n';)
4944 exitstatus = waitforjob(in.jp);
4945 handler = savehandler;
4947 longjmp(handler->loc, 1);
4950 recordregion(startloc, dest - stackblock(), 0);
4951 TRACE(("evalbackq: size=%d: \"%.*s\"\n",
4952 (dest - stackblock()) - startloc,
4953 (dest - stackblock()) - startloc,
4954 stackblock() + startloc));
4960 subevalvar(p, str, strloc, subtype, startloc, varflags, quotes)
4973 int saveherefd = herefd;
4974 struct nodelist *saveargbackq = argbackq;
4978 argstr(p, subtype != VSASSIGN && subtype != VSQUESTION ? EXP_CASE : 0);
4979 STACKSTRNUL(expdest);
4980 herefd = saveherefd;
4981 argbackq = saveargbackq;
4982 startp = stackblock() + startloc;
4984 str = stackblock() + strloc;
4988 setvar(str, startp, 0);
4989 amount = startp - expdest;
4990 STADJUST(amount, expdest);
4997 if (*p != CTLENDVAR) {
4998 out2fmt(snlfmt, startp);
4999 error((char *)NULL);
5001 error("%.*s: parameter %snot set", p - str - 1,
5002 str, (varflags & VSNUL) ? "null or "
5007 for (loc = startp; loc < str; loc++) {
5010 if (patmatch2(str, startp, quotes))
5013 if (quotes && *loc == CTLESC)
5019 for (loc = str - 1; loc >= startp;) {
5022 if (patmatch2(str, startp, quotes))
5026 if (quotes && loc > startp && *(loc - 1) == CTLESC) {
5027 for (q = startp; q < loc; q++)
5037 for (loc = str - 1; loc >= startp;) {
5038 if (patmatch2(str, loc, quotes))
5041 if (quotes && loc > startp && *(loc - 1) == CTLESC) {
5042 for (q = startp; q < loc; q++)
5051 case VSTRIMRIGHTMAX:
5052 for (loc = startp; loc < str - 1; loc++) {
5053 if (patmatch2(str, loc, quotes))
5055 if (quotes && *loc == CTLESC)
5068 amount = ((str - 1) - (loc - startp)) - expdest;
5069 STADJUST(amount, expdest);
5070 while (loc != str - 1)
5075 amount = loc - expdest;
5076 STADJUST(amount, expdest);
5077 STPUTC('\0', expdest);
5078 STADJUST(-1, expdest);
5084 * Test whether a specialized variable is set.
5088 varisset(name, nulok)
5093 return backgndpid != -1;
5094 else if (*name == '@' || *name == '*') {
5095 if (*shellparam.p == NULL)
5101 for (av = shellparam.p; *av; av++)
5106 } else if (is_digit(*name)) {
5108 int num = atoi(name);
5110 if (num > shellparam.nparam)
5116 ap = shellparam.p[num - 1];
5118 if (nulok && (ap == NULL || *ap == '\0'))
5125 * Put a string on the stack.
5129 strtodest(const char *p, int syntax, int quotes)
5132 if (quotes && SIT(*p,syntax) == CCTL)
5133 STPUTC(CTLESC, expdest);
5134 STPUTC(*p++, expdest);
5139 * Add the value of a specialized variable to the stack string.
5143 varvalue(char *name, int quoted, int flags)
5152 int allow_split = flags & EXP_FULL;
5153 int quotes = flags & (EXP_FULL | EXP_CASE);
5155 syntax = quoted ? DQSYNTAX : BASESYNTAX;
5164 num = shellparam.nparam;
5169 expdest = cvtnum(num, expdest);
5172 for (i = 0 ; i < NOPTS ; i++) {
5174 STPUTC(optent_letter(optlist[i]), expdest);
5178 if (allow_split && quoted) {
5179 sep = 1 << CHAR_BIT;
5184 sep = ifsset() ? ifsval()[0] : ' ';
5186 sepq = SIT(sep,syntax) == CCTL;
5189 for (ap = shellparam.p ; (p = *ap++) != NULL ; ) {
5190 strtodest(p, syntax, quotes);
5193 STPUTC(CTLESC, expdest);
5194 STPUTC(sep, expdest);
5199 strtodest(arg0, syntax, quotes);
5203 if (num > 0 && num <= shellparam.nparam) {
5204 strtodest(shellparam.p[num - 1], syntax, quotes);
5212 * Record the fact that we have to scan this region of the
5213 * string for IFS characters.
5217 recordregion(start, end, nulonly)
5222 struct ifsregion *ifsp;
5224 if (ifslastp == NULL) {
5228 ifsp = (struct ifsregion *)ckmalloc(sizeof (struct ifsregion));
5230 ifslastp->next = ifsp;
5234 ifslastp->begoff = start;
5235 ifslastp->endoff = end;
5236 ifslastp->nulonly = nulonly;
5242 * Break the argument string into pieces based upon IFS and add the
5243 * strings to the argument list. The regions of the string to be
5244 * searched for IFS characters have been stored by recordregion.
5247 ifsbreakup(string, arglist)
5249 struct arglist *arglist;
5251 struct ifsregion *ifsp;
5256 const char *ifs, *realifs;
5264 realifs = ifsset() ? ifsval() : defifs;
5265 if (ifslastp != NULL) {
5268 p = string + ifsp->begoff;
5269 nulonly = ifsp->nulonly;
5270 ifs = nulonly ? nullstr : realifs;
5272 while (p < string + ifsp->endoff) {
5276 if (strchr(ifs, *p)) {
5278 ifsspc = (strchr(defifs, *p) != NULL);
5279 /* Ignore IFS whitespace at start */
5280 if (q == start && ifsspc) {
5286 sp = (struct strlist *)stalloc(sizeof *sp);
5288 *arglist->lastp = sp;
5289 arglist->lastp = &sp->next;
5293 if (p >= string + ifsp->endoff) {
5299 if (strchr(ifs, *p) == NULL ) {
5302 } else if (strchr(defifs, *p) == NULL) {
5318 } while ((ifsp = ifsp->next) != NULL);
5319 if (!(*start || (!ifsspc && start > string && nulonly))) {
5324 sp = (struct strlist *)stalloc(sizeof *sp);
5326 *arglist->lastp = sp;
5327 arglist->lastp = &sp->next;
5333 while (ifsfirst.next != NULL) {
5334 struct ifsregion *ifsp;
5336 ifsp = ifsfirst.next->next;
5337 ckfree(ifsfirst.next);
5338 ifsfirst.next = ifsp;
5342 ifsfirst.next = NULL;
5346 * Add a file name to the list.
5350 addfname(const char *name)
5356 sp = (struct strlist *)stalloc(sizeof *sp);
5359 exparg.lastp = &sp->next;
5363 * Expand shell metacharacters. At this point, the only control characters
5364 * should be escapes. The results are stored in the list exparg.
5367 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN)
5369 expandmeta(str, flag)
5370 struct strlist *str;
5375 /* TODO - EXP_REDIR */
5380 p = preglob(str->text);
5382 switch (glob(p, 0, 0, &pglob)) {
5384 if(pglob.gl_pathv[1]==0 && !strcmp(p, pglob.gl_pathv[0]))
5395 *exparg.lastp = str;
5396 rmescapes(str->text);
5397 exparg.lastp = &str->next;
5399 default: /* GLOB_NOSPACE */
5400 error("Out of space");
5408 * Add the result of glob(3) to the list.
5413 const glob_t *pglob;
5415 char **p = pglob->gl_pathv;
5423 #else /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
5424 static char *expdir;
5428 expandmeta(str, flag)
5429 struct strlist *str;
5433 struct strlist **savelastp;
5436 /* TODO - EXP_REDIR */
5442 for (;;) { /* fast check for meta chars */
5443 if ((c = *p++) == '\0')
5445 if (c == '*' || c == '?' || c == '[' || c == '!')
5448 savelastp = exparg.lastp;
5450 if (expdir == NULL) {
5451 int i = strlen(str->text);
5452 expdir = ckmalloc(i < 2048 ? 2048 : i); /* XXX */
5455 expmeta(expdir, str->text);
5459 if (exparg.lastp == savelastp) {
5464 *exparg.lastp = str;
5465 rmescapes(str->text);
5466 exparg.lastp = &str->next;
5468 *exparg.lastp = NULL;
5469 *savelastp = sp = expsort(*savelastp);
5470 while (sp->next != NULL)
5472 exparg.lastp = &sp->next;
5480 * Do metacharacter (i.e. *, ?, [...]) expansion.
5484 expmeta(enddir, name)
5502 for (p = name ; ; p++) {
5503 if (*p == '*' || *p == '?')
5505 else if (*p == '[') {
5510 while (*q == CTLQUOTEMARK)
5514 if (*q == '/' || *q == '\0')
5521 } else if (*p == '!' && p[1] == '!' && (p == name || p[-1] == '/')) {
5523 } else if (*p == '\0')
5525 else if (*p == CTLQUOTEMARK)
5527 else if (*p == CTLESC)
5535 if (metaflag == 0) { /* we've reached the end of the file name */
5536 if (enddir != expdir)
5538 for (p = name ; ; p++) {
5539 if (*p == CTLQUOTEMARK)
5547 if (metaflag == 0 || lstat(expdir, &statb) >= 0)
5552 if (start != name) {
5555 while (*p == CTLQUOTEMARK)
5562 if (enddir == expdir) {
5564 } else if (enddir == expdir + 1 && *expdir == '/') {
5570 if ((dirp = opendir(cp)) == NULL)
5572 if (enddir != expdir)
5574 if (*endname == 0) {
5582 while (*p == CTLQUOTEMARK)
5588 while (! int_pending() && (dp = readdir(dirp)) != NULL) {
5589 if (dp->d_name[0] == '.' && ! matchdot)
5591 if (patmatch(start, dp->d_name, 0)) {
5593 strcpy(enddir, dp->d_name);
5596 for (p = enddir, cp = dp->d_name;
5597 (*p++ = *cp++) != '\0';)
5600 expmeta(p, endname);
5608 #endif /* defined(__GLIBC__) && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN) */
5612 #if !(defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN) && !defined(GLOB_BROKEN))
5614 * Sort the results of file name expansion. It calculates the number of
5615 * strings to sort and then calls msort (short for merge sort) to do the
5619 static struct strlist *
5621 struct strlist *str;
5627 for (sp = str ; sp ; sp = sp->next)
5629 return msort(str, len);
5633 static struct strlist *
5635 struct strlist *list;
5638 struct strlist *p, *q = NULL;
5639 struct strlist **lpp;
5647 for (n = half ; --n >= 0 ; ) {
5651 q->next = NULL; /* terminate first half of list */
5652 q = msort(list, half); /* sort first half of list */
5653 p = msort(p, len - half); /* sort second half */
5656 if (strcmp(p->text, q->text) < 0) {
5659 if ((p = *lpp) == NULL) {
5666 if ((q = *lpp) == NULL) {
5679 * Returns true if the pattern matches the string.
5682 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
5683 /* squoted: string might have quote chars */
5685 patmatch(char *pattern, char *string, int squoted)
5690 p = preglob(pattern);
5691 q = squoted ? _rmescapes(string, RMESCAPE_ALLOC) : string;
5693 return !fnmatch(p, q, 0);
5698 patmatch2(char *pattern, char *string, int squoted)
5704 p = grabstackstr(expdest);
5705 res = patmatch(pattern, string, squoted);
5706 ungrabstackstr(p, expdest);
5711 patmatch(char *pattern, char *string, int squoted) {
5712 return pmatch(pattern, string, squoted);
5717 pmatch(char *pattern, char *string, int squoted)
5729 if (squoted && *q == CTLESC)
5737 if (squoted && *q == CTLESC)
5744 while (c == CTLQUOTEMARK || c == '*')
5746 if (c != CTLESC && c != CTLQUOTEMARK &&
5747 c != '?' && c != '*' && c != '[') {
5749 if (squoted && *q == CTLESC &&
5754 if (squoted && *q == CTLESC)
5760 if (pmatch(p, q, squoted))
5762 if (squoted && *q == CTLESC)
5764 } while (*q++ != '\0');
5775 while (*endp == CTLQUOTEMARK)
5778 goto dft; /* no matching ] */
5779 if (*endp == CTLESC)
5791 if (squoted && chr == CTLESC)
5797 if (c == CTLQUOTEMARK)
5801 if (*p == '-' && p[1] != ']') {
5803 while (*p == CTLQUOTEMARK)
5807 if (chr >= c && chr <= *p)
5814 } while ((c = *p++) != ']');
5815 if (found == invert)
5820 if (squoted && *q == CTLESC)
5837 * Remove any CTLESC characters from a string.
5840 #if defined(__GLIBC__) && __GLIBC__ >= 2 && !defined(FNMATCH_BROKEN)
5842 _rmescapes(char *str, int flag)
5845 static const char qchars[] = { CTLESC, CTLQUOTEMARK, 0 };
5847 p = strpbrk(str, qchars);
5853 if (flag & RMESCAPE_ALLOC) {
5854 size_t len = p - str;
5855 q = r = stalloc(strlen(p) + len + 1);
5857 memcpy(q, str, len);
5862 if (*p == CTLQUOTEMARK) {
5868 if (flag & RMESCAPE_GLOB && *p != '/') {
5885 while (*p != CTLESC && *p != CTLQUOTEMARK) {
5891 if (*p == CTLQUOTEMARK) {
5906 * See if a pattern matches in a case statement.
5910 casematch(union node *pattern, const char *val)
5912 struct stackmark smark;
5916 setstackmark(&smark);
5917 argbackq = pattern->narg.backquote;
5918 STARTSTACKSTR(expdest);
5920 argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
5921 STPUTC('\0', expdest);
5922 p = grabstackstr(expdest);
5923 result = patmatch(p, (char *)val, 0);
5924 popstackmark(&smark);
5939 CHECKSTRSPACE(32, buf);
5940 len = sprintf(buf, "%d", num);
5945 * Editline and history functions (and glue).
5947 static int histcmd(argc, argv)
5951 error("not compiled with history support");
5957 struct redirtab *next;
5958 short renamed[10]; /* Current ash support only 0-9 descriptors */
5959 /* char on arm (and others) can't be negative */
5962 static struct redirtab *redirlist;
5964 extern char **environ;
5969 * Initialization code.
5982 basepf.nextc = basepf.buf = basebuf;
5991 for (envp = environ ; *envp ; envp++) {
5992 if (strchr(*envp, '=')) {
5993 setvareq(*envp, VEXPORT|VTEXTFIXED);
5997 snprintf(ppid, sizeof(ppid), "%d", (int) getppid());
5998 setvar("PPID", ppid, 0);
6005 * This routine is called when an error or an interrupt occurs in an
6006 * interactive shell and control is returned to the main command loop.
6009 /* 1 == check for aliases, 2 == also check for assignments */
6010 static int checkalias; /* also used in no alias mode for check assignments */
6024 if (exception != EXSHELLPROC)
6025 parselleft = parsenleft = 0; /* clear input buffer */
6029 /* from parser.c: */
6047 * This file implements the input routines used by the parser.
6050 #ifdef BB_FEATURE_COMMAND_EDITING
6051 static const char * cmdedit_prompt;
6052 static inline void putprompt(const char *s) {
6056 static inline void putprompt(const char *s) {
6061 #define EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */
6066 * Same as pgetc(), but ignores PEOA.
6076 } while (c == PEOA);
6080 static inline int pgetc2() { return pgetc_macro(); }
6084 * Read a line from the script.
6087 static inline char *
6088 pfgets(char *line, int len)
6094 while (--nleft > 0) {
6113 char *buf = parsefile->buf;
6117 #ifdef BB_FEATURE_COMMAND_EDITING
6119 if (!iflag || parsefile->fd)
6120 nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
6122 nr = cmdedit_read_input((char*)cmdedit_prompt, buf);
6126 nr = safe_read(parsefile->fd, buf, BUFSIZ - 1);
6130 if (parsefile->fd == 0 && errno == EWOULDBLOCK) {
6131 int flags = fcntl(0, F_GETFL, 0);
6132 if (flags >= 0 && flags & O_NONBLOCK) {
6133 flags &=~ O_NONBLOCK;
6134 if (fcntl(0, F_SETFL, flags) >= 0) {
6135 out2str("sh: turning off NDELAY mode\n");
6147 struct strpush *sp = parsefile->strpush;
6152 if (parsenextc[-1] == ' ' || parsenextc[-1] == '\t') {
6157 if (sp->string != sp->ap->val) {
6161 sp->ap->flag &= ~ALIASINUSE;
6162 if (sp->ap->flag & ALIASDEAD) {
6163 unalias(sp->ap->name);
6167 parsenextc = sp->prevstring;
6168 parsenleft = sp->prevnleft;
6169 /*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
6170 parsefile->strpush = sp->prev;
6171 if (sp != &(parsefile->basestrpush))
6178 * Refill the input buffer and return the next input character:
6180 * 1) If a string was pushed back on the input, pop it;
6181 * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
6182 * from a string so we can't refill the buffer, return EOF.
6183 * 3) If the is more stuff in this buffer, use it else call read to fill it.
6184 * 4) Process input up to the next newline, deleting nul characters.
6194 while (parsefile->strpush) {
6196 if (parsenleft == -1 && parsefile->strpush->ap &&
6197 parsenextc[-1] != ' ' && parsenextc[-1] != '\t') {
6202 if (--parsenleft >= 0)
6203 return (*parsenextc++);
6205 if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
6210 if (parselleft <= 0) {
6211 if ((parselleft = preadfd()) <= 0) {
6212 parselleft = parsenleft = EOF_NLEFT;
6219 /* delete nul characters */
6220 for (more = 1; more;) {
6228 parsenleft = q - parsenextc;
6229 more = 0; /* Stop processing here */
6235 if (--parselleft <= 0 && more) {
6236 parsenleft = q - parsenextc - 1;
6247 out2str(parsenextc);
6252 return *parsenextc++;
6257 * Push a string back onto the input at this current parsefile level.
6258 * We handle aliases this way.
6261 pushstring(char *s, int len, void *ap)
6266 /*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
6267 if (parsefile->strpush) {
6268 sp = ckmalloc(sizeof (struct strpush));
6269 sp->prev = parsefile->strpush;
6270 parsefile->strpush = sp;
6272 sp = parsefile->strpush = &(parsefile->basestrpush);
6273 sp->prevstring = parsenextc;
6274 sp->prevnleft = parsenleft;
6276 sp->ap = (struct alias *)ap;
6278 ((struct alias *)ap)->flag |= ALIASINUSE;
6289 * Like setinputfile, but takes input from a string.
6293 setinputstring(char *string)
6297 parsenextc = string;
6298 parsenleft = strlen(string);
6299 parsefile->buf = NULL;
6307 * To handle the "." command, a stack of input files is used. Pushfile
6308 * adds a new entry to the stack and popfile restores the previous level.
6313 struct parsefile *pf;
6315 parsefile->nleft = parsenleft;
6316 parsefile->lleft = parselleft;
6317 parsefile->nextc = parsenextc;
6318 parsefile->linno = plinno;
6319 pf = (struct parsefile *)ckmalloc(sizeof (struct parsefile));
6320 pf->prev = parsefile;
6323 pf->basestrpush.prev = NULL;
6328 static void restartjob (struct job *);
6330 static void freejob (struct job *);
6331 static struct job *getjob (const char *);
6332 static int dowait (int, struct job *);
6333 static void waitonint(int);
6337 * We keep track of whether or not fd0 has been redirected. This is for
6338 * background commands, where we want to redirect fd0 to /dev/null only
6339 * if it hasn't already been redirected.
6341 static int fd0_redirected = 0;
6343 /* Return true if fd 0 has already been redirected at least once. */
6345 fd0_redirected_p (void)
6347 return fd0_redirected != 0;
6350 static void dupredirect (const union node *, int, int fd1dup);
6354 * Turn job control on and off.
6356 * Note: This code assumes that the third arg to ioctl is a character
6357 * pointer, which is true on Berkeley systems but not System V. Since
6358 * System V doesn't have job control yet, this isn't a problem now.
6363 static void setjobctl(int enable)
6365 #ifdef OLD_TTY_DRIVER
6369 if (enable == jobctl || rootshell == 0)
6372 do { /* while we are in the background */
6373 #ifdef OLD_TTY_DRIVER
6374 if (ioctl(2, TIOCGPGRP, (char *)&initialpgrp) < 0) {
6376 initialpgrp = tcgetpgrp(2);
6377 if (initialpgrp < 0) {
6379 out2str("sh: can't access tty; job control turned off\n");
6383 if (initialpgrp == -1)
6384 initialpgrp = getpgrp();
6385 else if (initialpgrp != getpgrp()) {
6386 killpg(initialpgrp, SIGTTIN);
6390 #ifdef OLD_TTY_DRIVER
6391 if (ioctl(2, TIOCGETD, (char *)&ldisc) < 0 || ldisc != NTTYDISC) {
6392 out2str("sh: need new tty driver to run job control; job control turned off\n");
6400 setpgid(0, rootpid);
6401 #ifdef OLD_TTY_DRIVER
6402 ioctl(2, TIOCSPGRP, (char *)&rootpid);
6404 tcsetpgrp(2, rootpid);
6406 } else { /* turning job control off */
6407 setpgid(0, initialpgrp);
6408 #ifdef OLD_TTY_DRIVER
6409 ioctl(2, TIOCSPGRP, (char *)&initialpgrp);
6411 tcsetpgrp(2, initialpgrp);
6437 "Usage: kill [-s sigspec | -signum | -sigspec] [pid | job]... or\n"
6438 "kill -l [exitstatus]"
6442 if (*argv[1] == '-') {
6443 signo = decode_signal(argv[1] + 1, 1);
6447 while ((c = nextopt("ls:")) != '\0')
6453 signo = decode_signal(optionarg, 1);
6456 "invalid signal number or name: %s",
6464 "nextopt returned character code 0%o", c);
6471 if (!list && signo < 0)
6474 if ((signo < 0 || !*argptr) ^ list) {
6483 for (i = 1; i < NSIG; i++) {
6484 name = u_signal_names(0, &i, 1);
6486 printf(snlfmt, name);
6490 name = u_signal_names(*argptr, &signo, -1);
6492 printf(snlfmt, name);
6494 error("invalid signal number or exit status: %s",
6500 if (**argptr == '%') {
6501 jp = getjob(*argptr);
6502 if (jp->jobctl == 0)
6503 error("job %s not created under job control",
6505 pid = -jp->ps[0].pid;
6507 pid = atoi(*argptr);
6508 if (kill(pid, signo) != 0)
6509 error("%s: %m", *argptr);
6510 } while (*++argptr);
6524 jp = getjob(argv[1]);
6525 if (jp->jobctl == 0)
6526 error("job not created under job control");
6527 pgrp = jp->ps[0].pid;
6528 #ifdef OLD_TTY_DRIVER
6529 ioctl(2, TIOCSPGRP, (char *)&pgrp);
6535 status = waitforjob(jp);
6549 jp = getjob(*++argv);
6550 if (jp->jobctl == 0)
6551 error("job not created under job control");
6553 } while (--argc > 1);
6562 struct procstat *ps;
6565 if (jp->state == JOBDONE)
6568 killpg(jp->ps[0].pid, SIGCONT);
6569 for (ps = jp->ps, i = jp->nprocs ; --i >= 0 ; ps++) {
6570 if (WIFSTOPPED(ps->status)) {
6579 static void showjobs(int change);
6593 * Print a list of jobs. If "change" is nonzero, only print jobs whose
6594 * statuses have changed since the last call to showjobs.
6596 * If the shell is interrupted in the process of creating a job, the
6597 * result may be a job structure containing zero processes. Such structures
6598 * will be freed here.
6609 struct procstat *ps;
6613 TRACE(("showjobs(%d) called\n", change));
6614 while (dowait(0, (struct job *)NULL) > 0);
6615 for (jobno = 1, jp = jobtab ; jobno <= njobs ; jobno++, jp++) {
6618 if (jp->nprocs == 0) {
6622 if (change && ! jp->changed)
6624 procno = jp->nprocs;
6625 for (ps = jp->ps ; ; ps++) { /* for each process */
6627 snprintf(s, 64, "[%d] %ld ", jobno,
6630 snprintf(s, 64, " %ld ",
6635 if (ps->status == -1) {
6636 /* don't print anything */
6637 } else if (WIFEXITED(ps->status)) {
6638 snprintf(s, 64, "Exit %d",
6639 WEXITSTATUS(ps->status));
6642 if (WIFSTOPPED(ps->status))
6643 i = WSTOPSIG(ps->status);
6644 else /* WIFSIGNALED(ps->status) */
6646 i = WTERMSIG(ps->status);
6647 if ((i & 0x7F) < NSIG && sys_siglist[i & 0x7F])
6648 strcpy(s, sys_siglist[i & 0x7F]);
6650 snprintf(s, 64, "Signal %d", i & 0x7F);
6651 if (WCOREDUMP(ps->status))
6652 strcat(s, " (core dumped)");
6657 "%*c%s\n", 30 - col >= 0 ? 30 - col : 0, ' ',
6664 if (jp->state == JOBDONE) {
6672 * Mark a job structure as unused.
6676 freejob(struct job *jp)
6678 const struct procstat *ps;
6682 for (i = jp->nprocs, ps = jp->ps ; --i >= 0 ; ps++) {
6683 if (ps->cmd != nullstr)
6686 if (jp->ps != &jp->ps0)
6690 if (curjob == jp - jobtab + 1)
6709 job = getjob(*++argv);
6713 for (;;) { /* loop until process terminated or stopped */
6716 status = job->ps[job->nprocs - 1].status;
6722 if (WIFEXITED(status))
6723 retval = WEXITSTATUS(status);
6725 else if (WIFSTOPPED(status))
6726 retval = WSTOPSIG(status) + 128;
6729 /* XXX: limits number of signals */
6730 retval = WTERMSIG(status) + 128;
6735 for (jp = jobtab ; ; jp++) {
6736 if (jp >= jobtab + njobs) { /* no running procs */
6739 if (jp->used && jp->state == 0)
6743 if (dowait(2, 0) < 0 && errno == EINTR) {
6752 * Convert a job name to a job structure.
6756 getjob(const char *name)
6766 if ((jobno = curjob) == 0 || jobtab[jobno - 1].used == 0)
6767 error("No current job");
6768 return &jobtab[jobno - 1];
6770 error("No current job");
6772 } else if (name[0] == '%') {
6773 if (is_digit(name[1])) {
6774 jobno = number(name + 1);
6775 if (jobno > 0 && jobno <= njobs
6776 && jobtab[jobno - 1].used != 0)
6777 return &jobtab[jobno - 1];
6779 } else if (name[1] == '%' && name[2] == '\0') {
6783 struct job *found = NULL;
6784 for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
6785 if (jp->used && jp->nprocs > 0
6786 && prefix(name + 1, jp->ps[0].cmd)) {
6788 error("%s: ambiguous", name);
6795 } else if (is_number(name, &pid)) {
6796 for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
6797 if (jp->used && jp->nprocs > 0
6798 && jp->ps[jp->nprocs - 1].pid == pid)
6802 error("No such job: %s", name);
6809 * Return a new job structure,
6813 makejob(const union node *node, int nprocs)
6818 for (i = njobs, jp = jobtab ; ; jp++) {
6822 jobtab = ckmalloc(4 * sizeof jobtab[0]);
6824 jp = ckmalloc((njobs + 4) * sizeof jobtab[0]);
6825 memcpy(jp, jobtab, njobs * sizeof jp[0]);
6826 /* Relocate `ps' pointers */
6827 for (i = 0; i < njobs; i++)
6828 if (jp[i].ps == &jobtab[i].ps0)
6829 jp[i].ps = &jp[i].ps0;
6833 jp = jobtab + njobs;
6834 for (i = 4 ; --i >= 0 ; jobtab[njobs++].used = 0);
6847 jp->jobctl = jobctl;
6850 jp->ps = ckmalloc(nprocs * sizeof (struct procstat));
6855 TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long)node, nprocs,
6862 * Fork of a subshell. If we are doing job control, give the subshell its
6863 * own process group. Jp is a job structure that the job is to be added to.
6864 * N is the command that will be evaluated by the child. Both jp and n may
6865 * be NULL. The mode parameter can be one of the following:
6866 * FORK_FG - Fork off a foreground process.
6867 * FORK_BG - Fork off a background process.
6868 * FORK_NOJOB - Like FORK_FG, but don't give the process its own
6869 * process group even if job control is on.
6871 * When job control is turned off, background processes have their standard
6872 * input redirected to /dev/null (except for the second and later processes
6879 forkshell(struct job *jp, const union node *n, int mode)
6885 const char *devnull = _PATH_DEVNULL;
6886 const char *nullerr = "Can't open %s";
6888 TRACE(("forkshell(%%%d, 0x%lx, %d) called\n", jp - jobtab, (long)n,
6893 TRACE(("Fork failed, errno=%d\n", errno));
6895 error("Cannot fork");
6902 TRACE(("Child shell %d\n", getpid()));
6903 wasroot = rootshell;
6909 jobctl = 0; /* do job control only in root shell */
6910 if (wasroot && mode != FORK_NOJOB && mflag) {
6911 if (jp == NULL || jp->nprocs == 0)
6914 pgrp = jp->ps[0].pid;
6916 if (mode == FORK_FG) {
6917 /*** this causes superfluous TIOCSPGRPS ***/
6918 #ifdef OLD_TTY_DRIVER
6919 if (ioctl(2, TIOCSPGRP, (char *)&pgrp) < 0)
6920 error("TIOCSPGRP failed, errno=%d", errno);
6922 if (tcsetpgrp(2, pgrp) < 0)
6923 error("tcsetpgrp failed, errno=%d", errno);
6928 } else if (mode == FORK_BG) {
6931 if ((jp == NULL || jp->nprocs == 0) &&
6932 ! fd0_redirected_p ()) {
6934 if (open(devnull, O_RDONLY) != 0)
6935 error(nullerr, devnull);
6939 if (mode == FORK_BG) {
6942 if ((jp == NULL || jp->nprocs == 0) &&
6943 ! fd0_redirected_p ()) {
6945 if (open(devnull, O_RDONLY) != 0)
6946 error(nullerr, devnull);
6950 for (i = njobs, p = jobtab ; --i >= 0 ; p++)
6953 if (wasroot && iflag) {
6961 if (rootshell && mode != FORK_NOJOB && mflag) {
6962 if (jp == NULL || jp->nprocs == 0)
6965 pgrp = jp->ps[0].pid;
6969 if (mode == FORK_BG)
6970 backgndpid = pid; /* set $! */
6972 struct procstat *ps = &jp->ps[jp->nprocs++];
6976 if (iflag && rootshell && n)
6977 ps->cmd = commandtext(n);
6980 TRACE(("In parent shell: child = %d\n", pid));
6987 * Wait for job to finish.
6989 * Under job control we have the problem that while a child process is
6990 * running interrupts generated by the user are sent to the child but not
6991 * to the shell. This means that an infinite loop started by an inter-
6992 * active user may be hard to kill. With job control turned off, an
6993 * interactive user may place an interactive program inside a loop. If
6994 * the interactive program catches interrupts, the user doesn't want
6995 * these interrupts to also abort the loop. The approach we take here
6996 * is to have the shell ignore interrupt signals while waiting for a
6997 * forground process to terminate, and then send itself an interrupt
6998 * signal if the child process was terminated by an interrupt signal.
6999 * Unfortunately, some programs want to do a bit of cleanup and then
7000 * exit on interrupt; unless these processes terminate themselves by
7001 * sending a signal to themselves (instead of calling exit) they will
7002 * confuse this approach.
7006 waitforjob(struct job *jp)
7009 int mypgrp = getpgrp();
7013 struct sigaction act, oact;
7022 sigaction(SIGINT, 0, &act);
7023 act.sa_handler = waitonint;
7024 sigaction(SIGINT, &act, &oact);
7026 TRACE(("waitforjob(%%%d) called\n", jp - jobtab + 1));
7027 while (jp->state == 0) {
7035 sigaction(SIGINT, &oact, 0);
7036 if (intreceived && trap[SIGINT]) kill(getpid(), SIGINT);
7040 #ifdef OLD_TTY_DRIVER
7041 if (ioctl(2, TIOCSPGRP, (char *)&mypgrp) < 0)
7042 error("TIOCSPGRP failed, errno=%d\n", errno);
7044 if (tcsetpgrp(2, mypgrp) < 0)
7045 error("tcsetpgrp failed, errno=%d\n", errno);
7048 if (jp->state == JOBSTOPPED)
7049 curjob = jp - jobtab + 1;
7051 status = jp->ps[jp->nprocs - 1].status;
7052 /* convert to 8 bits */
7053 if (WIFEXITED(status))
7054 st = WEXITSTATUS(status);
7056 else if (WIFSTOPPED(status))
7057 st = WSTOPSIG(status) + 128;
7060 st = WTERMSIG(status) + 128;
7064 * This is truly gross.
7065 * If we're doing job control, then we did a TIOCSPGRP which
7066 * caused us (the shell) to no longer be in the controlling
7067 * session -- so we wouldn't have seen any ^C/SIGINT. So, we
7068 * intuit from the subprocess exit status whether a SIGINT
7069 * occured, and if so interrupt ourselves. Yuck. - mycroft
7071 if (WIFSIGNALED(status) && WTERMSIG(status) == SIGINT)
7074 if (jp->state == JOBDONE)
7085 * Wait for a process to terminate.
7089 * Do a wait system call. If job control is compiled in, we accept
7090 * stopped processes. If block is zero, we return a value of zero
7091 * rather than blocking.
7093 * System V doesn't have a non-blocking wait system call. It does
7094 * have a SIGCLD signal that is sent to a process when one of it's
7095 * children dies. The obvious way to use SIGCLD would be to install
7096 * a handler for SIGCLD which simply bumped a counter when a SIGCLD
7097 * was received, and have waitproc bump another counter when it got
7098 * the status of a process. Waitproc would then know that a wait
7099 * system call would not block if the two counters were different.
7100 * This approach doesn't work because if a process has children that
7101 * have not been waited for, System V will send it a SIGCLD when it
7102 * installs a signal handler for SIGCLD. What this means is that when
7103 * a child exits, the shell will be sent SIGCLD signals continuously
7104 * until is runs out of stack space, unless it does a wait call before
7105 * restoring the signal handler. The code below takes advantage of
7106 * this (mis)feature by installing a signal handler for SIGCLD and
7107 * then checking to see whether it was called. If there are any
7108 * children to be waited for, it will be.
7113 waitproc(int block, int *status)
7124 return wait3(status, flags, (struct rusage *)NULL);
7128 dowait(int block, struct job *job)
7132 struct procstat *sp;
7134 struct job *thisjob;
7140 TRACE(("dowait(%d) called\n", block));
7142 pid = waitproc(block, &status);
7143 TRACE(("wait returns %d, status=%d\n", pid, status));
7144 } while (!(block & 2) && pid == -1 && errno == EINTR);
7149 for (jp = jobtab ; jp < jobtab + njobs ; jp++) {
7153 for (sp = jp->ps ; sp < jp->ps + jp->nprocs ; sp++) {
7156 if (sp->pid == pid) {
7157 TRACE(("Changing status of proc %d from 0x%x to 0x%x\n", pid, sp->status, status));
7158 sp->status = status;
7161 if (sp->status == -1)
7163 else if (WIFSTOPPED(sp->status))
7166 if (stopped) { /* stopped or done */
7167 int state = done? JOBDONE : JOBSTOPPED;
7168 if (jp->state != state) {
7169 TRACE(("Job %d: changing state from %d to %d\n", jp - jobtab + 1, jp->state, state));
7172 if (done && curjob == jp - jobtab + 1)
7173 curjob = 0; /* no current job */
7180 if (! rootshell || ! iflag || (job && thisjob == job)) {
7181 core = WCOREDUMP(status);
7183 if (WIFSTOPPED(status)) sig = WSTOPSIG(status);
7186 if (WIFEXITED(status)) sig = 0;
7187 else sig = WTERMSIG(status);
7189 if (sig != 0 && sig != SIGINT && sig != SIGPIPE) {
7191 out2fmt("%d: ", pid);
7193 if (sig == SIGTSTP && rootshell && iflag)
7195 (long)(job - jobtab + 1));
7197 if (sig < NSIG && sys_siglist[sig])
7198 out2str(sys_siglist[sig]);
7200 out2fmt("Signal %d", sig);
7202 out2str(" - core dumped");
7205 TRACE(("Not printing status: status=%d, sig=%d\n",
7209 TRACE(("Not printing status, rootshell=%d, job=0x%x\n", rootshell, job));
7211 thisjob->changed = 1;
7220 * return 1 if there are stopped jobs, otherwise 0
7230 for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
7233 if (jp->state == JOBSTOPPED) {
7234 out2str("You have stopped jobs.\n");
7244 * Return a string identifying a command (to be printed by the
7248 static char *cmdnextc;
7249 static int cmdnleft;
7250 #define MAXCMDTEXT 200
7253 cmdputs(const char *s)
7264 while ((c = *p++) != '\0') {
7267 else if (c == CTLVAR) {
7272 } else if (c == '=' && subtype != 0) {
7273 *q++ = "}-+?="[(subtype & VSTYPE) - VSNORMAL];
7275 } else if (c == CTLENDVAR) {
7277 } else if (c == CTLBACKQ || c == CTLBACKQ+CTLQUOTE)
7278 cmdnleft++; /* ignore it */
7281 if (--cmdnleft <= 0) {
7291 #define CMDTXT_TABLE
7294 * To collect a lot of redundant code in cmdtxt() case statements, we
7295 * implement a mini language here. Each type of node struct has an
7296 * associated instruction sequence that operates on its members via
7297 * their offsets. The instruction are pack in unsigned chars with
7298 * format IIDDDDDE where the bits are
7299 * I : part of the instruction opcode, which are
7300 * 00 : member is a pointer to another node -- process it recursively
7301 * 40 : member is a pointer to a char string -- output it
7302 * 80 : output the string whose index is stored in the data field
7303 * CC : flag signaling that this case needs external processing
7304 * D : data - either the (shifted) index of a fixed string to output or
7305 * the actual offset of the member to operate on in the struct
7306 * (since we assume bit 0 is set, the offset is not shifted)
7307 * E : flag signaling end of instruction sequence
7309 * WARNING: In order to handle larger offsets for 64bit archs, this code
7310 * assumes that no offset can be an odd number and stores the
7311 * end-of-instructions flag in bit 0.
7314 #define CMDTXT_NOMORE 0x01 /* NOTE: no offset should be odd */
7315 #define CMDTXT_CHARPTR 0x40
7316 #define CMDTXT_STRING 0x80
7317 #define CMDTXT_SPECIAL 0xC0
7318 #define CMDTXT_OFFSETMASK 0x3E
7320 static const char * const cmdtxt_strings[] = {
7321 /* 0 1 2 3 4 5 6 7 */
7322 "; ", "(", ")", " && ", " || ", "if ", "; then ", "...",
7323 /* 8 9 10 11 12 13 */
7324 "while ", "; do ", "; done", "until ", "for ", " in ...",
7326 "case ", "???", "() ...", "<<..."
7329 static const char * const redir_strings[] = {
7330 ">", "<", "<>", ">>", ">|", ">&", "<&"
7333 static const unsigned char cmdtxt_ops[] = {
7334 #define CMDTXT_NSEMI 0
7335 offsetof(union node, nbinary.ch1),
7337 offsetof(union node, nbinary.ch2)|CMDTXT_NOMORE,
7338 #define CMDTXT_NCMD (CMDTXT_NSEMI + 3)
7339 #define CMDTXT_NPIPE (CMDTXT_NCMD)
7340 #define CMDTXT_NCASE (CMDTXT_NCMD)
7341 #define CMDTXT_NTO (CMDTXT_NCMD)
7342 #define CMDTXT_NFROM (CMDTXT_NCMD)
7343 #define CMDTXT_NFROMTO (CMDTXT_NCMD)
7344 #define CMDTXT_NAPPEND (CMDTXT_NCMD)
7345 #define CMDTXT_NTOOV (CMDTXT_NCMD)
7346 #define CMDTXT_NTOFD (CMDTXT_NCMD)
7347 #define CMDTXT_NFROMFD (CMDTXT_NCMD)
7349 #define CMDTXT_NREDIR (CMDTXT_NPIPE + 1)
7350 #define CMDTXT_NBACKGND (CMDTXT_NREDIR)
7351 offsetof(union node, nredir.n)|CMDTXT_NOMORE,
7352 #define CMDTXT_NSUBSHELL (CMDTXT_NBACKGND + 1)
7353 (1*2)|CMDTXT_STRING,
7354 offsetof(union node, nredir.n),
7355 (2*2)|CMDTXT_STRING|CMDTXT_NOMORE,
7356 #define CMDTXT_NAND (CMDTXT_NSUBSHELL + 3)
7357 offsetof(union node, nbinary.ch1),
7358 (3*2)|CMDTXT_STRING,
7359 offsetof(union node, nbinary.ch2)|CMDTXT_NOMORE,
7360 #define CMDTXT_NOR (CMDTXT_NAND + 3)
7361 offsetof(union node, nbinary.ch1),
7362 (4*2)|CMDTXT_STRING,
7363 offsetof(union node, nbinary.ch2)|CMDTXT_NOMORE,
7364 #define CMDTXT_NIF (CMDTXT_NOR + 3)
7365 (5*2)|CMDTXT_STRING,
7366 offsetof(union node, nif.test),
7367 (6*2)|CMDTXT_STRING,
7368 offsetof(union node, nif.ifpart),
7369 (7*2)|CMDTXT_STRING|CMDTXT_NOMORE,
7370 #define CMDTXT_NWHILE (CMDTXT_NIF + 5)
7371 (8*2)|CMDTXT_STRING,
7372 offsetof(union node, nbinary.ch1),
7373 (9*2)|CMDTXT_STRING,
7374 offsetof(union node, nbinary.ch2),
7375 (10*2)|CMDTXT_STRING|CMDTXT_NOMORE,
7376 #define CMDTXT_NUNTIL (CMDTXT_NWHILE + 5)
7377 (11*2)|CMDTXT_STRING,
7378 offsetof(union node, nbinary.ch1),
7379 (9*2)|CMDTXT_STRING,
7380 offsetof(union node, nbinary.ch2),
7381 (10*2)|CMDTXT_STRING|CMDTXT_NOMORE,
7382 #define CMDTXT_NFOR (CMDTXT_NUNTIL + 5)
7383 (12*2)|CMDTXT_STRING,
7384 offsetof(union node, nfor.var)|CMDTXT_CHARPTR,
7385 (13*2)|CMDTXT_STRING|CMDTXT_NOMORE,
7386 #define CMDTXT_NCLIST (CMDTXT_NFOR + 3) /* TODO: IS THIS CORRECT??? */
7387 #define CMDTXT_NNOT (CMDTXT_NCLIST) /* TODO: IS THIS CORRECT??? */
7388 (15*2)|CMDTXT_STRING|CMDTXT_NOMORE,
7389 #define CMDTXT_NDEFUN (CMDTXT_NCLIST + 1)
7390 offsetof(union node, narg.text)|CMDTXT_CHARPTR,
7391 (16*2)|CMDTXT_STRING|CMDTXT_NOMORE,
7392 #define CMDTXT_NARG (CMDTXT_NDEFUN + 2)
7393 offsetof(union node, narg.text)|CMDTXT_CHARPTR|CMDTXT_NOMORE,
7394 #define CMDTXT_NHERE (CMDTXT_NARG + 1)
7395 #define CMDTXT_NXHERE (CMDTXT_NHERE)
7396 (17*2)|CMDTXT_STRING|CMDTXT_NOMORE,
7399 #if CMDTXT_NXHERE != 36
7400 #error CMDTXT_NXHERE
7403 static const unsigned char cmdtxt_ops_index[26] = {
7433 cmdtxt(const union node *n)
7440 p = cmdtxt_ops + (int) cmdtxt_ops_index[n->type];
7441 if ((*p & CMDTXT_SPECIAL) != CMDTXT_SPECIAL) { /* normal case */
7443 if (*p & CMDTXT_STRING) { /* output fixed string */
7444 cmdputs(cmdtxt_strings[((int)(*p & CMDTXT_OFFSETMASK) >> 1)]);
7446 const char *pf = ((const char *) n)
7447 + ((int)(*p & CMDTXT_OFFSETMASK));
7448 if (*p & CMDTXT_CHARPTR) { /* output dynamic string */
7449 cmdputs(*((const char **) pf));
7450 } else { /* output field */
7451 cmdtxt(*((const union node **) pf));
7454 } while (!(*p++ & CMDTXT_NOMORE));
7455 } else if (n->type == NCMD) {
7457 for (np = n->ncmd.args ; np ; np = np->narg.next) {
7462 for (np = n->ncmd.redirect ; np ; np = np->nfile.next) {
7466 } else if (n->type == NPIPE) {
7467 struct nodelist *lp;
7468 for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
7473 } else if (n->type == NCASE) {
7474 cmdputs(cmdtxt_strings[14]);
7475 cmdputs(n->ncase.expr->narg.text);
7476 cmdputs(cmdtxt_strings[13]);
7478 #if (NTO != 16) || (NFROM != 17) || (NFROMTO != 18) || (NAPPEND != 19) || (NTOOV != 20) || (NTOFD != 21) || (NFROMFD != 22)
7479 #error Assumption violated regarding range and ordering of NTO ... NFROMFD!
7484 assert((n->type >= NTO) && (n->type <= NFROMFD));
7487 p = redir_strings[n->type - NTO];
7488 if (n->nfile.fd != ('>' == *p)) {
7489 s[0] = n->nfile.fd + '0';
7494 if (n->type >= NTOFD) {
7495 s[0] = n->ndup.dupfd + '0';
7499 cmdtxt(n->nfile.fname);
7503 #else /* CMDTXT_TABLE */
7505 cmdtxt(const union node *n)
7508 struct nodelist *lp;
7517 cmdtxt(n->nbinary.ch1);
7519 cmdtxt(n->nbinary.ch2);
7522 cmdtxt(n->nbinary.ch1);
7524 cmdtxt(n->nbinary.ch2);
7527 cmdtxt(n->nbinary.ch1);
7529 cmdtxt(n->nbinary.ch2);
7532 for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
7540 cmdtxt(n->nredir.n);
7545 cmdtxt(n->nredir.n);
7549 cmdtxt(n->nif.test);
7551 cmdtxt(n->nif.ifpart);
7560 cmdtxt(n->nbinary.ch1);
7562 cmdtxt(n->nbinary.ch2);
7567 cmdputs(n->nfor.var);
7572 cmdputs(n->ncase.expr->narg.text);
7576 cmdputs(n->narg.text);
7580 for (np = n->ncmd.args ; np ; np = np->narg.next) {
7585 for (np = n->ncmd.redirect ; np ; np = np->nfile.next) {
7591 cmdputs(n->narg.text);
7594 p = ">"; i = 1; goto redir;
7596 p = ">>"; i = 1; goto redir;
7598 p = ">&"; i = 1; goto redir;
7600 p = ">|"; i = 1; goto redir;
7602 p = "<"; i = 0; goto redir;
7604 p = "<&"; i = 0; goto redir;
7606 p = "<>"; i = 0; goto redir;
7608 if (n->nfile.fd != i) {
7609 s[0] = n->nfile.fd + '0';
7614 if (n->type == NTOFD || n->type == NFROMFD) {
7615 s[0] = n->ndup.dupfd + '0';
7619 cmdtxt(n->nfile.fname);
7631 #endif /* CMDTXT_TABLE */
7634 commandtext(const union node *n)
7638 cmdnextc = name = ckmalloc(MAXCMDTEXT);
7639 cmdnleft = MAXCMDTEXT - 4;
7646 static void waitonint(int sig) {
7651 * Routines to check for mail. (Perhaps make part of main.c?)
7655 #define MAXMBOXES 10
7658 static int nmboxes; /* number of mailboxes */
7659 static time_t mailtime[MAXMBOXES]; /* times of mailboxes */
7664 * Print appropriate message(s) if mail has arrived. If the argument is
7665 * nozero, then the value of MAIL has changed, so we just update the
7676 struct stackmark smark;
7683 setstackmark(&smark);
7684 mpath = mpathset()? mpathval() : mailval();
7685 for (i = 0 ; i < nmboxes ; i++) {
7686 p = padvance(&mpath, nullstr);
7691 for (q = p ; *q ; q++);
7696 q[-1] = '\0'; /* delete trailing '/' */
7697 if (stat(p, &statb) < 0)
7699 if (statb.st_size > mailtime[i] && ! silent) {
7701 pathopt? pathopt : "you have mail");
7703 mailtime[i] = statb.st_size;
7706 popstackmark(&smark);
7712 static short profile_buf[16384];
7716 static void read_profile (const char *);
7717 static void cmdloop (int);
7718 static void options (int);
7719 static void setoption (int, int);
7720 static void procargs (int, char **);
7724 * Main routine. We initialize things, parse the arguments, execute
7725 * profiles if we're a login shell, and then call cmdloop to execute
7726 * commands. The setjmp call sets up the location to jump to when an
7727 * exception occurs. When an exception occurs the variable "state"
7728 * is used to figure out how far we had gotten.
7732 ash_main(argc, argv)
7736 struct jmploc jmploc;
7737 struct stackmark smark;
7741 BLTINCMD = find_builtin("builtin");
7742 EXECCMD = find_builtin("exec");
7743 EVALCMD = find_builtin("eval");
7745 #ifndef BB_FEATURE_SH_FANCY_PROMPT
7751 monitor(4, etext, profile_buf, sizeof profile_buf, 50);
7753 #if defined(linux) || defined(__GNU__)
7754 signal(SIGCHLD, SIG_DFL);
7757 if (setjmp(jmploc.loc)) {
7760 * When a shell procedure is executed, we raise the
7761 * exception EXSHELLPROC to clean up before executing
7762 * the shell procedure.
7764 if (exception == EXSHELLPROC) {
7770 if (exception == EXEXEC) {
7771 exitstatus = exerrno;
7772 } else if (exception == EXERROR) {
7775 if (state == 0 || iflag == 0 || ! rootshell)
7776 exitshell(exitstatus);
7779 if (exception == EXINT) {
7782 popstackmark(&smark);
7783 FORCEINTON; /* enable interrupts */
7786 else if (state == 2)
7788 else if (state == 3)
7796 trputs("Shell args: "); trargs(argv);
7801 setstackmark(&smark);
7802 procargs(argc, argv);
7803 if (argv[0] && argv[0][0] == '-') {
7805 read_profile("/etc/profile");
7808 read_profile(".profile");
7813 if (getuid() == geteuid() && getgid() == getegid()) {
7815 if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
7817 read_profile(shinit);
7824 if (sflag == 0 || minusc) {
7825 static const char sigs[] = {
7826 SIGINT, SIGQUIT, SIGHUP,
7832 #define SIGSSIZE ((sizeof(sigs)/sizeof(sigs[0])) - 1) /* trailing nul */
7835 for (i = 0; i < SIGSSIZE; i++)
7840 evalstring(minusc, 0);
7842 if (sflag || minusc == NULL) {
7843 state4: /* XXX ??? - why isn't this before the "if" statement */
7849 exitshell(exitstatus);
7855 * Read and execute commands. "Top" is nonzero for the top level command
7856 * loop; it turns on prompting if the shell is interactive.
7863 struct stackmark smark;
7867 TRACE(("cmdloop(%d) called\n", top));
7868 setstackmark(&smark);
7879 n = parsecmd(inter);
7880 /* showtree(n); DEBUG */
7882 if (!top || numeof >= 50)
7884 if (!stoppedjobs()) {
7887 out2str("\nUse \"exit\" to leave shell.\n");
7890 } else if (n != NULL && nflag == 0) {
7891 job_warning = (job_warning == 2) ? 1 : 0;
7895 popstackmark(&smark);
7896 setstackmark(&smark);
7897 if (evalskip == SKIPFILE) {
7902 popstackmark(&smark);
7908 * Read /etc/profile or .profile. Return on error.
7920 if ((fd = open(name, O_RDONLY)) >= 0)
7925 /* -q turns off -x and -v just when executing init files */
7926 /* Note: Might do a little redundant work, but reduces code size. */
7941 * Read a file containing shell functions.
7945 readcmdfile(const char *name)
7950 if ((fd = open(name, O_RDONLY)) >= 0)
7953 error("Can't open %s", name);
7962 * Take commands from a file. To be compatable we should do a path
7963 * search for the file, which is necessary to find sub-commands.
7967 static inline char *
7968 find_dot_file(char *mybasename)
7971 const char *path = pathval();
7974 /* don't try this for absolute or relative paths */
7975 if (strchr(mybasename, '/'))
7978 while ((fullname = padvance(&path, mybasename)) != NULL) {
7979 if ((stat(fullname, &statb) == 0) && S_ISREG(statb.st_mode)) {
7981 * Don't bother freeing here, since it will
7982 * be freed by the caller.
7986 stunalloc(fullname);
7989 /* not found in the PATH */
7990 error("%s: not found", mybasename);
8002 for (sp = cmdenviron; sp ; sp = sp->next)
8003 setvareq(savestr(sp->text), VSTRFIXED|VTEXTFIXED);
8005 if (argc >= 2) { /* That's what SVR2 does */
8007 struct stackmark smark;
8009 setstackmark(&smark);
8010 fullname = find_dot_file(argv[1]);
8011 setinputfile(fullname, 1);
8012 commandname = fullname;
8015 popstackmark(&smark);
8029 exitstatus = number(argv[1]);
8031 exitstatus = oexitstatus;
8032 exitshell(exitstatus);
8041 nbytes = ALIGN(nbytes);
8042 if (nbytes > stacknleft) {
8044 struct stack_block *sp;
8047 if (blocksize < MINSIZE)
8048 blocksize = MINSIZE;
8050 sp = ckmalloc(sizeof(struct stack_block) - MINSIZE + blocksize);
8052 stacknxt = sp->space;
8053 stacknleft = blocksize;
8059 stacknleft -= nbytes;
8065 stunalloc(pointer p)
8068 if (p == NULL) { /*DEBUG */
8069 write(2, "stunalloc\n", 10);
8073 if (!(stacknxt >= (char *)p && (char *)p >= stackp->space)) {
8076 stacknleft += stacknxt - (char *)p;
8082 setstackmark(struct stackmark *mark)
8084 mark->stackp = stackp;
8085 mark->stacknxt = stacknxt;
8086 mark->stacknleft = stacknleft;
8087 mark->marknext = markp;
8093 popstackmark(struct stackmark *mark)
8095 struct stack_block *sp;
8098 markp = mark->marknext;
8099 while (stackp != mark->stackp) {
8104 stacknxt = mark->stacknxt;
8105 stacknleft = mark->stacknleft;
8111 * When the parser reads in a string, it wants to stick the string on the
8112 * stack and only adjust the stack pointer when it knows how big the
8113 * string is. Stackblock (defined in stack.h) returns a pointer to a block
8114 * of space on top of the stack and stackblocklen returns the length of
8115 * this block. Growstackblock will grow this space by at least one byte,
8116 * possibly moving it (like realloc). Grabstackblock actually allocates the
8117 * part of the block that has been used.
8121 growstackblock(void) {
8123 int newlen = ALIGN(stacknleft * 2 + 100);
8124 char *oldspace = stacknxt;
8125 int oldlen = stacknleft;
8126 struct stack_block *sp;
8127 struct stack_block *oldstackp;
8129 if (stacknxt == stackp->space && stackp != &stackbase) {
8134 sp = ckrealloc((pointer)sp, sizeof(struct stack_block) - MINSIZE + newlen);
8137 stacknxt = sp->space;
8138 stacknleft = newlen;
8140 /* Stack marks pointing to the start of the old block
8141 * must be relocated to point to the new block
8143 struct stackmark *xmark;
8145 while (xmark != NULL && xmark->stackp == oldstackp) {
8146 xmark->stackp = stackp;
8147 xmark->stacknxt = stacknxt;
8148 xmark->stacknleft = stacknleft;
8149 xmark = xmark->marknext;
8154 p = stalloc(newlen);
8155 memcpy(p, oldspace, oldlen);
8156 stacknxt = p; /* free the space */
8157 stacknleft += newlen; /* we just allocated */
8164 grabstackblock(int len)
8174 * The following routines are somewhat easier to use that the above.
8175 * The user declares a variable of type STACKSTR, which may be declared
8176 * to be a register. The macro STARTSTACKSTR initializes things. Then
8177 * the user uses the macro STPUTC to add characters to the string. In
8178 * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is
8179 * grown as necessary. When the user is done, she can just leave the
8180 * string there and refer to it using stackblock(). Or she can allocate
8181 * the space for it using grabstackstr(). If it is necessary to allow
8182 * someone else to use the stack temporarily and then continue to grow
8183 * the string, the user should use grabstack to allocate the space, and
8184 * then call ungrabstr(p) to return to the previous mode of operation.
8186 * USTPUTC is like STPUTC except that it doesn't check for overflow.
8187 * CHECKSTACKSPACE can be called before USTPUTC to ensure that there
8188 * is space for at least one character.
8193 growstackstr(void) {
8194 int len = stackblocksize();
8195 if (herefd >= 0 && len >= 1024) {
8196 xwrite(herefd, stackblock(), len);
8197 sstrnleft = len - 1;
8198 return stackblock();
8201 sstrnleft = stackblocksize() - len - 1;
8202 return stackblock() + len;
8207 * Called from CHECKSTRSPACE.
8211 makestrspace(size_t newlen) {
8212 int len = stackblocksize() - sstrnleft;
8215 sstrnleft = stackblocksize() - len;
8216 } while (sstrnleft < newlen);
8217 return stackblock() + len;
8223 ungrabstackstr(char *s, char *p)
8225 stacknleft += stacknxt - s;
8227 sstrnleft = stacknleft - (p - s);
8230 * Miscelaneous builtins.
8236 #if !defined(__GLIBC__) || __GLIBC__ == 2 && __GLIBC_MINOR__ < 1
8237 typedef long rlim_t;
8243 * The read builtin. The -e option causes backslashes to escape the
8244 * following character.
8246 * This uses unbuffered input, which may be avoidable in some cases.
8250 readcmd(int argc, char **argv)
8265 while ((i = nextopt("p:r")) != '\0') {
8271 if (prompt && isatty(0)) {
8272 out2str(prompt); /* read without cmdedit */
8275 if (*(ap = argptr) == NULL)
8277 if ((ifs = bltinlookup("IFS")) == NULL)
8284 if (read(0, &c, 1) != 1) {
8296 if (!rflag && c == '\\') {
8302 if (startword && *ifs == ' ' && strchr(ifs, c)) {
8306 if (backslash && c == '\\') {
8307 if (read(0, &c, 1) != 1) {
8312 } else if (ap[1] != NULL && strchr(ifs, c) != NULL) {
8314 setvar(*ap, stackblock(), 0);
8323 /* Remove trailing blanks */
8324 while (stackblock() <= --p && strchr(ifs, *p) != NULL)
8326 setvar(*ap, stackblock(), 0);
8327 while (*++ap != NULL)
8328 setvar(*ap, nullstr, 0);
8335 umaskcmd(argc, argv)
8339 static const char permuser[3] = "ugo";
8340 static const char permmode[3] = "rwx";
8341 static const short int permmask[] = {
8342 S_IRUSR, S_IWUSR, S_IXUSR,
8343 S_IRGRP, S_IWGRP, S_IXGRP,
8344 S_IROTH, S_IWOTH, S_IXOTH
8350 int symbolic_mode = 0;
8352 while (nextopt("S") != '\0') {
8361 if ((ap = *argptr) == NULL) {
8362 if (symbolic_mode) {
8365 for (i=0 ; i<3 ; i++) {
8369 for (j=0 ; j<3 ; j++) {
8370 if ((mask & permmask[3*i+j]) == 0) {
8379 printf("%.4o\n", mask);
8382 if (is_digit((unsigned char)*ap)) {
8385 if (*ap >= '8' || *ap < '0')
8386 error("Illegal number: %s", argv[1]);
8387 mask = (mask << 3) + (*ap - '0');
8388 } while (*++ap != '\0');
8391 mask = ~mask & 0777;
8392 if (parse_mode(ap, &mask) == FALSE) {
8393 error("Illegal mode: %s", ap);
8395 umask(~mask & 0777);
8404 * This code, originally by Doug Gwyn, Doug Kingston, Eric Gisin, and
8405 * Michael Rendell was ripped from pdksh 5.0.8 and hacked for use with
8406 * ash by J.T. Conklin.
8414 short factor; /* multiply by to get rlim_{cur,max} values */
8417 static const struct limits limits[] = {
8419 { "time(seconds)", RLIMIT_CPU, 1 },
8422 { "file(blocks)", RLIMIT_FSIZE, 512 },
8425 { "data(kbytes)", RLIMIT_DATA, 1024 },
8428 { "stack(kbytes)", RLIMIT_STACK, 1024 },
8431 { "coredump(blocks)", RLIMIT_CORE, 512 },
8434 { "memory(kbytes)", RLIMIT_RSS, 1024 },
8436 #ifdef RLIMIT_MEMLOCK
8437 { "locked memory(kbytes)", RLIMIT_MEMLOCK, 1024 },
8440 { "process(processes)", RLIMIT_NPROC, 1 },
8442 #ifdef RLIMIT_NOFILE
8443 { "nofiles(descriptors)", RLIMIT_NOFILE, 1 },
8446 { "vmemory(kbytes)", RLIMIT_VMEM, 1024 },
8449 { "swap(kbytes)", RLIMIT_SWAP, 1024 },
8455 ulimitcmd(argc, argv)
8459 static const char unlimited_string[] = "unlimited";
8462 enum { SOFT = 0x1, HARD = 0x2 }
8464 const struct limits *l;
8467 struct rlimit limit;
8471 while ((optc = nextopt("HSa"
8490 #ifdef RLIMIT_MEMLOCK
8496 #ifdef RLIMIT_NOFILE
8508 } else if (optc == 'S') {
8510 } else if (optc == 'a') {
8517 for (l = limits; l->name; l++) {
8518 if(l->name[0] == what)
8520 if(l->name[1]=='w' && what=='w')
8524 set = *argptr ? 1 : 0;
8528 if (all || argptr[1])
8529 error("too many arguments");
8530 if (strcmp(p, unlimited_string) == 0)
8531 val = RLIM_INFINITY;
8535 while ((c = *p++) >= '0' && c <= '9')
8537 val = (val * 10) + (long)(c - '0');
8538 if (val < (rlim_t) 0)
8542 error("bad number");
8548 for (l = limits; l->name; l++) {
8549 printf("%-20s ", l->name);
8550 getrlimit(l->cmd, &limit);
8553 val = limit.rlim_cur;
8554 else if (how & HARD)
8555 val = limit.rlim_max;
8557 if (val == RLIM_INFINITY)
8558 puts(unlimited_string);
8562 printf("%lld\n", (long long) val);
8575 getrlimit(l->cmd, &limit);
8577 limit.rlim_max = val;
8579 limit.rlim_cur = val;
8580 if (setrlimit(l->cmd, &limit) < 0)
8581 error("error setting limit (%m)");
8585 * prefix -- see if pfx is a prefix of string.
8589 prefix(char const *pfx, char const *string)
8592 if (*pfx++ != *string++)
8599 * Return true if s is a string of digits, and save munber in intptr
8604 is_number(const char *p, int *intptr)
8612 ret += digit_val(*p);
8614 } while (*p != '\0');
8621 * Convert a string of digits to an integer, printing an error message on
8626 number(const char *s)
8629 if (! is_number(s, &i))
8630 error("Illegal number: %s", s);
8635 * Produce a possibly single quoted string suitable as input to the shell.
8636 * The return string is allocated on the stack.
8640 single_quote(const char *s) {
8647 size_t len1, len1p, len2, len2p;
8649 len1 = strcspn(s, "'");
8650 len2 = strspn(s + len1, "'");
8652 len1p = len1 ? len1 + 2 : len1;
8653 len2p = len2 + ((len2 < 2) ? len2 : 2);
8655 CHECKSTRSPACE(len1p + len2p + 1, p);
8660 memcpy(p + 1, s, len1);
8668 memcpy(q + 1, s, len2);
8671 } else if (len2 == 1) {
8677 STADJUST(len1p + len2p, p);
8682 return grabstackstr(p);
8686 * Like strdup but works with the ash stack.
8690 sstrdup(const char *p)
8692 size_t len = strlen(p) + 1;
8693 return memcpy(stalloc(len), p, len);
8698 * Routine for dealing with parsed shell commands.
8702 static void sizenodelist (const struct nodelist *);
8703 static struct nodelist *copynodelist (const struct nodelist *);
8704 static char *nodesavestr (const char *);
8706 #define CALCSIZE_TABLE
8707 #define COPYNODE_TABLE
8708 #if defined(CALCSIZE_TABLE) || defined(COPYNODE_TABLE)
8710 * To collect a lot of redundant code in case statements for copynode()
8711 * and calcsize(), we implement a mini language here. Each type of node
8712 * struct has an associated instruction sequence that operates on its
8713 * members via their offsets. The instruction are pack in unsigned chars
8714 * with format IIDDDDDE where the bits are
8715 * I : part of the instruction opcode, which are
8716 * 00 : member is a pointer to another node
8717 * 40 : member is an integer
8718 * 80 : member is a pointer to a nodelist
8719 * CC : member is a pointer to a char string
8720 * D : data - the actual offset of the member to operate on in the struct
8721 * (since we assume bit 0 is set, it is not shifted)
8722 * E : flag signaling end of instruction sequence
8724 * WARNING: In order to handle larger offsets for 64bit archs, this code
8725 * assumes that no offset can be an odd number and stores the
8726 * end-of-instructions flag in bit 0.
8729 #define NODE_INTEGER 0x40
8730 #define NODE_NODELIST 0x80
8731 #define NODE_CHARPTR 0xC0
8732 #define NODE_NOMORE 0x01 /* Note: no offset should be odd (aligned)*/
8733 #define NODE_MBRMASK 0xC0
8734 #define NODE_OFFSETMASK 0x3E
8736 static const unsigned char copynode_ops[35] = {
8737 #define COPYNODE_OPS0 0
8738 offsetof(union node, nbinary.ch2),
8739 offsetof(union node, nbinary.ch1)|NODE_NOMORE,
8740 #define COPYNODE_OPS1 (COPYNODE_OPS0 + 2)
8741 offsetof(union node, ncmd.redirect),
8742 offsetof(union node, ncmd.args),
8743 offsetof(union node, ncmd.assign),
8744 offsetof(union node, ncmd.backgnd)|NODE_INTEGER|NODE_NOMORE,
8745 #define COPYNODE_OPS2 (COPYNODE_OPS1 + 4)
8746 offsetof(union node, npipe.cmdlist)|NODE_NODELIST,
8747 offsetof(union node, npipe.backgnd)|NODE_INTEGER|NODE_NOMORE,
8748 #define COPYNODE_OPS3 (COPYNODE_OPS2 + 2)
8749 offsetof(union node, nredir.redirect),
8750 offsetof(union node, nredir.n)|NODE_NOMORE,
8751 #define COPYNODE_OPS4 (COPYNODE_OPS3 + 2)
8752 offsetof(union node, nif.elsepart),
8753 offsetof(union node, nif.ifpart),
8754 offsetof(union node, nif.test)|NODE_NOMORE,
8755 #define COPYNODE_OPS5 (COPYNODE_OPS4 + 3)
8756 offsetof(union node, nfor.var)|NODE_CHARPTR,
8757 offsetof(union node, nfor.body),
8758 offsetof(union node, nfor.args)|NODE_NOMORE,
8759 #define COPYNODE_OPS6 (COPYNODE_OPS5 + 3)
8760 offsetof(union node, ncase.cases),
8761 offsetof(union node, ncase.expr)|NODE_NOMORE,
8762 #define COPYNODE_OPS7 (COPYNODE_OPS6 + 2)
8763 offsetof(union node, nclist.body),
8764 offsetof(union node, nclist.pattern),
8765 offsetof(union node, nclist.next)|NODE_NOMORE,
8766 #define COPYNODE_OPS8 (COPYNODE_OPS7 + 3)
8767 offsetof(union node, narg.backquote)|NODE_NODELIST,
8768 offsetof(union node, narg.text)|NODE_CHARPTR,
8769 offsetof(union node, narg.next)|NODE_NOMORE,
8770 #define COPYNODE_OPS9 (COPYNODE_OPS8 + 3)
8771 offsetof(union node, nfile.fname),
8772 offsetof(union node, nfile.fd)|NODE_INTEGER,
8773 offsetof(union node, nfile.next)|NODE_NOMORE,
8774 #define COPYNODE_OPS10 (COPYNODE_OPS9 + 3)
8775 offsetof(union node, ndup.vname),
8776 offsetof(union node, ndup.dupfd)|NODE_INTEGER,
8777 offsetof(union node, ndup.fd)|NODE_INTEGER,
8778 offsetof(union node, ndup.next)|NODE_NOMORE,
8779 #define COPYNODE_OPS11 (COPYNODE_OPS10 + 4)
8780 offsetof(union node, nhere.doc),
8781 offsetof(union node, nhere.fd)|NODE_INTEGER,
8782 offsetof(union node, nhere.next)|NODE_NOMORE,
8783 #define COPYNODE_OPS12 (COPYNODE_OPS11 + 3)
8784 offsetof(union node, nnot.com)|NODE_NOMORE,
8787 #if COPYNODE_OPS12 != 34
8788 #error COPYNODE_OPS12 is incorrect
8791 static const unsigned char copynode_ops_index[26] = {
8792 COPYNODE_OPS0, /* NSEMI */
8793 COPYNODE_OPS1, /* NCMD */
8794 COPYNODE_OPS2, /* NPIPE */
8795 COPYNODE_OPS3, /* NREDIR */
8796 COPYNODE_OPS3, /* NBACKGND */
8797 COPYNODE_OPS3, /* NSUBSHELL */
8798 COPYNODE_OPS0, /* NAND */
8799 COPYNODE_OPS0, /* NOR */
8800 COPYNODE_OPS4, /* NIF */
8801 COPYNODE_OPS0, /* NWHILE */
8802 COPYNODE_OPS0, /* NUNTIL */
8803 COPYNODE_OPS5, /* NFOR */
8804 COPYNODE_OPS6, /* NCASE */
8805 COPYNODE_OPS7, /* NCLIST */
8806 COPYNODE_OPS8, /* NDEFUN */
8807 COPYNODE_OPS8, /* NARG */
8808 COPYNODE_OPS9, /* NTO */
8809 COPYNODE_OPS9, /* NFROM */
8810 COPYNODE_OPS9, /* NFROMTO */
8811 COPYNODE_OPS9, /* NAPPEND */
8812 COPYNODE_OPS9, /* NTOOV */
8813 COPYNODE_OPS10, /* NTOFD */
8814 COPYNODE_OPS10, /* NFROMFD */
8815 COPYNODE_OPS11, /* NHERE */
8816 COPYNODE_OPS11, /* NXHERE */
8817 COPYNODE_OPS12, /* NNOT */
8820 #if NODE_CHARPTR != NODE_MBRMASK
8821 #error NODE_CHARPTR != NODE_MBRMASK!!!
8823 #endif /* defined(CALCSIZE_TABLE) || defined(COPYNODE_TABLE) */
8825 #ifdef COPYNODE_TABLE
8827 copynode(const union node *n)
8830 const unsigned char *p;
8836 new->type = n->type;
8837 funcblock = (char *) funcblock + (int) nodesize[n->type];
8838 p = copynode_ops + (int) copynode_ops_index[n->type];
8840 char *nn = ((char *) new) + ((int)(*p & NODE_OFFSETMASK));
8841 const char *no = ((const char *) n) + ((int)(*p & NODE_OFFSETMASK));
8843 if (!(*p & NODE_MBRMASK)) { /* standard node */
8844 *((union node **)nn) = copynode(*((const union node **) no));
8845 } else if ((*p & NODE_MBRMASK) == NODE_CHARPTR) { /* string */
8846 *((const char **)nn) = nodesavestr(*((const char **)no));
8847 } else if (*p & NODE_NODELIST) { /* nodelist */
8848 *((struct nodelist **)nn)
8849 = copynodelist(*((const struct nodelist **) no));
8850 } else { /* integer */
8851 *((int *) nn) = *((int *) no);
8853 } while (!(*p++ & NODE_NOMORE));
8856 #else /* COPYNODE_TABLE */
8858 copynode(const union node *n)
8865 funcblock = (char *) funcblock + nodesize[n->type];
8872 new->nbinary.ch2 = copynode(n->nbinary.ch2);
8873 new->nbinary.ch1 = copynode(n->nbinary.ch1);
8876 new->ncmd.redirect = copynode(n->ncmd.redirect);
8877 new->ncmd.args = copynode(n->ncmd.args);
8878 new->ncmd.assign = copynode(n->ncmd.assign);
8879 new->ncmd.backgnd = n->ncmd.backgnd;
8882 new->npipe.cmdlist = copynodelist(n->npipe.cmdlist);
8883 new->npipe.backgnd = n->npipe.backgnd;
8888 new->nredir.redirect = copynode(n->nredir.redirect);
8889 new->nredir.n = copynode(n->nredir.n);
8892 new->nif.elsepart = copynode(n->nif.elsepart);
8893 new->nif.ifpart = copynode(n->nif.ifpart);
8894 new->nif.test = copynode(n->nif.test);
8897 new->nfor.var = nodesavestr(n->nfor.var);
8898 new->nfor.body = copynode(n->nfor.body);
8899 new->nfor.args = copynode(n->nfor.args);
8902 new->ncase.cases = copynode(n->ncase.cases);
8903 new->ncase.expr = copynode(n->ncase.expr);
8906 new->nclist.body = copynode(n->nclist.body);
8907 new->nclist.pattern = copynode(n->nclist.pattern);
8908 new->nclist.next = copynode(n->nclist.next);
8912 new->narg.backquote = copynodelist(n->narg.backquote);
8913 new->narg.text = nodesavestr(n->narg.text);
8914 new->narg.next = copynode(n->narg.next);
8921 new->nfile.fname = copynode(n->nfile.fname);
8922 new->nfile.fd = n->nfile.fd;
8923 new->nfile.next = copynode(n->nfile.next);
8927 new->ndup.vname = copynode(n->ndup.vname);
8928 new->ndup.dupfd = n->ndup.dupfd;
8929 new->ndup.fd = n->ndup.fd;
8930 new->ndup.next = copynode(n->ndup.next);
8934 new->nhere.doc = copynode(n->nhere.doc);
8935 new->nhere.fd = n->nhere.fd;
8936 new->nhere.next = copynode(n->nhere.next);
8939 new->nnot.com = copynode(n->nnot.com);
8942 new->type = n->type;
8945 #endif /* COPYNODE_TABLE */
8947 #ifdef CALCSIZE_TABLE
8949 calcsize(const union node *n)
8951 const unsigned char *p;
8955 funcblocksize += (int) nodesize[n->type];
8957 p = copynode_ops + (int) copynode_ops_index[n->type];
8959 const char *no = ((const char *) n) + ((int)(*p & NODE_OFFSETMASK));
8961 if (!(*p & NODE_MBRMASK)) { /* standard node */
8962 calcsize(*((const union node **) no));
8963 } else if ((*p & NODE_MBRMASK) == NODE_CHARPTR) { /* string */
8964 funcstringsize += strlen(*((const char **)no)) + 1;
8965 } else if (*p & NODE_NODELIST) { /* nodelist */
8966 sizenodelist(*((const struct nodelist **) no));
8967 } /* else integer -- ignore */
8968 } while (!(*p++ & NODE_NOMORE));
8970 #else /* CALCSIZE_TABLE */
8972 calcsize(const union node *n)
8976 funcblocksize += nodesize[n->type];
8983 calcsize(n->nbinary.ch2);
8984 calcsize(n->nbinary.ch1);
8987 calcsize(n->ncmd.redirect);
8988 calcsize(n->ncmd.args);
8989 calcsize(n->ncmd.assign);
8992 sizenodelist(n->npipe.cmdlist);
8997 calcsize(n->nredir.redirect);
8998 calcsize(n->nredir.n);
9001 calcsize(n->nif.elsepart);
9002 calcsize(n->nif.ifpart);
9003 calcsize(n->nif.test);
9006 funcstringsize += strlen(n->nfor.var) + 1;
9007 calcsize(n->nfor.body);
9008 calcsize(n->nfor.args);
9011 calcsize(n->ncase.cases);
9012 calcsize(n->ncase.expr);
9015 calcsize(n->nclist.body);
9016 calcsize(n->nclist.pattern);
9017 calcsize(n->nclist.next);
9021 sizenodelist(n->narg.backquote);
9022 funcstringsize += strlen(n->narg.text) + 1;
9023 calcsize(n->narg.next);
9030 calcsize(n->nfile.fname);
9031 calcsize(n->nfile.next);
9035 calcsize(n->ndup.vname);
9036 calcsize(n->ndup.next);
9040 calcsize(n->nhere.doc);
9041 calcsize(n->nhere.next);
9044 calcsize(n->nnot.com);
9048 #endif /* CALCSIZE_TABLE */
9051 sizenodelist(const struct nodelist *lp)
9054 funcblocksize += ALIGN(sizeof(struct nodelist));
9061 static struct nodelist *
9062 copynodelist(const struct nodelist *lp)
9064 struct nodelist *start;
9065 struct nodelist **lpp;
9070 funcblock = (char *) funcblock + ALIGN(sizeof(struct nodelist));
9071 (*lpp)->n = copynode(lp->n);
9073 lpp = &(*lpp)->next;
9081 nodesavestr(const char *s)
9084 char *q = funcstring;
9085 char *rtn = funcstring;
9087 while ((*q++ = *p++) != '\0')
9094 static int getopts (char *, char *, char **, int *, int *);
9099 * Process the shell command line arguments.
9103 procargs(argc, argv)
9112 for (i = 0; i < NOPTS; i++)
9115 if (*argptr == NULL && minusc == NULL)
9117 if (iflag == 2 && sflag == 1 && isatty(0) && isatty(1))
9121 for (i = 0; i < NOPTS; i++)
9122 if (optent_val(i) == 2)
9125 if (sflag == 0 && minusc == NULL) {
9126 commandname = argv[0];
9128 setinputfile(arg0, 0);
9131 /* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
9132 if (argptr && minusc && *argptr)
9135 shellparam.p = argptr;
9136 shellparam.optind = 1;
9137 shellparam.optoff = -1;
9138 /* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
9140 shellparam.nparam++;
9149 * Process shell options. The global variable argptr contains a pointer
9150 * to the argument list; we advance it past the options.
9154 minus_o(const char *name, int val)
9159 out1str("Current option settings\n");
9160 for (i = 0; i < NOPTS; i++)
9161 printf("%-16s%s\n", optent_name(optlist[i]),
9162 optent_val(i) ? "on" : "off");
9164 for (i = 0; i < NOPTS; i++)
9165 if (equal(name, optent_name(optlist[i]))) {
9166 setoption(optent_letter(optlist[i]), val);
9169 error("Illegal option -o %s", name);
9175 options(int cmdline)
9183 while ((p = *argptr) != NULL) {
9185 if ((c = *p++) == '-') {
9187 if (p[0] == '\0' || (p[0] == '-' && p[1] == '\0')) {
9189 /* "-" means turn off -x and -v */
9192 /* "--" means reset params */
9193 else if (*argptr == NULL)
9196 break; /* "-" or "--" terminates options */
9198 } else if (c == '+') {
9204 while ((c = *p++) != '\0') {
9205 if (c == 'c' && cmdline) {
9207 #ifdef NOHACK /* removing this code allows sh -ce 'foo' for compat */
9211 if (q == NULL || minusc != NULL)
9212 error("Bad -c option");
9217 } else if (c == 'o') {
9218 minus_o(*argptr, val);
9230 setoption(int flag, int val)
9234 for (i = 0; i < NOPTS; i++)
9235 if (optent_letter(optlist[i]) == flag) {
9236 optent_val(i) = val;
9238 /* #%$ hack for ksh semantics */
9241 else if (flag == 'E')
9246 error("Illegal option -%c", flag);
9253 * Set the shell parameters.
9257 setparam(char **argv)
9263 for (nparam = 0 ; argv[nparam] ; nparam++);
9264 ap = newparam = ckmalloc((nparam + 1) * sizeof *ap);
9266 *ap++ = savestr(*argv++);
9269 freeparam(&shellparam);
9270 shellparam.malloc = 1;
9271 shellparam.nparam = nparam;
9272 shellparam.p = newparam;
9273 shellparam.optind = 1;
9274 shellparam.optoff = -1;
9279 * Free the list of positional parameters.
9283 freeparam(volatile struct shparam *param)
9287 if (param->malloc) {
9288 for (ap = param->p ; *ap ; ap++)
9297 * The shift builtin command.
9301 shiftcmd(argc, argv)
9310 n = number(argv[1]);
9311 if (n > shellparam.nparam)
9312 error("can't shift that many");
9314 shellparam.nparam -= n;
9315 for (ap1 = shellparam.p ; --n >= 0 ; ap1++) {
9316 if (shellparam.malloc)
9320 while ((*ap2++ = *ap1++) != NULL);
9321 shellparam.optind = 1;
9322 shellparam.optoff = -1;
9330 * The set command builtin.
9339 return showvarscmd(argc, argv);
9343 if (*argptr != NULL) {
9352 getoptsreset(const char *value)
9354 shellparam.optind = number(value);
9355 shellparam.optoff = -1;
9358 #ifdef BB_LOCALE_SUPPORT
9359 static void change_lc_all(const char *value)
9361 if(value != 0 && *value != 0)
9362 setlocale(LC_ALL, value);
9365 static void change_lc_ctype(const char *value)
9367 if(value != 0 && *value != 0)
9368 setlocale(LC_CTYPE, value);
9375 * The getopts builtin. Shellparam.optnext points to the next argument
9376 * to be processed. Shellparam.optptr points to the next character to
9377 * be processed in the current argument. If shellparam.optnext is NULL,
9378 * then it's the first time getopts has been called.
9382 getoptscmd(argc, argv)
9389 error("Usage: getopts optstring var [arg]");
9390 else if (argc == 3) {
9391 optbase = shellparam.p;
9392 if (shellparam.optind > shellparam.nparam + 1) {
9393 shellparam.optind = 1;
9394 shellparam.optoff = -1;
9399 if (shellparam.optind > argc - 2) {
9400 shellparam.optind = 1;
9401 shellparam.optoff = -1;
9405 return getopts(argv[1], argv[2], optbase, &shellparam.optind,
9406 &shellparam.optoff);
9410 * Safe version of setvar, returns 1 on success 0 on failure.
9414 setvarsafe(name, val, flags)
9415 const char *name, *val;
9418 struct jmploc jmploc;
9419 struct jmploc *volatile savehandler = handler;
9425 if (setjmp(jmploc.loc))
9429 setvar(name, val, flags);
9431 handler = savehandler;
9436 getopts(optstr, optvar, optfirst, myoptind, optoff)
9448 char **optnext = optfirst + *myoptind - 1;
9450 if (*myoptind <= 1 || *optoff < 0 || !(*(optnext - 1)) ||
9451 strlen(*(optnext - 1)) < *optoff)
9454 p = *(optnext - 1) + *optoff;
9455 if (p == NULL || *p == '\0') {
9456 /* Current word is done, advance */
9457 if (optnext == NULL)
9460 if (p == NULL || *p != '-' || *++p == '\0') {
9462 *myoptind = optnext - optfirst + 1;
9468 if (p[0] == '-' && p[1] == '\0') /* check for "--" */
9473 for (q = optstr; *q != c; ) {
9475 if (optstr[0] == ':') {
9478 err |= setvarsafe("OPTARG", s, 0);
9481 out2fmt("Illegal option -%c\n", c);
9482 (void) unsetvar("OPTARG");
9492 if (*p == '\0' && (p = *optnext) == NULL) {
9493 if (optstr[0] == ':') {
9496 err |= setvarsafe("OPTARG", s, 0);
9500 out2fmt("No arg for -%c option\n", c);
9501 (void) unsetvar("OPTARG");
9509 setvarsafe("OPTARG", p, 0);
9513 setvarsafe("OPTARG", "", 0);
9514 *myoptind = optnext - optfirst + 1;
9521 *optoff = p ? p - *(optnext - 1) : -1;
9522 snprintf(s, sizeof(s), "%d", *myoptind);
9523 err |= setvarsafe("OPTIND", s, VNOFUNC);
9526 err |= setvarsafe(optvar, s, 0);
9537 * XXX - should get rid of. have all builtins use getopt(3). the
9538 * library getopt must have the BSD extension static variable "optreset"
9539 * otherwise it can't be used within the shell safely.
9541 * Standard option processing (a la getopt) for builtin routines. The
9542 * only argument that is passed to nextopt is the option string; the
9543 * other arguments are unnecessary. It return the character, or '\0' on
9548 nextopt(const char *optstring)
9554 if ((p = optptr) == NULL || *p == '\0') {
9556 if (p == NULL || *p != '-' || *++p == '\0')
9559 if (p[0] == '-' && p[1] == '\0') /* check for "--" */
9563 for (q = optstring ; *q != c ; ) {
9565 error("Illegal option -%c", c);
9570 if (*p == '\0' && (p = *argptr++) == NULL)
9571 error("No arg for -%c option", c);
9588 out2fmt(const char *fmt, ...)
9592 vfprintf(stderr, fmt, ap);
9597 * Version of write which resumes after a signal is caught.
9601 xwrite(int fd, const char *buf, int nbytes)
9610 i = write(fd, buf, n);
9616 } else if (i == 0) {
9619 } else if (errno != EINTR) {
9627 * Shell command parser.
9630 #define EOFMARKLEN 79
9635 struct heredoc *next; /* next here document in list */
9636 union node *here; /* redirection node */
9637 char *eofmark; /* string indicating end of input */
9638 int striptabs; /* if set, strip leading tabs */
9641 static struct heredoc *heredoclist; /* list of here documents to read */
9642 static int parsebackquote; /* nonzero if we are inside backquotes */
9643 static int doprompt; /* if set, prompt the user */
9644 static int needprompt; /* true if interactive and at start of line */
9645 static int lasttoken; /* last token read */
9647 static char *wordtext; /* text of last word returned by readtoken */
9649 static struct nodelist *backquotelist;
9650 static union node *redirnode;
9651 static struct heredoc *heredoc;
9652 static int quoteflag; /* set if (part of) last token was quoted */
9653 static int startlinno; /* line # where last token started */
9656 static union node *list (int);
9657 static union node *andor (void);
9658 static union node *pipeline (void);
9659 static union node *command (void);
9660 static union node *simplecmd (void);
9661 static void parsefname (void);
9662 static void parseheredoc (void);
9663 static char peektoken (void);
9664 static int readtoken (void);
9665 static int xxreadtoken (void);
9666 static int readtoken1 (int, int, const char *, int);
9667 static int noexpand (char *);
9668 static void synexpect (int) __attribute__((noreturn));
9669 static void synerror (const char *) __attribute__((noreturn));
9670 static void setprompt (int);
9674 * Read and parse a command. Returns NEOF on end of file. (NULL is a
9675 * valid parse tree indicating a blank line.)
9679 parsecmd(int interact)
9684 doprompt = interact;
9704 union node *n1, *n2, *n3;
9708 if (nlflag == 0 && peektoken())
9714 if (tok == TBACKGND) {
9715 if (n2->type == NCMD || n2->type == NPIPE) {
9716 n2->ncmd.backgnd = 1;
9717 } else if (n2->type == NREDIR) {
9718 n2->type = NBACKGND;
9720 n3 = (union node *)stalloc(sizeof (struct nredir));
9721 n3->type = NBACKGND;
9723 n3->nredir.redirect = NULL;
9731 n3 = (union node *)stalloc(sizeof (struct nbinary));
9733 n3->nbinary.ch1 = n1;
9734 n3->nbinary.ch2 = n2;
9758 pungetc(); /* push back EOF on input */
9773 union node *n1, *n2, *n3;
9779 if ((t = readtoken()) == TAND) {
9781 } else if (t == TOR) {
9789 n3 = (union node *)stalloc(sizeof (struct nbinary));
9791 n3->nbinary.ch1 = n1;
9792 n3->nbinary.ch2 = n2;
9801 union node *n1, *n2, *pipenode;
9802 struct nodelist *lp, *prev;
9806 TRACE(("pipeline: entered\n"));
9807 if (readtoken() == TNOT) {
9813 if (readtoken() == TPIPE) {
9814 pipenode = (union node *)stalloc(sizeof (struct npipe));
9815 pipenode->type = NPIPE;
9816 pipenode->npipe.backgnd = 0;
9817 lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
9818 pipenode->npipe.cmdlist = lp;
9822 lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
9826 } while (readtoken() == TPIPE);
9832 n2 = (union node *)stalloc(sizeof (struct nnot));
9844 union node *n1, *n2;
9845 union node *ap, **app;
9846 union node *cp, **cpp;
9847 union node *redir, **rpp;
9854 /* Check for redirection which may precede command */
9855 while (readtoken() == TREDIR) {
9856 *rpp = n2 = redirnode;
9857 rpp = &n2->nfile.next;
9862 switch (readtoken()) {
9864 n1 = (union node *)stalloc(sizeof (struct nif));
9866 n1->nif.test = list(0);
9867 if (readtoken() != TTHEN)
9869 n1->nif.ifpart = list(0);
9871 while (readtoken() == TELIF) {
9872 n2->nif.elsepart = (union node *)stalloc(sizeof (struct nif));
9873 n2 = n2->nif.elsepart;
9875 n2->nif.test = list(0);
9876 if (readtoken() != TTHEN)
9878 n2->nif.ifpart = list(0);
9880 if (lasttoken == TELSE)
9881 n2->nif.elsepart = list(0);
9883 n2->nif.elsepart = NULL;
9886 if (readtoken() != TFI)
9893 n1 = (union node *)stalloc(sizeof (struct nbinary));
9894 n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL;
9895 n1->nbinary.ch1 = list(0);
9896 if ((got=readtoken()) != TDO) {
9897 TRACE(("expecting DO got %s %s\n", tokname(got), got == TWORD ? wordtext : ""));
9900 n1->nbinary.ch2 = list(0);
9901 if (readtoken() != TDONE)
9907 if (readtoken() != TWORD || quoteflag || ! goodname(wordtext))
9908 synerror("Bad for loop variable");
9909 n1 = (union node *)stalloc(sizeof (struct nfor));
9911 n1->nfor.var = wordtext;
9913 if (readtoken() == TIN) {
9915 while (readtoken() == TWORD) {
9916 n2 = (union node *)stalloc(sizeof (struct narg));
9918 n2->narg.text = wordtext;
9919 n2->narg.backquote = backquotelist;
9921 app = &n2->narg.next;
9925 if (lasttoken != TNL && lasttoken != TSEMI)
9928 static char argvars[5] = {CTLVAR, VSNORMAL|VSQUOTE,
9930 n2 = (union node *)stalloc(sizeof (struct narg));
9932 n2->narg.text = argvars;
9933 n2->narg.backquote = NULL;
9934 n2->narg.next = NULL;
9937 * Newline or semicolon here is optional (but note
9938 * that the original Bourne shell only allowed NL).
9940 if (lasttoken != TNL && lasttoken != TSEMI)
9944 if (readtoken() != TDO)
9946 n1->nfor.body = list(0);
9947 if (readtoken() != TDONE)
9952 n1 = (union node *)stalloc(sizeof (struct ncase));
9954 if (readtoken() != TWORD)
9956 n1->ncase.expr = n2 = (union node *)stalloc(sizeof (struct narg));
9958 n2->narg.text = wordtext;
9959 n2->narg.backquote = backquotelist;
9960 n2->narg.next = NULL;
9963 } while (readtoken() == TNL);
9964 if (lasttoken != TIN)
9965 synerror("expecting \"in\"");
9966 cpp = &n1->ncase.cases;
9967 checkkwd = 2, readtoken();
9969 if (lasttoken == TLP)
9971 *cpp = cp = (union node *)stalloc(sizeof (struct nclist));
9973 app = &cp->nclist.pattern;
9975 *app = ap = (union node *)stalloc(sizeof (struct narg));
9977 ap->narg.text = wordtext;
9978 ap->narg.backquote = backquotelist;
9979 if (checkkwd = 2, readtoken() != TPIPE)
9981 app = &ap->narg.next;
9984 ap->narg.next = NULL;
9985 if (lasttoken != TRP)
9987 cp->nclist.body = list(0);
9990 if ((t = readtoken()) != TESAC) {
9992 synexpect(TENDCASE);
9994 checkkwd = 2, readtoken();
9996 cpp = &cp->nclist.next;
9997 } while(lasttoken != TESAC);
10002 n1 = (union node *)stalloc(sizeof (struct nredir));
10003 n1->type = NSUBSHELL;
10004 n1->nredir.n = list(0);
10005 n1->nredir.redirect = NULL;
10006 if (readtoken() != TRP)
10012 if (readtoken() != TEND)
10016 /* Handle an empty command like other simple commands. */
10025 * An empty command before a ; doesn't make much sense, and
10026 * should certainly be disallowed in the case of `if ;'.
10039 /* Now check for redirection which may follow command */
10040 while (readtoken() == TREDIR) {
10041 *rpp = n2 = redirnode;
10042 rpp = &n2->nfile.next;
10048 if (n1->type != NSUBSHELL) {
10049 n2 = (union node *)stalloc(sizeof (struct nredir));
10054 n1->nredir.redirect = redir;
10061 static union node *
10063 union node *args, **app;
10064 union node *n = NULL;
10065 union node *vars, **vpp;
10066 union node **rpp, *redir;
10077 switch (readtoken()) {
10080 n = (union node *)stalloc(sizeof (struct narg));
10082 n->narg.text = wordtext;
10083 n->narg.backquote = backquotelist;
10084 if (lasttoken == TWORD) {
10086 app = &n->narg.next;
10089 vpp = &n->narg.next;
10093 *rpp = n = redirnode;
10094 rpp = &n->nfile.next;
10095 parsefname(); /* read name of redirection file */
10099 args && app == &args->narg.next &&
10102 /* We have a function */
10103 if (readtoken() != TRP)
10107 n->narg.next = command();
10120 n = (union node *)stalloc(sizeof (struct ncmd));
10122 n->ncmd.backgnd = 0;
10123 n->ncmd.args = args;
10124 n->ncmd.assign = vars;
10125 n->ncmd.redirect = redir;
10129 static union node *
10133 n = (union node *)stalloc(sizeof (struct narg));
10135 n->narg.next = NULL;
10136 n->narg.text = wordtext;
10137 n->narg.backquote = backquotelist;
10141 static void fixredir(union node *n, const char *text, int err)
10143 TRACE(("Fix redir %s %d\n", text, err));
10145 n->ndup.vname = NULL;
10147 if (is_digit(text[0]) && text[1] == '\0')
10148 n->ndup.dupfd = digit_val(text[0]);
10149 else if (text[0] == '-' && text[1] == '\0')
10150 n->ndup.dupfd = -1;
10154 synerror("Bad fd number");
10156 n->ndup.vname = makename();
10163 union node *n = redirnode;
10165 if (readtoken() != TWORD)
10167 if (n->type == NHERE) {
10168 struct heredoc *here = heredoc;
10172 if (quoteflag == 0)
10174 TRACE(("Here document %d\n", n->type));
10175 if (here->striptabs) {
10176 while (*wordtext == '\t')
10179 if (! noexpand(wordtext) || (i = strlen(wordtext)) == 0 || i > EOFMARKLEN)
10180 synerror("Illegal eof marker for << redirection");
10181 rmescapes(wordtext);
10182 here->eofmark = wordtext;
10184 if (heredoclist == NULL)
10185 heredoclist = here;
10187 for (p = heredoclist ; p->next ; p = p->next);
10190 } else if (n->type == NTOFD || n->type == NFROMFD) {
10191 fixredir(n, wordtext, 0);
10193 n->nfile.fname = makename();
10199 * Input any here documents.
10204 struct heredoc *here;
10207 while (heredoclist) {
10208 here = heredoclist;
10209 heredoclist = here->next;
10214 readtoken1(pgetc(), here->here->type == NHERE? SQSYNTAX : DQSYNTAX,
10215 here->eofmark, here->striptabs);
10216 n = (union node *)stalloc(sizeof (struct narg));
10217 n->narg.type = NARG;
10218 n->narg.next = NULL;
10219 n->narg.text = wordtext;
10220 n->narg.backquote = backquotelist;
10221 here->here->nhere.doc = n;
10231 return tokname_array[t][0];
10239 int savecheckalias = checkalias;
10240 int savecheckkwd = checkkwd;
10245 int alreadyseen = tokpushback;
10255 checkalias = savecheckalias;
10262 if (checkkwd == 2) {
10271 * check for keywords
10273 if (t == TWORD && !quoteflag)
10275 const char *const *pp;
10277 if ((pp = findkwd(wordtext))) {
10278 lasttoken = t = pp - tokname_array;
10279 TRACE(("keyword %s recognized\n", tokname(t)));
10290 } else if (checkalias == 2 && isassignment(wordtext)) {
10291 lasttoken = t = TASSIGN;
10293 } else if (checkalias) {
10294 if (!quoteflag && (ap = lookupalias(wordtext, 1)) != NULL) {
10296 pushstring(ap->val, strlen(ap->val), ap);
10298 checkkwd = savecheckkwd;
10307 TRACE(("token %s %s\n", tokname(t), t == TWORD || t == TASSIGN ? wordtext : ""));
10309 TRACE(("reread token %s %s\n", tokname(t), t == TWORD || t == TASSIGN ? wordtext : ""));
10316 * Read the next input token.
10317 * If the token is a word, we set backquotelist to the list of cmds in
10318 * backquotes. We set quoteflag to true if any part of the word was
10320 * If the token is TREDIR, then we set redirnode to a structure containing
10322 * In all cases, the variable startlinno is set to the number of the line
10323 * on which the token starts.
10325 * [Change comment: here documents and internal procedures]
10326 * [Readtoken shouldn't have any arguments. Perhaps we should make the
10327 * word parsing code into a separate routine. In this case, readtoken
10328 * doesn't need to have any internal procedures, but parseword does.
10329 * We could also make parseoperator in essence the main routine, and
10330 * have parseword (readtoken1?) handle both words and redirection.]
10333 #define NEW_xxreadtoken
10334 #ifdef NEW_xxreadtoken
10336 static const char xxreadtoken_chars[] = "\n()&|;"; /* singles must be first! */
10337 static const char xxreadtoken_tokens[] = {
10338 TNL, TLP, TRP, /* only single occurrence allowed */
10339 TBACKGND, TPIPE, TSEMI, /* if single occurrence */
10340 TEOF, /* corresponds to trailing nul */
10341 TAND, TOR, TENDCASE, /* if double occurrence */
10344 #define xxreadtoken_doubles \
10345 (sizeof(xxreadtoken_tokens) - sizeof(xxreadtoken_chars))
10346 #define xxreadtoken_singles \
10347 (sizeof(xxreadtoken_chars) - xxreadtoken_doubles - 1)
10361 startlinno = plinno;
10362 for (;;) { /* until token or start of word found */
10365 if ((c!=' ') && (c!='\t')
10371 while ((c = pgetc()) != '\n' && c != PEOF);
10373 } else if (c=='\\') {
10374 if (pgetc() != '\n') {
10378 startlinno = ++plinno;
10379 setprompt(doprompt ? 2 : 0);
10382 = xxreadtoken_chars + sizeof(xxreadtoken_chars) - 1;
10387 needprompt = doprompt;
10390 p = strchr(xxreadtoken_chars, c);
10393 return readtoken1(c, BASESYNTAX, (char *)NULL, 0);
10396 if (p-xxreadtoken_chars >= xxreadtoken_singles) {
10397 if (pgetc() == *p) { /* double occurrence? */
10398 p += xxreadtoken_doubles + 1;
10405 return lasttoken = xxreadtoken_tokens[p-xxreadtoken_chars];
10413 #define RETURN(token) return lasttoken = token
10427 startlinno = plinno;
10428 for (;;) { /* until token or start of word found */
10431 case ' ': case '\t':
10437 while ((c = pgetc()) != '\n' && c != PEOF);
10441 if (pgetc() == '\n') {
10442 startlinno = ++plinno;
10453 needprompt = doprompt;
10458 if (pgetc() == '&')
10463 if (pgetc() == '|')
10468 if (pgetc() == ';')
10481 return readtoken1(c, BASESYNTAX, (char *)NULL, 0);
10488 * If eofmark is NULL, read a word or a redirection symbol. If eofmark
10489 * is not NULL, read a here document. In the latter case, eofmark is the
10490 * word which marks the end of the document and striptabs is true if
10491 * leading tabs should be stripped from the document. The argument firstc
10492 * is the first character of the input token or document.
10494 * Because C does not have internal subroutines, I have simulated them
10495 * using goto's to implement the subroutine linkage. The following macros
10496 * will run code that appears at the end of readtoken1.
10499 #define CHECKEND() {goto checkend; checkend_return:;}
10500 #define PARSEREDIR() {goto parseredir; parseredir_return:;}
10501 #define PARSESUB() {goto parsesub; parsesub_return:;}
10502 #define PARSEBACKQOLD() {oldstyle = 1; goto parsebackq; parsebackq_oldreturn:;}
10503 #define PARSEBACKQNEW() {oldstyle = 0; goto parsebackq; parsebackq_newreturn:;}
10504 #define PARSEARITH() {goto parsearith; parsearith_return:;}
10507 readtoken1(int firstc, int syntax, const char *eofmark, int striptabs)
10512 char line[EOFMARKLEN + 1];
10513 struct nodelist *bqlist;
10516 int varnest; /* levels of variables expansion */
10517 int arinest; /* levels of arithmetic expansion */
10518 int parenlevel; /* levels of parens in arithmetic */
10519 int dqvarnest; /* levels of variables expansion within double quotes */
10521 int prevsyntax; /* syntax before arithmetic */
10523 /* Avoid longjmp clobbering */
10529 (void) &parenlevel;
10532 (void) &prevsyntax;
10536 startlinno = plinno;
10538 if (syntax == DQSYNTAX)
10547 STARTSTACKSTR(out);
10548 loop: { /* for each line, until end of word */
10549 CHECKEND(); /* set c to PEOF if at end of here document */
10550 for (;;) { /* until end of line or end of word */
10551 CHECKSTRSPACE(3, out); /* permit 3 calls to USTPUTC */
10552 switch(SIT(c,syntax)) {
10553 case CNL: /* '\n' */
10554 if (syntax == BASESYNTAX)
10555 goto endword; /* exit outer loop */
10563 goto loop; /* continue outer loop */
10568 if ((eofmark == NULL || dblquote) &&
10570 USTPUTC(CTLESC, out);
10573 case CBACK: /* backslash */
10576 USTPUTC('\\', out);
10578 } else if (c == '\n') {
10584 if (dblquote && c != '\\' && c != '`' && c != '$'
10585 && (c != '"' || eofmark != NULL))
10586 USTPUTC('\\', out);
10587 if (SIT(c,SQSYNTAX) == CCTL)
10588 USTPUTC(CTLESC, out);
10589 else if (eofmark == NULL)
10590 USTPUTC(CTLQUOTEMARK, out);
10596 if (eofmark == NULL)
10597 USTPUTC(CTLQUOTEMARK, out);
10601 if (eofmark == NULL)
10602 USTPUTC(CTLQUOTEMARK, out);
10607 if (eofmark != NULL && arinest == 0 &&
10612 syntax = ARISYNTAX;
10614 } else if (eofmark == NULL &&
10616 syntax = BASESYNTAX;
10622 case CVAR: /* '$' */
10623 PARSESUB(); /* parse substitution */
10625 case CENDVAR: /* '}' */
10628 if (dqvarnest > 0) {
10631 USTPUTC(CTLENDVAR, out);
10636 #ifdef ASH_MATH_SUPPORT
10637 case CLP: /* '(' in arithmetic */
10641 case CRP: /* ')' in arithmetic */
10642 if (parenlevel > 0) {
10646 if (pgetc() == ')') {
10647 if (--arinest == 0) {
10648 USTPUTC(CTLENDARI, out);
10649 syntax = prevsyntax;
10650 if (syntax == DQSYNTAX)
10658 * unbalanced parens
10659 * (don't 2nd guess - no error)
10667 case CBQUOTE: /* '`' */
10671 goto endword; /* exit outer loop */
10676 goto endword; /* exit outer loop */
10687 if (syntax == ARISYNTAX)
10688 synerror("Missing '))'");
10689 if (syntax != BASESYNTAX && ! parsebackquote && eofmark == NULL)
10690 synerror("Unterminated quoted string");
10691 if (varnest != 0) {
10692 startlinno = plinno;
10693 synerror("Missing '}'");
10695 USTPUTC('\0', out);
10696 len = out - stackblock();
10697 out = stackblock();
10698 if (eofmark == NULL) {
10699 if ((c == '>' || c == '<')
10702 && (*out == '\0' || is_digit(*out))) {
10704 return lasttoken = TREDIR;
10709 quoteflag = quotef;
10710 backquotelist = bqlist;
10711 grabstackblock(len);
10713 return lasttoken = TWORD;
10714 /* end of readtoken routine */
10719 * Check to see whether we are at the end of the here document. When this
10720 * is called, c is set to the first character of the next input line. If
10721 * we are at the end of the here document, this routine sets the c to PEOF.
10732 while (c == '\t') {
10736 if (c == *eofmark) {
10737 if (pfgets(line, sizeof line) != NULL) {
10741 for (q = eofmark + 1 ; *q && *p == *q ; p++, q++);
10742 if (*p == '\n' && *q == '\0') {
10745 needprompt = doprompt;
10747 pushstring(line, strlen(line), NULL);
10752 goto checkend_return;
10757 * Parse a redirection operator. The variable "out" points to a string
10758 * specifying the fd to be redirected. The variable "c" contains the
10759 * first character of the redirection operator.
10766 np = (union node *)stalloc(sizeof (struct nfile));
10771 np->type = NAPPEND;
10780 } else { /* c == '<' */
10782 switch (c = pgetc()) {
10784 if (sizeof (struct nfile) != sizeof (struct nhere)) {
10785 np = (union node *)stalloc(sizeof (struct nhere));
10789 heredoc = (struct heredoc *)stalloc(sizeof (struct heredoc));
10790 heredoc->here = np;
10791 if ((c = pgetc()) == '-') {
10792 heredoc->striptabs = 1;
10794 heredoc->striptabs = 0;
10800 np->type = NFROMFD;
10804 np->type = NFROMTO;
10814 np->nfile.fd = digit_val(fd);
10816 goto parseredir_return;
10821 * Parse a substitution. At this point, we have read the dollar sign
10822 * and nothing else.
10830 static const char types[] = "}-+?=";
10835 (c != '(' && c != '{' && !is_name(c) && !is_special(c))
10839 } else if (c == '(') { /* $(command) or $((arith)) */
10840 if (pgetc() == '(') {
10847 USTPUTC(CTLVAR, out);
10848 typeloc = out - stackblock();
10849 USTPUTC(VSNORMAL, out);
10850 subtype = VSNORMAL;
10854 if ((c = pgetc()) == '}')
10857 subtype = VSLENGTH;
10862 if (c > PEOA && is_name(c)) {
10866 } while (c > PEOA && is_in_name(c));
10867 } else if (is_digit(c)) {
10871 } while (is_digit(c));
10873 else if (is_special(c)) {
10878 badsub: synerror("Bad substitution");
10882 if (subtype == 0) {
10889 p = strchr(types, c);
10892 subtype = p - types + VSNORMAL;
10898 subtype = c == '#' ? VSTRIMLEFT :
10911 if (dblquote || arinest)
10913 *(stackblock() + typeloc) = subtype | flags;
10914 if (subtype != VSNORMAL) {
10921 goto parsesub_return;
10926 * Called to parse command substitutions. Newstyle is set if the command
10927 * is enclosed inside $(...); nlpp is a pointer to the head of the linked
10928 * list of commands (passed by reference), and savelen is the number of
10929 * characters on the top of the stack which must be preserved.
10933 struct nodelist **nlpp;
10936 char *volatile str;
10937 struct jmploc jmploc;
10938 struct jmploc *volatile savehandler;
10942 (void) &saveprompt;
10945 savepbq = parsebackquote;
10946 if (setjmp(jmploc.loc)) {
10949 parsebackquote = 0;
10950 handler = savehandler;
10951 longjmp(handler->loc, 1);
10955 savelen = out - stackblock();
10957 str = ckmalloc(savelen);
10958 memcpy(str, stackblock(), savelen);
10960 savehandler = handler;
10964 /* We must read until the closing backquote, giving special
10965 treatment to some slashes, and then push the string and
10966 reread it as input, interpreting it normally. */
10973 STARTSTACKSTR(pout);
10979 switch (pc = pgetc()) {
10984 if ((pc = pgetc()) == '\n') {
10991 * If eating a newline, avoid putting
10992 * the newline into the new character
10993 * stream (via the STPUTC after the
10998 if (pc != '\\' && pc != '`' && pc != '$'
10999 && (!dblquote || pc != '"'))
11000 STPUTC('\\', pout);
11010 startlinno = plinno;
11011 synerror("EOF in backquote substitution");
11015 needprompt = doprompt;
11024 STPUTC('\0', pout);
11025 psavelen = pout - stackblock();
11026 if (psavelen > 0) {
11027 pstr = grabstackstr(pout);
11028 setinputstring(pstr);
11033 nlpp = &(*nlpp)->next;
11034 *nlpp = (struct nodelist *)stalloc(sizeof (struct nodelist));
11035 (*nlpp)->next = NULL;
11036 parsebackquote = oldstyle;
11039 saveprompt = doprompt;
11046 doprompt = saveprompt;
11048 if (readtoken() != TRP)
11055 * Start reading from old file again, ignoring any pushed back
11056 * tokens left from the backquote parsing
11061 while (stackblocksize() <= savelen)
11063 STARTSTACKSTR(out);
11065 memcpy(out, str, savelen);
11066 STADJUST(savelen, out);
11072 parsebackquote = savepbq;
11073 handler = savehandler;
11074 if (arinest || dblquote)
11075 USTPUTC(CTLBACKQ | CTLQUOTE, out);
11077 USTPUTC(CTLBACKQ, out);
11079 goto parsebackq_oldreturn;
11081 goto parsebackq_newreturn;
11085 * Parse an arithmetic expansion (indicate start of one and set state)
11089 if (++arinest == 1) {
11090 prevsyntax = syntax;
11091 syntax = ARISYNTAX;
11092 USTPUTC(CTLARI, out);
11099 * we collapse embedded arithmetic expansion to
11100 * parenthesis, which should be equivalent
11104 goto parsearith_return;
11107 } /* end of readtoken */
11111 * Returns true if the text contains nothing to expand (no dollar signs
11123 while ((c = *p++) != '\0') {
11124 if (c == CTLQUOTEMARK)
11128 else if (SIT(c,BASESYNTAX) == CCTL)
11136 * Return true if the argument is a legal variable name (a letter or
11137 * underscore followed by zero or more letters, underscores, and digits).
11141 goodname(const char *name)
11149 if (! is_in_name(*p))
11157 * Called when an unexpected token is read during the parse. The argument
11158 * is the token that is expected, or -1 if more than one type of token can
11159 * occur at this point.
11169 l = sprintf(msg, "%s unexpected", tokname(lasttoken));
11171 sprintf(msg+l, " (expecting %s)", tokname(token));
11178 synerror(const char *msg)
11181 out2fmt("%s: %d: ", commandname, startlinno);
11182 out2fmt("Syntax error: %s\n", msg);
11183 error((char *)NULL);
11189 * called by editline -- any expansions to the prompt
11190 * should be added here.
11193 setprompt(int whichprompt)
11196 switch (whichprompt) {
11211 * Code for dealing with input/output redirection.
11214 #define EMPTY -2 /* marks an unused slot in redirtab */
11216 # define PIPESIZE 4096 /* amount of buffering in a pipe */
11218 # define PIPESIZE PIPE_BUF
11223 * Open a file in noclobber mode.
11224 * The code was copied from bash.
11227 noclobberopen(const char *fname)
11230 struct stat finfo, finfo2;
11233 * If the file exists and is a regular file, return an error
11236 r = stat(fname, &finfo);
11237 if (r == 0 && S_ISREG(finfo.st_mode)) {
11243 * If the file was not present (r != 0), make sure we open it
11244 * exclusively so that if it is created before we open it, our open
11245 * will fail. Make sure that we do not truncate an existing file.
11246 * Note that we don't turn on O_EXCL unless the stat failed -- if the
11247 * file was not a regular file, we leave O_EXCL off.
11250 return open(fname, O_WRONLY|O_CREAT|O_EXCL, 0666);
11251 fd = open(fname, O_WRONLY|O_CREAT, 0666);
11253 /* If the open failed, return the file descriptor right away. */
11258 * OK, the open succeeded, but the file may have been changed from a
11259 * non-regular file to a regular file between the stat and the open.
11260 * We are assuming that the O_EXCL open handles the case where FILENAME
11261 * did not exist and is symlinked to an existing file between the stat
11266 * If we can open it and fstat the file descriptor, and neither check
11267 * revealed that it was a regular file, and the file has not been
11268 * replaced, return the file descriptor.
11270 if (fstat(fd, &finfo2) == 0 && !S_ISREG(finfo2.st_mode) &&
11271 finfo.st_dev == finfo2.st_dev && finfo.st_ino == finfo2.st_ino)
11274 /* The file has been replaced. badness. */
11281 * Handle here documents. Normally we fork off a process to write the
11282 * data to a pipe. If the document is short, we can stuff the data in
11283 * the pipe without forking.
11287 openhere(const union node *redir)
11293 error("Pipe call failed");
11294 if (redir->type == NHERE) {
11295 len = strlen(redir->nhere.doc->narg.text);
11296 if (len <= PIPESIZE) {
11297 xwrite(pip[1], redir->nhere.doc->narg.text, len);
11301 if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) {
11303 signal(SIGINT, SIG_IGN);
11304 signal(SIGQUIT, SIG_IGN);
11305 signal(SIGHUP, SIG_IGN);
11307 signal(SIGTSTP, SIG_IGN);
11309 signal(SIGPIPE, SIG_DFL);
11310 if (redir->type == NHERE)
11311 xwrite(pip[1], redir->nhere.doc->narg.text, len);
11313 expandhere(redir->nhere.doc, pip[1]);
11323 openredirect(const union node *redir)
11328 switch (redir->nfile.type) {
11330 fname = redir->nfile.expfname;
11331 if ((f = open(fname, O_RDONLY)) < 0)
11335 fname = redir->nfile.expfname;
11336 if ((f = open(fname, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0)
11340 /* Take care of noclobber mode. */
11342 fname = redir->nfile.expfname;
11343 if ((f = noclobberopen(fname)) < 0)
11348 fname = redir->nfile.expfname;
11350 if ((f = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)
11353 if ((f = creat(fname, 0666)) < 0)
11358 fname = redir->nfile.expfname;
11360 if ((f = open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666)) < 0)
11363 if ((f = open(fname, O_WRONLY)) < 0
11364 && (f = creat(fname, 0666)) < 0)
11366 lseek(f, (off_t)0, 2);
11373 /* Fall through to eliminate warning. */
11380 f = openhere(redir);
11386 error("cannot create %s: %s", fname, errmsg(errno, E_CREAT));
11388 error("cannot open %s: %s", fname, errmsg(errno, E_OPEN));
11393 * Process a list of redirection commands. If the REDIR_PUSH flag is set,
11394 * old file descriptors are stashed away so that the redirection can be
11395 * undone by calling popredir. If the REDIR_BACKQ flag is set, then the
11396 * standard output, and the standard error if it becomes a duplicate of
11401 redirect(union node *redir, int flags)
11404 struct redirtab *sv = NULL;
11409 int fd1dup = flags & REDIR_BACKQ;; /* stdout `cmd` redir to pipe */
11411 if (flags & REDIR_PUSH) {
11412 sv = ckmalloc(sizeof (struct redirtab));
11413 for (i = 0 ; i < 10 ; i++)
11414 sv->renamed[i] = EMPTY;
11415 sv->next = redirlist;
11418 for (n = redir ; n ; n = n->nfile.next) {
11421 if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD) &&
11422 n->ndup.dupfd == fd)
11423 continue; /* redirect from/to same file descriptor */
11426 newfd = openredirect(n);
11427 if ((flags & REDIR_PUSH) && sv->renamed[fd] == EMPTY) {
11430 } else if ((i = fcntl(fd, F_DUPFD, 10)) == -1) {
11434 dupredirect(n, newfd, fd1dup);
11444 error("%d: %m", fd);
11450 if (flags & REDIR_PUSH) {
11451 sv->renamed[fd] = i;
11454 } else if (fd != newfd) {
11460 dupredirect(n, newfd, fd1dup);
11467 dupredirect(const union node *redir, int f, int fd1dup)
11469 int fd = redir->nfile.fd;
11473 if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) {
11474 if (redir->ndup.dupfd >= 0) { /* if not ">&-" */
11475 if (redir->ndup.dupfd!=1 || fd1dup!=1)
11476 dup_as_newfd(redir->ndup.dupfd, fd);
11482 dup_as_newfd(f, fd);
11491 * Undo the effects of the last redirection.
11497 struct redirtab *rp = redirlist;
11501 for (i = 0 ; i < 10 ; i++) {
11502 if (rp->renamed[i] != EMPTY) {
11506 if (rp->renamed[i] >= 0) {
11507 dup_as_newfd(rp->renamed[i], i);
11508 close(rp->renamed[i]);
11512 redirlist = rp->next;
11518 * Discard all saved file descriptors.
11523 struct redirtab *rp;
11526 for (rp = redirlist ; rp ; rp = rp->next) {
11527 for (i = 0 ; i < 10 ; i++) {
11528 if (rp->renamed[i] >= 0) {
11529 close(rp->renamed[i]);
11531 rp->renamed[i] = EMPTY;
11538 * Copy a file descriptor to be >= to. Returns -1
11539 * if the source file descriptor is closed, EMPTY if there are no unused
11540 * file descriptors left.
11544 dup_as_newfd(from, to)
11550 newfd = fcntl(from, F_DUPFD, to);
11552 if (errno == EMFILE)
11555 error("%d: %m", from);
11561 static void shtree (union node *, int, char *, FILE*);
11562 static void shcmd (union node *, FILE *);
11563 static void sharg (union node *, FILE *);
11564 static void indent (int, char *, FILE *);
11565 static void trstring (char *);
11572 trputs("showtree called\n");
11573 shtree(n, 1, NULL, stdout);
11578 shtree(n, ind, pfx, fp)
11584 struct nodelist *lp;
11590 indent(ind, pfx, fp);
11601 shtree(n->nbinary.ch1, ind, NULL, fp);
11604 shtree(n->nbinary.ch2, ind, NULL, fp);
11612 for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
11617 if (n->npipe.backgnd)
11623 fprintf(fp, "<node type %d>", n->type);
11643 for (np = cmd->ncmd.args ; np ; np = np->narg.next) {
11649 for (np = cmd->ncmd.redirect ; np ; np = np->nfile.next) {
11655 if ((np->nfile.type <= NFROMFD) && (np->nfile.type >= NTO)) {
11656 s = redir_strings[np->nfile.type - NTO];
11662 switch (np->nfile.type) {
11663 case NTO: s = ">"; dftfd = 1; break;
11664 case NAPPEND: s = ">>"; dftfd = 1; break;
11665 case NTOFD: s = ">&"; dftfd = 1; break;
11666 case NTOOV: s = ">|"; dftfd = 1; break;
11667 case NFROM: s = "<"; dftfd = 0; break;
11668 case NFROMFD: s = "<&"; dftfd = 0; break;
11669 case NFROMTO: s = "<>"; dftfd = 0; break;
11670 default: s = "*error*"; dftfd = 0; break;
11673 if (np->nfile.fd != dftfd)
11674 fprintf(fp, "%d", np->nfile.fd);
11676 if (np->nfile.type == NTOFD || np->nfile.type == NFROMFD) {
11677 fprintf(fp, "%d", np->ndup.dupfd);
11679 sharg(np->nfile.fname, fp);
11693 struct nodelist *bqlist;
11696 if (arg->type != NARG) {
11697 printf("<node type %d>\n", arg->type);
11701 bqlist = arg->narg.backquote;
11702 for (p = arg->narg.text ; *p ; p++) {
11711 if (subtype == VSLENGTH)
11717 if (subtype & VSNUL)
11720 switch (subtype & VSTYPE) {
11739 case VSTRIMLEFTMAX:
11746 case VSTRIMRIGHTMAX:
11753 printf("<subtype %d>", subtype);
11760 case CTLBACKQ|CTLQUOTE:
11763 shtree(bqlist->n, -1, NULL, fp);
11775 indent(amount, pfx, fp)
11782 for (i = 0 ; i < amount ; i++) {
11783 if (pfx && i == amount - 1)
11801 static int debug = 1;
11803 static int debug = 0;
11811 if (tracefile == NULL)
11813 putc(c, tracefile);
11819 trace(const char *fmt, ...)
11823 if (tracefile != NULL) {
11824 (void) vfprintf(tracefile, fmt, va);
11825 if (strchr(fmt, '\n'))
11826 (void) fflush(tracefile);
11836 if (tracefile == NULL)
11838 fputs(s, tracefile);
11839 if (strchr(s, '\n'))
11851 if (tracefile == NULL)
11853 putc('"', tracefile);
11854 for (p = s ; *p ; p++) {
11856 case '\n': c = 'n'; goto backslash;
11857 case '\t': c = 't'; goto backslash;
11858 case '\r': c = 'r'; goto backslash;
11859 case '"': c = '"'; goto backslash;
11860 case '\\': c = '\\'; goto backslash;
11861 case CTLESC: c = 'e'; goto backslash;
11862 case CTLVAR: c = 'v'; goto backslash;
11863 case CTLVAR+CTLQUOTE: c = 'V'; goto backslash;
11864 case CTLBACKQ: c = 'q'; goto backslash;
11865 case CTLBACKQ+CTLQUOTE: c = 'Q'; goto backslash;
11866 backslash: putc('\\', tracefile);
11867 putc(c, tracefile);
11870 if (*p >= ' ' && *p <= '~')
11871 putc(*p, tracefile);
11873 putc('\\', tracefile);
11874 putc(*p >> 6 & 03, tracefile);
11875 putc(*p >> 3 & 07, tracefile);
11876 putc(*p & 07, tracefile);
11881 putc('"', tracefile);
11889 if (tracefile == NULL)
11894 putc(' ', tracefile);
11896 putc('\n', tracefile);
11911 #ifdef not_this_way
11914 if ((p = getenv("HOME")) == NULL) {
11915 if (geteuid() == 0)
11921 strcat(s, "/trace");
11924 strcpy(s, "./trace");
11925 #endif /* not_this_way */
11926 if ((tracefile = fopen(s, "a")) == NULL) {
11927 fprintf(stderr, "Can't open %s\n", s);
11931 if ((flags = fcntl(fileno(tracefile), F_GETFL, 0)) >= 0)
11932 fcntl(fileno(tracefile), F_SETFL, flags | O_APPEND);
11934 fputs("\nTracing started.\n", tracefile);
11941 * The trap builtin.
11945 trapcmd(argc, argv)
11954 for (signo = 0 ; signo < NSIG ; signo++) {
11955 if (trap[signo] != NULL) {
11959 p = single_quote(trap[signo]);
11960 sn = sys_siglist[signo];
11962 sn = u_signal_names(0, &signo, 0);
11965 printf("trap -- %s %s\n", p, sn);
11977 if ((signo = decode_signal(*ap, 0)) < 0)
11978 error("%s: bad trap", *ap);
11981 if (action[0] == '-' && action[1] == '\0')
11984 action = savestr(action);
11987 ckfree(trap[signo]);
11988 trap[signo] = action;
12003 * Set the signal handler for the specified signal. The routine figures
12004 * out what it should be set to.
12008 setsignal(int signo)
12012 struct sigaction act;
12014 if ((t = trap[signo]) == NULL)
12016 else if (*t != '\0')
12020 if (rootshell && action == S_DFL) {
12023 if (iflag || minusc || sflag == 0)
12049 t = &sigmode[signo - 1];
12052 * current setting unknown
12054 if (sigaction(signo, 0, &act) == -1) {
12056 * Pretend it worked; maybe we should give a warning
12057 * here, but other shells don't. We don't alter
12058 * sigmode, so that we retry every time.
12062 if (act.sa_handler == SIG_IGN) {
12063 if (mflag && (signo == SIGTSTP ||
12064 signo == SIGTTIN || signo == SIGTTOU)) {
12065 *t = S_IGN; /* don't hard ignore these */
12069 *t = S_RESET; /* force to be set */
12072 if (*t == S_HARD_IGN || *t == action)
12074 act.sa_handler = ((action == S_CATCH) ? onsig
12075 : ((action == S_IGN) ? SIG_IGN : SIG_DFL));
12078 sigemptyset(&act.sa_mask);
12079 sigaction(signo, &act, 0);
12090 if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
12091 signal(signo, SIG_IGN);
12093 sigmode[signo - 1] = S_HARD_IGN;
12104 if (signo == SIGINT && trap[SIGINT] == NULL) {
12108 gotsig[signo - 1] = 1;
12114 * Called to execute a trap. Perhaps we should avoid entering new trap
12115 * handlers while we are executing a trap handler.
12125 for (i = 1 ; ; i++) {
12132 savestatus=exitstatus;
12133 evalstring(trap[i], 0);
12134 exitstatus=savestatus;
12141 * Called to exit the shell.
12145 exitshell(int status)
12147 struct jmploc loc1, loc2;
12150 TRACE(("exitshell(%d) pid=%d\n", status, getpid()));
12151 if (setjmp(loc1.loc)) {
12154 if (setjmp(loc2.loc)) {
12158 if ((p = trap[0]) != NULL && *p != '\0') {
12162 l1: handler = &loc2; /* probably unnecessary */
12171 static int decode_signal(const char *string, int minsig)
12174 const char *name = u_signal_names(string, &signo, minsig);
12176 return name ? signo : -1;
12179 static struct var **hashvar (const char *);
12180 static void showvars (const char *, int, int);
12181 static struct var **findvar (struct var **, const char *);
12184 * Initialize the varable symbol tables and import the environment
12188 * This routine initializes the builtin variables. It is called when the
12189 * shell is initialized and again when a shell procedure is spawned.
12194 const struct varinit *ip;
12198 for (ip = varinit ; (vp = ip->var) != NULL ; ip++) {
12199 if ((vp->flags & VEXPORT) == 0) {
12200 vpp = hashvar(ip->text);
12203 vp->text = strdup(ip->text);
12204 vp->flags = ip->flags;
12205 vp->func = ip->func;
12209 * PS1 depends on uid
12211 if ((vps1.flags & VEXPORT) == 0) {
12212 vpp = hashvar("PS1=");
12215 vps1.text = strdup(geteuid() ? "PS1=$ " : "PS1=# ");
12216 vps1.flags = VSTRFIXED|VTEXTFIXED;
12221 * Set the value of a variable. The flags argument is ored with the
12222 * flags of the variable. If val is NULL, the variable is unset.
12226 setvar(name, val, flags)
12227 const char *name, *val;
12243 if (! is_in_name(*p)) {
12244 if (*p == '\0' || *p == '=')
12250 namelen = p - name;
12252 error("%.*s: bad variable name", namelen, name);
12253 len = namelen + 2; /* 2 is space for '=' and '\0' */
12257 len += vallen = strlen(val);
12260 nameeq = ckmalloc(len);
12261 memcpy(nameeq, name, namelen);
12262 nameeq[namelen] = '=';
12264 memcpy(nameeq + namelen + 1, val, vallen + 1);
12266 nameeq[namelen + 1] = '\0';
12268 setvareq(nameeq, flags);
12275 * Same as setvar except that the variable and value are passed in
12276 * the first argument as name=value. Since the first argument will
12277 * be actually stored in the table, it should not be a string that
12286 struct var *vp, **vpp;
12289 flags |= (VEXPORT & (((unsigned) (1 - aflag)) - 1));
12290 if ((vp = *findvar(vpp, s))) {
12291 if (vp->flags & VREADONLY) {
12292 size_t len = strchr(s, '=') - s;
12293 error("%.*s: is read only", len, s);
12297 if (vp->func && (flags & VNOFUNC) == 0)
12298 (*vp->func)(strchr(s, '=') + 1);
12300 if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
12303 vp->flags &= ~(VTEXTFIXED|VSTACK|VUNSET);
12304 vp->flags |= flags;
12308 * We could roll this to a function, to handle it as
12309 * a regular variable function callback, but why bother?
12311 if (iflag && (vp == &vmpath || (vp == &vmail && !mpathset())))
12317 vp = ckmalloc(sizeof (*vp));
12328 * Process a linked list of variable assignments.
12333 struct strlist *mylist;
12335 struct strlist *lp;
12338 for (lp = mylist ; lp ; lp = lp->next) {
12339 setvareq(savestr(lp->text), 0);
12347 * Find the value of a variable. Returns NULL if not set.
12350 static const char *
12356 if ((v = *findvar(hashvar(name), name)) && !(v->flags & VUNSET)) {
12357 return strchr(v->text, '=') + 1;
12365 * Search the environment of a builtin command.
12368 static const char *
12369 bltinlookup(const char *name)
12371 const struct strlist *sp;
12373 for (sp = cmdenviron ; sp ; sp = sp->next) {
12374 if (varequal(sp->text, name))
12375 return strchr(sp->text, '=') + 1;
12377 return lookupvar(name);
12383 * Generate a list of exported variables. This routine is used to construct
12384 * the third argument to execve when executing a program.
12396 for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
12397 for (vp = *vpp ; vp ; vp = vp->next)
12398 if (vp->flags & VEXPORT)
12401 ep = env = stalloc((nenv + 1) * sizeof *env);
12402 for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
12403 for (vp = *vpp ; vp ; vp = vp->next)
12404 if (vp->flags & VEXPORT)
12413 * Called when a shell procedure is invoked to clear out nonexported
12414 * variables. It is also necessary to reallocate variables of with
12415 * VSTACK set since these are currently allocated on the stack.
12421 struct var *vp, **prev;
12423 for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
12424 for (prev = vpp ; (vp = *prev) != NULL ; ) {
12425 if ((vp->flags & VEXPORT) == 0) {
12427 if ((vp->flags & VTEXTFIXED) == 0)
12429 if ((vp->flags & VSTRFIXED) == 0)
12432 if (vp->flags & VSTACK) {
12433 vp->text = savestr(vp->text);
12434 vp->flags &=~ VSTACK;
12446 * Command to list all variables which are set. Currently this command
12447 * is invoked from the set command when the set command is called without
12452 showvarscmd(argc, argv)
12456 showvars(nullstr, VUNSET, VUNSET);
12463 * The export and readonly commands.
12467 exportcmd(argc, argv)
12474 int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT;
12477 listsetvar(cmdenviron);
12478 pflag = (nextopt("p") == 'p');
12479 if (argc > 1 && !pflag) {
12480 while ((name = *argptr++) != NULL) {
12481 if ((p = strchr(name, '=')) != NULL) {
12484 if ((vp = *findvar(hashvar(name), name))) {
12489 setvar(name, p, flag);
12493 showvars(argv[0], flag, 0);
12500 * The "local" command.
12503 /* funcnest nonzero if we are currently evaluating a function */
12506 localcmd(argc, argv)
12513 error("Not in a function");
12514 while ((name = *argptr++) != NULL) {
12522 * Make a variable a local variable. When a variable is made local, it's
12523 * value and flags are saved in a localvar structure. The saved values
12524 * will be restored when the shell function returns. We handle the name
12525 * "-" as a special case.
12532 struct localvar *lvp;
12537 lvp = ckmalloc(sizeof (struct localvar));
12538 if (name[0] == '-' && name[1] == '\0') {
12540 p = ckmalloc(sizeof optet_vals);
12541 lvp->text = memcpy(p, optet_vals, sizeof optet_vals);
12544 vpp = hashvar(name);
12545 vp = *findvar(vpp, name);
12547 if (strchr(name, '='))
12548 setvareq(savestr(name), VSTRFIXED);
12550 setvar(name, NULL, VSTRFIXED);
12551 vp = *vpp; /* the new variable */
12553 lvp->flags = VUNSET;
12555 lvp->text = vp->text;
12556 lvp->flags = vp->flags;
12557 vp->flags |= VSTRFIXED|VTEXTFIXED;
12558 if (strchr(name, '='))
12559 setvareq(savestr(name), 0);
12563 lvp->next = localvars;
12570 * Called after a function returns.
12575 struct localvar *lvp;
12578 while ((lvp = localvars) != NULL) {
12579 localvars = lvp->next;
12581 if (vp == NULL) { /* $- saved */
12582 memcpy(optet_vals, lvp->text, sizeof optet_vals);
12584 } else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) {
12585 (void)unsetvar(vp->text);
12587 if ((vp->flags & VTEXTFIXED) == 0)
12589 vp->flags = lvp->flags;
12590 vp->text = lvp->text;
12598 setvarcmd(argc, argv)
12603 return unsetcmd(argc, argv);
12604 else if (argc == 3)
12605 setvar(argv[1], argv[2], 0);
12607 error("List assignment not implemented");
12613 * The unset builtin command. We unset the function before we unset the
12614 * variable to allow a function to be unset when there is a readonly variable
12615 * with the same name.
12619 unsetcmd(argc, argv)
12629 while ((i = nextopt("vf")) != '\0') {
12635 if (flg_func == 0 && flg_var == 0)
12638 for (ap = argptr; *ap ; ap++) {
12642 ret |= unsetvar(*ap);
12649 * Unset the specified variable.
12653 unsetvar(const char *s)
12658 vpp = findvar(hashvar(s), s);
12661 if (vp->flags & VREADONLY)
12664 if (*(strchr(vp->text, '=') + 1) != '\0')
12665 setvar(s, nullstr, 0);
12666 vp->flags &= ~VEXPORT;
12667 vp->flags |= VUNSET;
12668 if ((vp->flags & VSTRFIXED) == 0) {
12669 if ((vp->flags & VTEXTFIXED) == 0)
12684 * Find the appropriate entry in the hash table from the name.
12687 static struct var **
12688 hashvar(const char *p)
12690 unsigned int hashval;
12692 hashval = ((unsigned char) *p) << 4;
12693 while (*p && *p != '=')
12694 hashval += (unsigned char) *p++;
12695 return &vartab[hashval % VTABSIZE];
12701 * Returns true if the two strings specify the same varable. The first
12702 * variable name is terminated by '='; the second may be terminated by
12703 * either '=' or '\0'.
12707 varequal(const char *p, const char *q)
12709 while (*p == *q++) {
12713 if (*p == '=' && *(q - 1) == '\0')
12719 showvars(const char *myprefix, int mask, int xor)
12723 const char *sep = myprefix == nullstr ? myprefix : spcstr;
12725 for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
12726 for (vp = *vpp ; vp ; vp = vp->next) {
12727 if ((vp->flags & mask) ^ xor) {
12731 p = strchr(vp->text, '=') + 1;
12732 len = p - vp->text;
12733 p = single_quote(p);
12735 printf("%s%s%.*s%s\n", myprefix, sep, len,
12743 static struct var **
12744 findvar(struct var **vpp, const char *name)
12746 for (; *vpp; vpp = &(*vpp)->next) {
12747 if (varequal((*vpp)->text, name)) {
12755 * Copyright (c) 1999 Herbert Xu <herbert@debian.org>
12756 * This file contains code for the times builtin.
12757 * $Id: ash.c,v 1.26 2001/10/18 04:11:38 andersen Exp $
12759 static int timescmd (int argc, char **argv)
12762 long int clk_tck = sysconf(_SC_CLK_TCK);
12765 printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n",
12766 (int) (buf.tms_utime / clk_tck / 60),
12767 ((double) buf.tms_utime) / clk_tck,
12768 (int) (buf.tms_stime / clk_tck / 60),
12769 ((double) buf.tms_stime) / clk_tck,
12770 (int) (buf.tms_cutime / clk_tck / 60),
12771 ((double) buf.tms_cutime) / clk_tck,
12772 (int) (buf.tms_cstime / clk_tck / 60),
12773 ((double) buf.tms_cstime) / clk_tck);
12777 #ifdef ASH_MATH_SUPPORT
12778 /* The let builtin. */
12779 int letcmd(int argc, char **argv)
12784 char *tmp, *expression, p[13];
12785 expression = strchr(argv[1], '=');
12787 /* Cannot use 'error()' here, or the return code
12788 * will be incorrect */
12789 out2fmt("sh: let: syntax error: \"%s\"\n", argv[1]);
12792 *expression = '\0';
12793 tmp = ++expression;
12794 result = arith(tmp, &errcode);
12796 /* Cannot use 'error()' here, or the return code
12797 * will be incorrect */
12798 out2fmt("sh: let: ");
12800 out2fmt("divide by zero");
12802 out2fmt("syntax error: \"%s=%s\"\n", argv[1], expression);
12805 snprintf(p, 12, "%ld", result);
12806 setvar(argv[1], savestr(p), 0);
12807 } else if (argc >= 3)
12808 synerror("invalid operand");
12816 * Copyright (c) 1989, 1991, 1993, 1994
12817 * The Regents of the University of California. All rights reserved.
12819 * This code is derived from software contributed to Berkeley by
12820 * Kenneth Almquist.
12822 * Redistribution and use in source and binary forms, with or without
12823 * modification, are permitted provided that the following conditions
12825 * 1. Redistributions of source code must retain the above copyright
12826 * notice, this list of conditions and the following disclaimer.
12827 * 2. Redistributions in binary form must reproduce the above copyright
12828 * notice, this list of conditions and the following disclaimer in the
12829 * documentation and/or other materials provided with the distribution.
12831 * 3. <BSD Advertising Clause omitted per the July 22, 1999 licensing change
12832 * ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change>
12834 * 4. Neither the name of the University nor the names of its contributors
12835 * may be used to endorse or promote products derived from this software
12836 * without specific prior written permission.
12838 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
12839 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
12840 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
12841 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
12842 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
12843 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
12844 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
12845 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
12846 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
12847 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
projects / oweals / busybox.git / blob