blob: efba6a1ee22ccc806d4c0551e10e727d03ad5083 [file] [log] [blame]
Eric Andersenff9eee42001-06-29 04:57:14 +00001/* vi: set sw=4 ts=4: */
2/*
3 * Minix shell port for busybox
4 *
5 * This version of the Minix shell was adapted for use in busybox
6 * by Erik Andersen <andersee@debian.org>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 * Original copyright notice is retained at the end of this file.
23 */
24
25#include <ctype.h>
26#include <dirent.h>
27#include <errno.h>
28#include <fcntl.h>
29#include <limits.h>
30#include <setjmp.h>
31#include <signal.h>
32#include <stddef.h>
33#include <stdio.h>
34#include <stdlib.h>
35#include <string.h>
36#include <time.h>
37#include <unistd.h>
38#include <sys/stat.h>
39#include <sys/times.h>
40#include <sys/types.h>
41#include <sys/wait.h>
42
43#include "cmdedit.h"
44#include "busybox.h"
45
46
47/* -------- sh.h -------- */
48/*
49 * shell
50 */
51
52#define LINELIM 2100
53#define NPUSH 8 /* limit to input nesting */
54
55#define NOFILE 20 /* Number of open files */
56#define NUFILE 10 /* Number of user-accessible files */
57#define FDBASE 10 /* First file usable by Shell */
58
59/*
60 * values returned by wait
61 */
62#define WAITSIG(s) ((s)&0177)
63#define WAITVAL(s) (((s)>>8)&0377)
64#define WAITCORE(s) (((s)&0200)!=0)
65
66/*
67 * library and system defintions
68 */
69typedef void xint; /* base type of jmp_buf, for not broken compilers */
70
71/*
72 * shell components
73 */
74
75#define QUOTE 0200
76
77#define NOBLOCK ((struct op *)NULL)
78#define NOWORD ((char *)NULL)
79#define NOWORDS ((char **)NULL)
80#define NOPIPE ((int *)NULL)
81
82/*
83 * Description of a command or an operation on commands.
84 * Might eventually use a union.
85 */
86struct op {
87 int type; /* operation type, see below */
88 char **words; /* arguments to a command */
89 struct ioword **ioact; /* IO actions (eg, < > >>) */
90 struct op *left;
91 struct op *right;
92 char *str; /* identifier for case and for */
93};
94
95#define TCOM 1 /* command */
96#define TPAREN 2 /* (c-list) */
97#define TPIPE 3 /* a | b */
98#define TLIST 4 /* a [&;] b */
99#define TOR 5 /* || */
100#define TAND 6 /* && */
101#define TFOR 7
102#define TDO 8
103#define TCASE 9
104#define TIF 10
105#define TWHILE 11
106#define TUNTIL 12
107#define TELIF 13
108#define TPAT 14 /* pattern in case */
109#define TBRACE 15 /* {c-list} */
110#define TASYNC 16 /* c & */
111
112/*
113 * actions determining the environment of a process
114 */
115#define BIT(i) (1<<(i))
116#define FEXEC BIT(0) /* execute without forking */
117
118/*
119 * flags to control evaluation of words
120 */
121#define DOSUB 1 /* interpret $, `, and quotes */
122#define DOBLANK 2 /* perform blank interpretation */
123#define DOGLOB 4 /* interpret [?* */
124#define DOKEY 8 /* move words with `=' to 2nd arg. list */
125#define DOTRIM 16 /* trim resulting string */
126
127#define DOALL (DOSUB|DOBLANK|DOGLOB|DOKEY|DOTRIM)
128
129static char **dolv;
130static int dolc;
131static int exstat;
132static char gflg;
133static int interactive; /* Is this an interactive shell */
134static int execflg;
135static int multiline; /* \n changed to ; */
136static struct op *outtree; /* result from parser */
137
138static xint *failpt;
139static xint *errpt;
140static struct brkcon *brklist;
141static int isbreak;
142static int newfile(char *s);
143static char *findeq(char *cp);
144static char *cclass(char *p, int sub);
145static void initarea(void);
146extern int shell_main(int argc, char **argv);
147
148
149struct brkcon {
150 jmp_buf brkpt;
151 struct brkcon *nextlev;
152} ;
153
154/*
155 * redirection
156 */
157struct ioword {
158 short io_unit; /* unit affected */
159 short io_flag; /* action (below) */
160 char *io_name; /* file name */
161};
162#define IOREAD 1 /* < */
163#define IOHERE 2 /* << (here file) */
164#define IOWRITE 4 /* > */
165#define IOCAT 8 /* >> */
166#define IOXHERE 16 /* ${}, ` in << */
167#define IODUP 32 /* >&digit */
168#define IOCLOSE 64 /* >&- */
169
170#define IODEFAULT (-1) /* token for default IO unit */
171
172static struct wdblock *wdlist;
173static struct wdblock *iolist;
174
175/*
176 * parsing & execution environment
177 */
178static struct env {
179 char *linep;
180 struct io *iobase;
181 struct io *iop;
182 xint *errpt;
183 int iofd;
184 struct env *oenv;
185} e;
186
187/*
188 * flags:
189 * -e: quit on error
190 * -k: look for name=value everywhere on command line
191 * -n: no execution
192 * -t: exit after reading and executing one command
193 * -v: echo as read
194 * -x: trace
195 * -u: unset variables net diagnostic
196 */
197static char *flag;
198
199static char *null; /* null value for variable */
200static int intr; /* interrupt pending */
201
202static char *trap[_NSIG+1];
203static char ourtrap[_NSIG+1];
204static int trapset; /* trap pending */
205
206static int heedint; /* heed interrupt signals */
207
208static int yynerrs; /* yacc */
209
210static char line[LINELIM];
211static char *elinep;
212
213/*
214 * other functions
215 */
216static int (*inbuilt(char *s ))(void);
217
218static char *rexecve (char *c , char **v, char **envp );
219static char *space (int n );
220static char *strsave (char *s, int a );
221static char *evalstr (char *cp, int f );
222static char *putn (int n );
223static char *itoa (unsigned u, int n );
224static char *unquote (char *as );
225static struct var *lookup (char *n );
226static int rlookup (char *n );
227static struct wdblock *glob (char *cp, struct wdblock *wb );
228static int my_getc( int ec);
229static int subgetc (int ec, int quoted );
230static char **makenv (void);
231static char **eval (char **ap, int f );
232static int setstatus (int s );
233static int waitfor (int lastpid, int canintr );
234
235static void onintr (int s ); /* SIGINT handler */
236
237static int newenv (int f );
238static void quitenv (void);
239static void err (char *s );
240static int anys (char *s1, char *s2 );
241static int any (int c, char *s );
242static void next (int f );
243static void setdash (void);
244static void onecommand (void);
245static void runtrap (int i );
246static int gmatch (char *s, char *p );
247
248/*
249 * error handling
250 */
251static void leave (void); /* abort shell (or fail in subshell) */
252static void fail (void); /* fail but return to process next command */
253static void warn (char *s );
254static void sig (int i ); /* default signal handler */
255
256
257
258/* -------- area stuff -------- */
259
260#define REGSIZE sizeof(struct region)
261#define GROWBY 256
262//#define SHRINKBY 64
263#undef SHRINKBY
264#define FREE 32767
265#define BUSY 0
266#define ALIGN (sizeof(int)-1)
267
268
269struct region {
270 struct region *next;
271 int area;
272};
273
274
275
276/* -------- grammar stuff -------- */
277typedef union {
278 char *cp;
279 char **wp;
280 int i;
281 struct op *o;
282} YYSTYPE;
283#define WORD 256
284#define LOGAND 257
285#define LOGOR 258
286#define BREAK 259
287#define IF 260
288#define THEN 261
289#define ELSE 262
290#define ELIF 263
291#define FI 264
292#define CASE 265
293#define ESAC 266
294#define FOR 267
295#define WHILE 268
296#define UNTIL 269
297#define DO 270
298#define DONE 271
299#define IN 272
300#define YYERRCODE 300
301
302/* flags to yylex */
303#define CONTIN 01 /* skip new lines to complete command */
304
305#define SYNTAXERR zzerr()
306static struct op *pipeline(int cf );
307static struct op *andor(void);
308static struct op *c_list(void);
309static int synio(int cf );
310static void musthave (int c, int cf );
311static struct op *simple(void);
312static struct op *nested(int type, int mark );
313static struct op *command(int cf );
314static struct op *dogroup(int onlydone );
315static struct op *thenpart(void);
316static struct op *elsepart(void);
317static struct op *caselist(void);
318static struct op *casepart(void);
319static char **pattern(void);
320static char **wordlist(void);
321static struct op *list(struct op *t1, struct op *t2 );
322static struct op *block(int type, struct op *t1, struct op *t2, char **wp );
323static struct op *newtp(void);
324static struct op *namelist(struct op *t );
325static char **copyw(void);
326static void word(char *cp );
327static struct ioword **copyio(void);
328static struct ioword *io (int u, int f, char *cp );
329static void zzerr(void);
330static void yyerror(char *s );
331static int yylex(int cf );
332static int collect(int c, int c1 );
333static int dual(int c );
334static void diag(int ec );
335static char *tree(unsigned size );
336
337/* -------- var.h -------- */
338
339struct var {
340 char *value;
341 char *name;
342 struct var *next;
343 char status;
344};
345#define COPYV 1 /* flag to setval, suggesting copy */
346#define RONLY 01 /* variable is read-only */
347#define EXPORT 02 /* variable is to be exported */
348#define GETCELL 04 /* name & value space was got with getcell */
349
350static struct var *vlist; /* dictionary */
351
352static struct var *homedir; /* home directory */
353static struct var *prompt; /* main prompt */
354static struct var *cprompt; /* continuation prompt */
355static struct var *path; /* search path for commands */
356static struct var *shell; /* shell to interpret command files */
357static struct var *ifs; /* field separators */
358
359static int yyparse (void);
360static struct var *lookup (char *n );
361static void setval (struct var *vp, char *val );
362static void nameval (struct var *vp, char *val, char *name );
363static void export (struct var *vp );
364static void ronly (struct var *vp );
365static int isassign (char *s );
366static int checkname (char *cp );
367static int assign (char *s, int cf );
368static void putvlist (int f, int out );
369static int eqname (char *n1, char *n2 );
370
371static int execute (struct op *t, int *pin, int *pout, int act );
372
373/* -------- io.h -------- */
374/* io buffer */
375struct iobuf {
376 unsigned id; /* buffer id */
377 char buf[512]; /* buffer */
378 char *bufp; /* pointer into buffer */
379 char *ebufp; /* pointer to end of buffer */
380};
381
382/* possible arguments to an IO function */
383struct ioarg {
384 char *aword;
385 char **awordlist;
386 int afile; /* file descriptor */
387 unsigned afid; /* buffer id */
388 long afpos; /* file position */
389 struct iobuf *afbuf; /* buffer for this file */
390};
391//static struct ioarg ioargstack[NPUSH];
392#define AFID_NOBUF (~0)
393#define AFID_ID 0
394
395/* an input generator's state */
396struct io {
397 int (*iofn)();
398 struct ioarg *argp;
399 int peekc;
400 char prev; /* previous character read by readc() */
401 char nlcount; /* for `'s */
402 char xchar; /* for `'s */
403 char task; /* reason for pushed IO */
404};
405//static struct io iostack[NPUSH];
406#define XOTHER 0 /* none of the below */
407#define XDOLL 1 /* expanding ${} */
408#define XGRAVE 2 /* expanding `'s */
409#define XIO 3 /* file IO */
410
411/* in substitution */
412#define INSUB() (e.iop->task == XGRAVE || e.iop->task == XDOLL)
413
414/*
415 * input generators for IO structure
416 */
417static int nlchar (struct ioarg *ap );
418static int strchar (struct ioarg *ap );
419static int qstrchar (struct ioarg *ap );
420static int filechar (struct ioarg *ap );
421static int herechar (struct ioarg *ap );
422static int linechar (struct ioarg *ap );
423static int gravechar (struct ioarg *ap, struct io *iop );
424static int qgravechar (struct ioarg *ap, struct io *iop );
425static int dolchar (struct ioarg *ap );
426static int wdchar (struct ioarg *ap );
427static void scraphere (void);
428static void freehere (int area );
429static void gethere (void);
430static void markhere (char *s, struct ioword *iop );
431static int herein (char *hname, int xdoll );
432static int run (struct ioarg *argp, int (*f)());
433
434/*
435 * IO functions
436 */
437static int eofc (void);
438static int readc (void);
439static void unget (int c );
440static void ioecho (int c );
441static void prs (char *s );
442static void prn (unsigned u );
443static void closef (int i );
444static void closeall (void);
445
446/*
447 * IO control
448 */
449static void pushio (struct ioarg *argp, int (*fn)());
450static int remap (int fd );
451static int openpipe (int *pv );
452static void closepipe (int *pv );
453static struct io *setbase (struct io *ip );
454
455static struct ioarg temparg; /* temporary for PUSHIO */
456#define PUSHIO(what,arg,gen) ((temparg.what = (arg)),pushio(&temparg,(gen)))
457#define RUN(what,arg,gen) ((temparg.what = (arg)), run(&temparg,(gen)))
458
459/* -------- word.h -------- */
460
461#define NSTART 16 /* default number of words to allow for initially */
462
463struct wdblock {
464 short w_bsize;
465 short w_nword;
466 /* bounds are arbitrary */
467 char *w_words[1];
468};
469
470static struct wdblock *addword (char *wd, struct wdblock *wb );
471static struct wdblock *newword (int nw );
472static char **getwords (struct wdblock *wb );
473
474/* -------- area.h -------- */
475
476/*
477 * storage allocation
478 */
479static char *getcell (unsigned nbytes );
480static void garbage (void);
481static void setarea (char *cp, int a );
482static int getarea (char *cp );
483static void freearea (int a );
484static void freecell (char *cp );
485static int areanum; /* current allocation area */
486
487#define NEW(type) (type *)getcell(sizeof(type))
488#define DELETE(obj) freecell((char *)obj)
489
490
491/* -------- misc stuff -------- */
492
493static int forkexec (struct op *t, int *pin, int *pout, int act, char **wp, int *pforked );
494static int iosetup (struct ioword *iop, int pipein, int pipeout );
495static void echo(char **wp );
496static struct op **find1case (struct op *t, char *w );
497static struct op *findcase (struct op *t, char *w );
498static void brkset(struct brkcon *bc );
499static int dolabel(void);
Eric Andersen1c039232001-07-07 00:05:55 +0000500static int dohelp(void);
Eric Andersenff9eee42001-06-29 04:57:14 +0000501static int dochdir(struct op *t );
502static int doshift(struct op *t );
503static int dologin(struct op *t );
504static int doumask(struct op *t );
505static int doexec(struct op *t );
506static int dodot(struct op *t );
507static int dowait(struct op *t );
508static int doread(struct op *t );
509static int doeval(struct op *t );
510static int dotrap(struct op *t );
511static int getsig(char *s );
512static void setsig (int n, void (*f)());
513static int getn(char *as );
514static int dobreak(struct op *t );
515static int docontinue(struct op *t );
516static int brkcontin (char *cp, int val );
517static int doexit(struct op *t );
518static int doexport(struct op *t );
519static int doreadonly(struct op *t );
520static void rdexp (char **wp, void (*f)(), int key);
521static void badid(char *s );
522static int doset(struct op *t );
523static void varput (char *s, int out );
524static int dotimes(void);
525static int expand (char *cp, struct wdblock **wbp, int f );
526static char *blank(int f );
527static int dollar(int quoted );
528static int grave(int quoted );
529static void globname (char *we, char *pp );
530static char *generate (char *start1, char *end1, char *middle, char *end );
531static int anyspcl(struct wdblock *wb );
532static int xstrcmp (char *p1, char *p2 );
533static void glob0 (char *a0, unsigned int a1, int a2, int (*a3)(char *, char *));
534static void glob1 (char *base, char *lim );
535static void glob2 (char *i, char *j );
536static void glob3 (char *i, char *j, char *k );
537static void readhere (char **name, char *s, int ec );
538static void pushio(struct ioarg *argp, int (*fn)());
539static int xxchar(struct ioarg *ap );
540
541struct here {
542 char *h_tag;
543 int h_dosub;
544 struct ioword *h_iop;
545 struct here *h_next;
546};
547
548static char *signame[] = {
549 "Signal 0",
550 "Hangup",
551 (char *)NULL, /* interrupt */
552 "Quit",
553 "Illegal instruction",
554 "Trace/BPT trap",
555 "Abort",
556 "Bus error",
557 "Floating Point Exception",
558 "Killed",
559 "SIGUSR1",
560 "SIGSEGV",
561 "SIGUSR2",
562 (char *)NULL, /* broken pipe */
563 "Alarm clock",
564 "Terminated",
565};
566#define NSIGNAL (sizeof(signame)/sizeof(signame[0]))
567
568struct res {
569 char *r_name;
570 int r_val;
571};
572static struct res restab[] = {
573 {"for", FOR},
574 {"case", CASE},
575 {"esac", ESAC},
576 {"while", WHILE},
577 {"do", DO},
578 {"done", DONE},
579 {"if", IF},
580 {"in", IN},
581 {"then", THEN},
582 {"else", ELSE},
583 {"elif", ELIF},
584 {"until", UNTIL},
585 {"fi", FI},
586
587 {";;", BREAK},
588 {"||", LOGOR},
589 {"&&", LOGAND},
590 {"{", '{'},
591 {"}", '}'},
592 {0, 0},
593};
594
595
Eric Andersen1c039232001-07-07 00:05:55 +0000596struct builtincmd {
597 const char *name;
598 int (*builtinfunc)();
Eric Andersenff9eee42001-06-29 04:57:14 +0000599};
Eric Andersen1c039232001-07-07 00:05:55 +0000600static const struct builtincmd builtincmds[] = {
601 {".", dodot},
Eric Andersenff9eee42001-06-29 04:57:14 +0000602 {":", dolabel},
Eric Andersenff9eee42001-06-29 04:57:14 +0000603 {"break", dobreak},
Eric Andersen1c039232001-07-07 00:05:55 +0000604 {"cd", dochdir},
Eric Andersenff9eee42001-06-29 04:57:14 +0000605 {"continue",docontinue},
Eric Andersen1c039232001-07-07 00:05:55 +0000606 {"eval", doeval},
607 {"exec", doexec},
Eric Andersenff9eee42001-06-29 04:57:14 +0000608 {"exit", doexit},
609 {"export", doexport},
Eric Andersen1c039232001-07-07 00:05:55 +0000610 {"help", dohelp},
Eric Andersenff9eee42001-06-29 04:57:14 +0000611 {"login", dologin},
612 {"newgrp", dologin},
Eric Andersen1c039232001-07-07 00:05:55 +0000613 {"read", doread},
614 {"readonly",doreadonly},
615 {"set", doset},
616 {"shift", doshift},
Eric Andersenff9eee42001-06-29 04:57:14 +0000617 {"times", dotimes},
Eric Andersen1c039232001-07-07 00:05:55 +0000618 {"trap", dotrap},
619 {"umask", doumask},
620 {"wait", dowait},
Eric Andersenff9eee42001-06-29 04:57:14 +0000621 {0,0}
622};
623
624/* Globals */
625extern char **environ; /* environment pointer */
626static char **dolv;
627static int dolc;
628static int exstat;
629static char gflg;
630static int interactive; /* Is this an interactive shell */
631static int execflg;
632static int multiline; /* \n changed to ; */
633static struct op *outtree; /* result from parser */
634static xint *failpt;
635static xint *errpt;
636static struct brkcon *brklist;
637static int isbreak;
638static struct wdblock *wdlist;
639static struct wdblock *iolist;
640static char *trap[_NSIG+1];
641static char ourtrap[_NSIG+1];
642static int trapset; /* trap pending */
643static int yynerrs; /* yacc */
644static char line[LINELIM];
645static struct var *vlist; /* dictionary */
646static struct var *homedir; /* home directory */
647static struct var *prompt; /* main prompt */
648static struct var *cprompt; /* continuation prompt */
649static struct var *path; /* search path for commands */
650static struct var *shell; /* shell to interpret command files */
651static struct var *ifs; /* field separators */
652static struct ioarg ioargstack[NPUSH];
653static struct io iostack[NPUSH];
654static int areanum; /* current allocation area */
655static int intr;
656static int inparse;
657static char flags['z'-'a'+1];
658static char *flag = flags-'a';
659static char *elinep = line+sizeof(line)-5;
660static char *null = "";
661static int heedint =1;
662static struct env e ={line, iostack, iostack-1, (xint *)NULL, FDBASE, (struct env *)NULL};
663static void (*qflag)(int) = SIG_IGN;
664static char shellname[] = "/bin/sh";
665static char search[] = ":/bin:/usr/bin";
666static int startl;
667static int peeksym;
668static int nlseen;
669static int iounit = IODEFAULT;
670static YYSTYPE yylval;
671static struct iobuf sharedbuf = {AFID_NOBUF};
672static struct iobuf mainbuf = {AFID_NOBUF};
673static unsigned bufid = AFID_ID; /* buffer id counter */
674static struct ioarg temparg = {0, 0, 0, AFID_NOBUF, 0};
675static struct here *inhere; /* list of hear docs while parsing */
676static struct here *acthere; /* list of active here documents */
677static struct region *areabot; /* bottom of area */
678static struct region *areatop; /* top of area */
679static struct region *areanxt; /* starting point of scan */
680static void * brktop;
681static void * brkaddr;
682
683
684#ifdef BB_FEATURE_COMMAND_EDITING
685char * current_prompt;
686unsigned int shell_context;
687#endif
688
689
690/* -------- sh.c -------- */
691/*
692 * shell
693 */
694
695
696extern int shell_main(int argc, char **argv)
697{
698 register int f;
699 register char *s;
700 int cflag;
701 char *name, **ap;
702 int (*iof)();
703
704 initarea();
705 if ((ap = environ) != NULL) {
706 while (*ap)
707 assign(*ap++, !COPYV);
708 for (ap = environ; *ap;)
709 export(lookup(*ap++));
710 }
711 closeall();
712 areanum = 1;
713
714 shell = lookup("SHELL");
715 if (shell->value == null)
716 setval(shell, shellname);
717 export(shell);
718
719 homedir = lookup("HOME");
720 if (homedir->value == null)
721 setval(homedir, "/");
722 export(homedir);
723
724 setval(lookup("$"), itoa(getpid(), 5));
725
726 path = lookup("PATH");
727 if (path->value == null)
728 setval(path, search);
729 export(path);
730
731 ifs = lookup("IFS");
732 if (ifs->value == null)
733 setval(ifs, " \t\n");
734
735 prompt = lookup("PS1");
Eric Andersen1c039232001-07-07 00:05:55 +0000736#ifdef BB_FEATURE_SH_FANCY_PROMPT
Eric Andersenff9eee42001-06-29 04:57:14 +0000737 if (prompt->value == null)
Eric Andersen1c039232001-07-07 00:05:55 +0000738#endif
Eric Andersenff9eee42001-06-29 04:57:14 +0000739 setval(prompt, "$ ");
740 if (geteuid() == 0) {
741 setval(prompt, "# ");
742 prompt->status &= ~EXPORT;
743 }
744 cprompt = lookup("PS2");
Eric Andersen1c039232001-07-07 00:05:55 +0000745#ifdef BB_FEATURE_SH_FANCY_PROMPT
Eric Andersenff9eee42001-06-29 04:57:14 +0000746 if (cprompt->value == null)
Eric Andersen1c039232001-07-07 00:05:55 +0000747#endif
Eric Andersenff9eee42001-06-29 04:57:14 +0000748 setval(cprompt, "> ");
749
750 iof = filechar;
751 cflag = 0;
752 name = *argv++;
753 if (--argc >= 1) {
754 if(argv[0][0] == '-' && argv[0][1] != '\0') {
755 for (s = argv[0]+1; *s; s++)
756 switch (*s) {
757 case 'c':
758 prompt->status &= ~EXPORT;
759 cprompt->status &= ~EXPORT;
760 setval(prompt, "");
761 setval(cprompt, "");
762 cflag = 1;
763 if (--argc > 0)
764 PUSHIO(aword, *++argv, iof = nlchar);
765 break;
766
767 case 'q':
768 qflag = SIG_DFL;
769 break;
770
771 case 's':
772 /* standard input */
773 break;
774
775 case 't':
776 prompt->status &= ~EXPORT;
777 setval(prompt, "");
778 iof = linechar;
779 break;
780
781 case 'i':
782 interactive++;
783 default:
784 if (*s>='a' && *s<='z')
785 flag[(int)*s]++;
786 }
787 } else {
788 argv--;
789 argc++;
790 }
791 if (iof == filechar && --argc > 0) {
792 setval(prompt, "");
793 setval(cprompt, "");
794 prompt->status &= ~EXPORT;
795 cprompt->status &= ~EXPORT;
796 if (newfile(name = *++argv))
797 exit(1);
798 }
799 }
800 setdash();
801 if (e.iop < iostack) {
802 PUSHIO(afile, 0, iof);
Eric Andersen1c039232001-07-07 00:05:55 +0000803 if (isatty(0) && isatty(1) && !cflag) {
Eric Andersenff9eee42001-06-29 04:57:14 +0000804 interactive++;
Eric Andersen1c039232001-07-07 00:05:55 +0000805 printf( "\n\n" BB_BANNER " Built-in shell (msh)\n");
806 printf( "Enter 'help' for a list of built-in commands.\n\n");
807 }
Eric Andersenff9eee42001-06-29 04:57:14 +0000808 }
809 signal(SIGQUIT, qflag);
810 if (name && name[0] == '-') {
811 interactive++;
812 if ((f = open(".profile", 0)) >= 0)
813 next(remap(f));
814 if ((f = open("/etc/profile", 0)) >= 0)
815 next(remap(f));
816 }
817 if (interactive)
818 signal(SIGTERM, sig);
819 if (signal(SIGINT, SIG_IGN) != SIG_IGN)
820 signal(SIGINT, onintr);
821 dolv = argv;
822 dolc = argc;
823 dolv[0] = name;
824 if (dolc > 1) {
825 for (ap = ++argv; --argc > 0;) {
826 if (assign(*ap = *argv++, !COPYV)) {
827 dolc--; /* keyword */
828 } else {
829 ap++;
830 }
831 }
832 }
833 setval(lookup("#"), putn((--dolc < 0) ? (dolc = 0) : dolc));
834
835 for (;;) {
836 if (interactive && e.iop <= iostack) {
837#ifdef BB_FEATURE_COMMAND_EDITING
838 current_prompt=prompt->value;
839#else
840 prs(prompt->value);
841#endif
842 }
843 onecommand();
844 }
845}
846
847static void
848setdash()
849{
850 register char *cp;
851 register int c;
852 char m['z'-'a'+1];
853
854 cp = m;
855 for (c='a'; c<='z'; c++)
856 if (flag[c])
857 *cp++ = c;
858 *cp = 0;
859 setval(lookup("-"), m);
860}
861
862static int
863newfile(s)
864register char *s;
865{
866 register int f;
867
868 if (strcmp(s, "-") != 0) {
869 f = open(s, 0);
870 if (f < 0) {
871 prs(s);
872 err(": cannot open");
873 return(1);
874 }
875 } else
876 f = 0;
877 next(remap(f));
878 return(0);
879}
880
881static void
882onecommand()
883{
884 register int i;
885 jmp_buf m1;
886
887 while (e.oenv)
888 quitenv();
889 areanum = 1;
890 freehere(areanum);
891 freearea(areanum);
892 garbage();
893 wdlist = 0;
894 iolist = 0;
895 e.errpt = 0;
896 e.linep = line;
897 yynerrs = 0;
898 multiline = 0;
899 inparse = 1;
900 intr = 0;
901 execflg = 0;
902 setjmp(failpt = m1); /* Bruce Evans' fix */
903 if (setjmp(failpt = m1) || yyparse() || intr) {
904 while (e.oenv)
905 quitenv();
906 scraphere();
907 if (!interactive && intr)
908 leave();
909 inparse = 0;
910 intr = 0;
911 return;
912 }
913 inparse = 0;
914 brklist = 0;
915 intr = 0;
916 execflg = 0;
917 if (!flag['n'])
918 execute(outtree, NOPIPE, NOPIPE, 0);
919 if (!interactive && intr) {
920 execflg = 0;
921 leave();
922 }
923 if ((i = trapset) != 0) {
924 trapset = 0;
925 runtrap(i);
926 }
927}
928
929static void
930fail()
931{
932 longjmp(failpt, 1);
933 /* NOTREACHED */
934}
935
936static void
937leave()
938{
939 if (execflg)
940 fail();
941 scraphere();
942 freehere(1);
943 runtrap(0);
944 exit(exstat);
945 /* NOTREACHED */
946}
947
948static void
949warn(s)
950register char *s;
951{
952 if(*s) {
953 prs(s);
954 exstat = -1;
955 }
956 prs("\n");
957 if (flag['e'])
958 leave();
959}
960
961static void
962err(s)
963char *s;
964{
965 warn(s);
966 if (flag['n'])
967 return;
968 if (!interactive)
969 leave();
970 if (e.errpt)
971 longjmp(e.errpt, 1);
972 closeall();
973 e.iop = e.iobase = iostack;
974}
975
976static int
977newenv(f)
978int f;
979{
980 register struct env *ep;
981
982 if (f) {
983 quitenv();
984 return(1);
985 }
986 ep = (struct env *) space(sizeof(*ep));
987 if (ep == NULL) {
988 while (e.oenv)
989 quitenv();
990 fail();
991 }
992 *ep = e;
993 e.oenv = ep;
994 e.errpt = errpt;
995 return(0);
996}
997
998static void
999quitenv()
1000{
1001 register struct env *ep;
1002 register int fd;
1003
1004 if ((ep = e.oenv) != NULL) {
1005 fd = e.iofd;
1006 e = *ep;
1007 /* should close `'d files */
1008 DELETE(ep);
1009 while (--fd >= e.iofd)
1010 close(fd);
1011 }
1012}
1013
1014/*
1015 * Is any character from s1 in s2?
1016 */
1017static int
1018anys(s1, s2)
1019register char *s1, *s2;
1020{
1021 while (*s1)
1022 if (any(*s1++, s2))
1023 return(1);
1024 return(0);
1025}
1026
1027/*
1028 * Is character c in s?
1029 */
1030static int
1031any(c, s)
1032register int c;
1033register char *s;
1034{
1035 while (*s)
1036 if (*s++ == c)
1037 return(1);
1038 return(0);
1039}
1040
1041static char *
1042putn(n)
1043register int n;
1044{
1045 return(itoa(n, -1));
1046}
1047
1048static char *
1049itoa(u, n)
1050register unsigned u;
1051int n;
1052{
1053 register char *cp;
1054 static char s[20];
1055 int m;
1056
1057 m = 0;
1058 if (n < 0 && (int) u < 0) {
1059 m++;
1060 u = -u;
1061 }
1062 cp = s+sizeof(s);
1063 *--cp = 0;
1064 do {
1065 *--cp = u%10 + '0';
1066 u /= 10;
1067 } while (--n > 0 || u);
1068 if (m)
1069 *--cp = '-';
1070 return(cp);
1071}
1072
1073static void
1074next(f)
1075int f;
1076{
1077 PUSHIO(afile, f, filechar);
1078}
1079
1080static void
1081onintr(s)
1082int s; /* ANSI C requires a parameter */
1083{
1084 signal(SIGINT, onintr);
1085 intr = 1;
1086 if (interactive) {
1087 if (inparse) {
1088 prs("\n");
1089 fail();
1090 }
1091 }
1092 else if (heedint) {
1093 execflg = 0;
1094 leave();
1095 }
1096}
1097
1098static char *
1099space(n)
1100int n;
1101{
1102 register char *cp;
1103
1104 if ((cp = getcell(n)) == 0)
1105 err("out of string space");
1106 return(cp);
1107}
1108
1109static char *
1110strsave(s, a)
1111register char *s;
1112int a;
1113{
1114 register char *cp, *xp;
1115
1116 if ((cp = space(strlen(s)+1)) != NULL) {
1117 setarea((char *)cp, a);
1118 for (xp = cp; (*xp++ = *s++) != '\0';)
1119 ;
1120 return(cp);
1121 }
1122 return("");
1123}
1124
1125/*
1126 * trap handling
1127 */
1128static void
1129sig(i)
1130register int i;
1131{
1132 trapset = i;
1133 signal(i, sig);
1134}
1135
1136static void runtrap(i)
1137int i;
1138{
1139 char *trapstr;
1140
1141 if ((trapstr = trap[i]) == NULL)
1142 return;
1143 if (i == 0)
1144 trap[i] = 0;
1145 RUN(aword, trapstr, nlchar);
1146}
1147
1148/* -------- var.c -------- */
1149
1150/*
1151 * Find the given name in the dictionary
1152 * and return its value. If the name was
1153 * not previously there, enter it now and
1154 * return a null value.
1155 */
1156static struct var *
1157lookup(n)
1158register char *n;
1159{
1160 register struct var *vp;
1161 register char *cp;
1162 register int c;
1163 static struct var dummy;
1164
1165 if (isdigit(*n)) {
1166 dummy.name = n;
1167 for (c = 0; isdigit(*n) && c < 1000; n++)
1168 c = c*10 + *n-'0';
1169 dummy.status = RONLY;
1170 dummy.value = c <= dolc? dolv[c]: null;
1171 return(&dummy);
1172 }
1173 for (vp = vlist; vp; vp = vp->next)
1174 if (eqname(vp->name, n))
1175 return(vp);
1176 cp = findeq(n);
1177 vp = (struct var *)space(sizeof(*vp));
1178 if (vp == 0 || (vp->name = space((int)(cp-n)+2)) == 0) {
1179 dummy.name = dummy.value = "";
1180 return(&dummy);
1181 }
1182 for (cp = vp->name; (*cp = *n++) && *cp != '='; cp++)
1183 ;
1184 if (*cp == 0)
1185 *cp = '=';
1186 *++cp = 0;
1187 setarea((char *)vp, 0);
1188 setarea((char *)vp->name, 0);
1189 vp->value = null;
1190 vp->next = vlist;
1191 vp->status = GETCELL;
1192 vlist = vp;
1193 return(vp);
1194}
1195
1196/*
1197 * give variable at `vp' the value `val'.
1198 */
1199static void
1200setval(vp, val)
1201struct var *vp;
1202char *val;
1203{
1204 nameval(vp, val, (char *)NULL);
1205}
1206
1207/*
1208 * if name is not NULL, it must be
1209 * a prefix of the space `val',
1210 * and end with `='.
1211 * this is all so that exporting
1212 * values is reasonably painless.
1213 */
1214static void
1215nameval(vp, val, name)
1216register struct var *vp;
1217char *val, *name;
1218{
1219 register char *cp, *xp;
1220 char *nv;
1221 int fl;
1222
1223 if (vp->status & RONLY) {
1224 for (xp = vp->name; *xp && *xp != '=';)
1225 putc(*xp++, stderr);
1226 err(" is read-only");
1227 return;
1228 }
1229 fl = 0;
1230 if (name == NULL) {
1231 xp = space(strlen(vp->name)+strlen(val)+2);
1232 if (xp == 0)
1233 return;
1234 /* make string: name=value */
1235 setarea((char *)xp, 0);
1236 name = xp;
1237 for (cp = vp->name; (*xp = *cp++) && *xp!='='; xp++)
1238 ;
1239 if (*xp++ == 0)
1240 xp[-1] = '=';
1241 nv = xp;
1242 for (cp = val; (*xp++ = *cp++) != '\0';)
1243 ;
1244 val = nv;
1245 fl = GETCELL;
1246 }
1247 if (vp->status & GETCELL)
1248 freecell(vp->name); /* form new string `name=value' */
1249 vp->name = name;
1250 vp->value = val;
1251 vp->status |= fl;
1252}
1253
1254static void
1255export(vp)
1256struct var *vp;
1257{
1258 vp->status |= EXPORT;
1259}
1260
1261static void
1262ronly(vp)
1263struct var *vp;
1264{
1265 if (isalpha(vp->name[0])) /* not an internal symbol ($# etc) */
1266 vp->status |= RONLY;
1267}
1268
1269static int
1270isassign(s)
1271register char *s;
1272{
1273 if (!isalpha((int)*s))
1274 return(0);
1275 for (; *s != '='; s++)
1276 if (*s == 0 || !isalnum(*s))
1277 return(0);
1278 return(1);
1279}
1280
1281static int
1282assign(s, cf)
1283register char *s;
1284int cf;
1285{
1286 register char *cp;
1287 struct var *vp;
1288
1289 if (!isalpha(*s))
1290 return(0);
1291 for (cp = s; *cp != '='; cp++)
1292 if (*cp == 0 || !isalnum(*cp))
1293 return(0);
1294 vp = lookup(s);
1295 nameval(vp, ++cp, cf == COPYV? (char *)NULL: s);
1296 if (cf != COPYV)
1297 vp->status &= ~GETCELL;
1298 return(1);
1299}
1300
1301static int
1302checkname(cp)
1303register char *cp;
1304{
1305 if (!isalpha(*cp++))
1306 return(0);
1307 while (*cp)
1308 if (!isalnum(*cp++))
1309 return(0);
1310 return(1);
1311}
1312
1313static void
1314putvlist(f, out)
1315register int f, out;
1316{
1317 register struct var *vp;
1318
1319 for (vp = vlist; vp; vp = vp->next)
1320 if (vp->status & f && isalpha(*vp->name)) {
1321 if (vp->status & EXPORT)
1322 write(out, "export ", 7);
1323 if (vp->status & RONLY)
1324 write(out, "readonly ", 9);
1325 write(out, vp->name, (int)(findeq(vp->name) - vp->name));
1326 write(out, "\n", 1);
1327 }
1328}
1329
1330static int
1331eqname(n1, n2)
1332register char *n1, *n2;
1333{
1334 for (; *n1 != '=' && *n1 != 0; n1++)
1335 if (*n2++ != *n1)
1336 return(0);
1337 return(*n2 == 0 || *n2 == '=');
1338}
1339
1340static char *
1341findeq(cp)
1342register char *cp;
1343{
1344 while (*cp != '\0' && *cp != '=')
1345 cp++;
1346 return(cp);
1347}
1348
1349/* -------- gmatch.c -------- */
1350/*
1351 * int gmatch(string, pattern)
1352 * char *string, *pattern;
1353 *
1354 * Match a pattern as in sh(1).
1355 */
1356
1357#define CMASK 0377
1358#define QUOTE 0200
1359#define QMASK (CMASK&~QUOTE)
1360#define NOT '!' /* might use ^ */
1361
1362static int
1363gmatch(s, p)
1364register char *s, *p;
1365{
1366 register int sc, pc;
1367
1368 if (s == NULL || p == NULL)
1369 return(0);
1370 while ((pc = *p++ & CMASK) != '\0') {
1371 sc = *s++ & QMASK;
1372 switch (pc) {
1373 case '[':
1374 if ((p = cclass(p, sc)) == NULL)
1375 return(0);
1376 break;
1377
1378 case '?':
1379 if (sc == 0)
1380 return(0);
1381 break;
1382
1383 case '*':
1384 s--;
1385 do {
1386 if (*p == '\0' || gmatch(s, p))
1387 return(1);
1388 } while (*s++ != '\0');
1389 return(0);
1390
1391 default:
1392 if (sc != (pc&~QUOTE))
1393 return(0);
1394 }
1395 }
1396 return(*s == 0);
1397}
1398
1399static char *
1400cclass(p, sub)
1401register char *p;
1402register int sub;
1403{
1404 register int c, d, not, found;
1405
1406 if ((not = *p == NOT) != 0)
1407 p++;
1408 found = not;
1409 do {
1410 if (*p == '\0')
1411 return((char *)NULL);
1412 c = *p & CMASK;
1413 if (p[1] == '-' && p[2] != ']') {
1414 d = p[2] & CMASK;
1415 p++;
1416 } else
1417 d = c;
1418 if (c == sub || (c <= sub && sub <= d))
1419 found = !not;
1420 } while (*++p != ']');
1421 return(found? p+1: (char *)NULL);
1422}
1423
1424
1425/* -------- area.c -------- */
1426
1427/*
1428 * All memory between (char *)areabot and (char *)(areatop+1) is
1429 * exclusively administered by the area management routines.
1430 * It is assumed that sbrk() and brk() manipulate the high end.
1431 */
1432
1433#define sbrk(X) ({ void * __q = (void *)-1; if (brkaddr + (int)(X) < brktop) { __q = brkaddr; brkaddr+=(int)(X); } __q;})
1434
1435static void
1436initarea()
1437{
1438 brkaddr = malloc(65000);
1439 brktop = brkaddr + 65000;
1440
1441 while ((int)sbrk(0) & ALIGN)
1442 sbrk(1);
1443 areabot = (struct region *)sbrk(REGSIZE);
1444
1445 areabot->next = areabot;
1446 areabot->area = BUSY;
1447 areatop = areabot;
1448 areanxt = areabot;
1449}
1450
1451char *
1452getcell(nbytes)
1453unsigned nbytes;
1454{
1455 register int nregio;
1456 register struct region *p, *q;
1457 register int i;
1458
1459 if (nbytes == 0) {
1460 puts("getcell(0)");
1461 abort();
1462 } /* silly and defeats the algorithm */
1463 /*
1464 * round upwards and add administration area
1465 */
1466 nregio = (nbytes+(REGSIZE-1))/REGSIZE + 1;
1467 for (p = areanxt;;) {
1468 if (p->area > areanum) {
1469 /*
1470 * merge free cells
1471 */
1472 while ((q = p->next)->area > areanum && q != areanxt)
1473 p->next = q->next;
1474 /*
1475 * exit loop if cell big enough
1476 */
1477 if (q >= p + nregio)
1478 goto found;
1479 }
1480 p = p->next;
1481 if (p == areanxt)
1482 break;
1483 }
1484 i = nregio >= GROWBY ? nregio : GROWBY;
1485 p = (struct region *)sbrk(i * REGSIZE);
1486 if (p == (struct region *)-1)
1487 return((char *)NULL);
1488 p--;
1489 if (p != areatop) {
1490 puts("not contig");
1491 abort(); /* allocated areas are contiguous */
1492 }
1493 q = p + i;
1494 p->next = q;
1495 p->area = FREE;
1496 q->next = areabot;
1497 q->area = BUSY;
1498 areatop = q;
1499found:
1500 /*
1501 * we found a FREE area big enough, pointed to by 'p', and up to 'q'
1502 */
1503 areanxt = p + nregio;
1504 if (areanxt < q) {
1505 /*
1506 * split into requested area and rest
1507 */
1508 if (areanxt+1 > q) {
1509 puts("OOM");
1510 abort(); /* insufficient space left for admin */
1511 }
1512 areanxt->next = q;
1513 areanxt->area = FREE;
1514 p->next = areanxt;
1515 }
1516 p->area = areanum;
1517 return((char *)(p+1));
1518}
1519
1520static void
1521freecell(cp)
1522char *cp;
1523{
1524 register struct region *p;
1525
1526 if ((p = (struct region *)cp) != NULL) {
1527 p--;
1528 if (p < areanxt)
1529 areanxt = p;
1530 p->area = FREE;
1531 }
1532}
1533
1534static void
1535freearea(a)
1536register int a;
1537{
1538 register struct region *p, *top;
1539
1540 top = areatop;
1541 for (p = areabot; p != top; p = p->next)
1542 if (p->area >= a)
1543 p->area = FREE;
1544}
1545
1546static void
1547setarea(cp,a)
1548char *cp;
1549int a;
1550{
1551 register struct region *p;
1552
1553 if ((p = (struct region *)cp) != NULL)
1554 (p-1)->area = a;
1555}
1556
1557int
1558getarea(cp)
1559char *cp;
1560{
1561 return ((struct region*)cp-1)->area;
1562}
1563
1564static void
1565garbage()
1566{
1567 register struct region *p, *q, *top;
1568
1569 top = areatop;
1570 for (p = areabot; p != top; p = p->next) {
1571 if (p->area > areanum) {
1572 while ((q = p->next)->area > areanum)
1573 p->next = q->next;
1574 areanxt = p;
1575 }
1576 }
1577#ifdef SHRINKBY
1578 if (areatop >= q + SHRINKBY && q->area > areanum) {
1579 brk((char *)(q+1));
1580 q->next = areabot;
1581 q->area = BUSY;
1582 areatop = q;
1583 }
1584#endif
1585}
1586
1587/* -------- csyn.c -------- */
1588/*
1589 * shell: syntax (C version)
1590 */
1591
1592
1593int
1594yyparse()
1595{
1596 startl = 1;
1597 peeksym = 0;
1598 yynerrs = 0;
1599 outtree = c_list();
1600 musthave('\n', 0);
1601 return(yynerrs!=0);
1602}
1603
1604static struct op *
1605pipeline(cf)
1606int cf;
1607{
1608 register struct op *t, *p;
1609 register int c;
1610
1611 t = command(cf);
1612 if (t != NULL) {
1613 while ((c = yylex(0)) == '|') {
1614 if ((p = command(CONTIN)) == NULL)
1615 SYNTAXERR;
1616 if (t->type != TPAREN && t->type != TCOM) {
1617 /* shell statement */
1618 t = block(TPAREN, t, NOBLOCK, NOWORDS);
1619 }
1620 t = block(TPIPE, t, p, NOWORDS);
1621 }
1622 peeksym = c;
1623 }
1624 return(t);
1625}
1626
1627static struct op *
1628andor()
1629{
1630 register struct op *t, *p;
1631 register int c;
1632
1633 t = pipeline(0);
1634 if (t != NULL) {
1635 while ((c = yylex(0)) == LOGAND || c == LOGOR) {
1636 if ((p = pipeline(CONTIN)) == NULL)
1637 SYNTAXERR;
1638 t = block(c == LOGAND? TAND: TOR, t, p, NOWORDS);
1639 }
1640 peeksym = c;
1641 }
1642 return(t);
1643}
1644
1645static struct op *
1646c_list()
1647{
1648 register struct op *t, *p;
1649 register int c;
1650
1651 t = andor();
1652 if (t != NULL) {
1653 if((peeksym = yylex(0)) == '&')
1654 t = block(TASYNC, t, NOBLOCK, NOWORDS);
1655 while ((c = yylex(0)) == ';' || c == '&' || (multiline && c == '\n')) {
1656 if ((p = andor()) == NULL)
1657 return(t);
1658 if((peeksym = yylex(0)) == '&')
1659 p = block(TASYNC, p, NOBLOCK, NOWORDS);
1660 t = list(t, p);
1661 }
1662 peeksym = c;
1663 }
1664 return(t);
1665}
1666
1667
1668static int
1669synio(cf)
1670int cf;
1671{
1672 register struct ioword *iop;
1673 register int i;
1674 register int c;
1675
1676 if ((c = yylex(cf)) != '<' && c != '>') {
1677 peeksym = c;
1678 return(0);
1679 }
1680 i = yylval.i;
1681 musthave(WORD, 0);
1682 iop = io(iounit, i, yylval.cp);
1683 iounit = IODEFAULT;
1684 if (i & IOHERE)
1685 markhere(yylval.cp, iop);
1686 return(1);
1687}
1688
1689static void
1690musthave(c, cf)
1691int c, cf;
1692{
1693 if ((peeksym = yylex(cf)) != c)
1694 SYNTAXERR;
1695 peeksym = 0;
1696}
1697
1698static struct op *
1699simple()
1700{
1701 register struct op *t;
1702
1703 t = NULL;
1704 for (;;) {
1705 switch (peeksym = yylex(0)) {
1706 case '<':
1707 case '>':
1708 (void) synio(0);
1709 break;
1710
1711 case WORD:
1712 if (t == NULL) {
1713 t = newtp();
1714 t->type = TCOM;
1715 }
1716 peeksym = 0;
1717 word(yylval.cp);
1718 break;
1719
1720 default:
1721 return(t);
1722 }
1723 }
1724}
1725
1726static struct op *
1727nested(type, mark)
1728int type, mark;
1729{
1730 register struct op *t;
1731
1732 multiline++;
1733 t = c_list();
1734 musthave(mark, 0);
1735 multiline--;
1736 return(block(type, t, NOBLOCK, NOWORDS));
1737}
1738
1739static struct op *
1740command(cf)
1741int cf;
1742{
1743 register struct op *t;
1744 struct wdblock *iosave;
1745 register int c;
1746
1747 iosave = iolist;
1748 iolist = NULL;
1749 if (multiline)
1750 cf |= CONTIN;
1751 while (synio(cf))
1752 cf = 0;
1753 switch (c = yylex(cf)) {
1754 default:
1755 peeksym = c;
1756 if ((t = simple()) == NULL) {
1757 if (iolist == NULL)
1758 return((struct op *)NULL);
1759 t = newtp();
1760 t->type = TCOM;
1761 }
1762 break;
1763
1764 case '(':
1765 t = nested(TPAREN, ')');
1766 break;
1767
1768 case '{':
1769 t = nested(TBRACE, '}');
1770 break;
1771
1772 case FOR:
1773 t = newtp();
1774 t->type = TFOR;
1775 musthave(WORD, 0);
1776 startl = 1;
1777 t->str = yylval.cp;
1778 multiline++;
1779 t->words = wordlist();
1780 if ((c = yylex(0)) != '\n' && c != ';')
1781 peeksym = c;
1782 t->left = dogroup(0);
1783 multiline--;
1784 break;
1785
1786 case WHILE:
1787 case UNTIL:
1788 multiline++;
1789 t = newtp();
1790 t->type = c == WHILE? TWHILE: TUNTIL;
1791 t->left = c_list();
1792 t->right = dogroup(1);
1793 t->words = NULL;
1794 multiline--;
1795 break;
1796
1797 case CASE:
1798 t = newtp();
1799 t->type = TCASE;
1800 musthave(WORD, 0);
1801 t->str = yylval.cp;
1802 startl++;
1803 multiline++;
1804 musthave(IN, CONTIN);
1805 startl++;
1806 t->left = caselist();
1807 musthave(ESAC, 0);
1808 multiline--;
1809 break;
1810
1811 case IF:
1812 multiline++;
1813 t = newtp();
1814 t->type = TIF;
1815 t->left = c_list();
1816 t->right = thenpart();
1817 musthave(FI, 0);
1818 multiline--;
1819 break;
1820 }
1821 while (synio(0))
1822 ;
1823 t = namelist(t);
1824 iolist = iosave;
1825 return(t);
1826}
1827
1828static struct op *
1829dogroup(onlydone)
1830int onlydone;
1831{
1832 register int c;
1833 register struct op *mylist;
1834
1835 c = yylex(CONTIN);
1836 if (c == DONE && onlydone)
1837 return((struct op *)NULL);
1838 if (c != DO)
1839 SYNTAXERR;
1840 mylist = c_list();
1841 musthave(DONE, 0);
1842 return(mylist);
1843}
1844
1845static struct op *
1846thenpart()
1847{
1848 register int c;
1849 register struct op *t;
1850
1851 if ((c = yylex(0)) != THEN) {
1852 peeksym = c;
1853 return((struct op *)NULL);
1854 }
1855 t = newtp();
1856 t->type = 0;
1857 t->left = c_list();
1858 if (t->left == NULL)
1859 SYNTAXERR;
1860 t->right = elsepart();
1861 return(t);
1862}
1863
1864static struct op *
1865elsepart()
1866{
1867 register int c;
1868 register struct op *t;
1869
1870 switch (c = yylex(0)) {
1871 case ELSE:
1872 if ((t = c_list()) == NULL)
1873 SYNTAXERR;
1874 return(t);
1875
1876 case ELIF:
1877 t = newtp();
1878 t->type = TELIF;
1879 t->left = c_list();
1880 t->right = thenpart();
1881 return(t);
1882
1883 default:
1884 peeksym = c;
1885 return((struct op *)NULL);
1886 }
1887}
1888
1889static struct op *
1890caselist()
1891{
1892 register struct op *t;
1893
1894 t = NULL;
1895 while ((peeksym = yylex(CONTIN)) != ESAC)
1896 t = list(t, casepart());
1897 return(t);
1898}
1899
1900static struct op *
1901casepart()
1902{
1903 register struct op *t;
1904
1905 t = newtp();
1906 t->type = TPAT;
1907 t->words = pattern();
1908 musthave(')', 0);
1909 t->left = c_list();
1910 if ((peeksym = yylex(CONTIN)) != ESAC)
1911 musthave(BREAK, CONTIN);
1912 return(t);
1913}
1914
1915static char **
1916pattern()
1917{
1918 register int c, cf;
1919
1920 cf = CONTIN;
1921 do {
1922 musthave(WORD, cf);
1923 word(yylval.cp);
1924 cf = 0;
1925 } while ((c = yylex(0)) == '|');
1926 peeksym = c;
1927 word(NOWORD);
1928 return(copyw());
1929}
1930
1931static char **
1932wordlist()
1933{
1934 register int c;
1935
1936 if ((c = yylex(0)) != IN) {
1937 peeksym = c;
1938 return((char **)NULL);
1939 }
1940 startl = 0;
1941 while ((c = yylex(0)) == WORD)
1942 word(yylval.cp);
1943 word(NOWORD);
1944 peeksym = c;
1945 return(copyw());
1946}
1947
1948/*
1949 * supporting functions
1950 */
1951static struct op *
1952list(t1, t2)
1953register struct op *t1, *t2;
1954{
1955 if (t1 == NULL)
1956 return(t2);
1957 if (t2 == NULL)
1958 return(t1);
1959 return(block(TLIST, t1, t2, NOWORDS));
1960}
1961
1962static struct op *
1963block(type, t1, t2, wp)
1964int type;
1965struct op *t1, *t2;
1966char **wp;
1967{
1968 register struct op *t;
1969
1970 t = newtp();
1971 t->type = type;
1972 t->left = t1;
1973 t->right = t2;
1974 t->words = wp;
1975 return(t);
1976}
1977
1978static int
1979rlookup(n)
1980register char *n;
1981{
1982 register struct res *rp;
1983
1984 for (rp = restab; rp->r_name; rp++)
1985 if (strcmp(rp->r_name, n) == 0)
1986 return(rp->r_val);
1987 return(0);
1988}
1989
1990static struct op *
1991newtp()
1992{
1993 register struct op *t;
1994
1995 t = (struct op *)tree(sizeof(*t));
1996 t->type = 0;
1997 t->words = NULL;
1998 t->ioact = NULL;
1999 t->left = NULL;
2000 t->right = NULL;
2001 t->str = NULL;
2002 return(t);
2003}
2004
2005static struct op *
2006namelist(t)
2007register struct op *t;
2008{
2009 if (iolist) {
2010 iolist = addword((char *)NULL, iolist);
2011 t->ioact = copyio();
2012 } else
2013 t->ioact = NULL;
2014 if (t->type != TCOM) {
2015 if (t->type != TPAREN && t->ioact != NULL) {
2016 t = block(TPAREN, t, NOBLOCK, NOWORDS);
2017 t->ioact = t->left->ioact;
2018 t->left->ioact = NULL;
2019 }
2020 return(t);
2021 }
2022 word(NOWORD);
2023 t->words = copyw();
2024 return(t);
2025}
2026
2027static char **
2028copyw()
2029{
2030 register char **wd;
2031
2032 wd = getwords(wdlist);
2033 wdlist = 0;
2034 return(wd);
2035}
2036
2037static void
2038word(cp)
2039char *cp;
2040{
2041 wdlist = addword(cp, wdlist);
2042}
2043
2044static struct ioword **
2045copyio()
2046{
2047 register struct ioword **iop;
2048
2049 iop = (struct ioword **) getwords(iolist);
2050 iolist = 0;
2051 return(iop);
2052}
2053
2054static struct ioword *
2055io(u, f, cp)
2056int u;
2057int f;
2058char *cp;
2059{
2060 register struct ioword *iop;
2061
2062 iop = (struct ioword *) tree(sizeof(*iop));
2063 iop->io_unit = u;
2064 iop->io_flag = f;
2065 iop->io_name = cp;
2066 iolist = addword((char *)iop, iolist);
2067 return(iop);
2068}
2069
2070static void
2071zzerr()
2072{
2073 yyerror("syntax error");
2074}
2075
2076static void
2077yyerror(s)
2078char *s;
2079{
2080 yynerrs++;
2081 if (interactive && e.iop <= iostack) {
2082 multiline = 0;
2083 while (eofc() == 0 && yylex(0) != '\n')
2084 ;
2085 }
2086 err(s);
2087 fail();
2088}
2089
2090static int
2091yylex(cf)
2092int cf;
2093{
2094 register int c, c1;
2095 int atstart;
2096
2097 if ((c = peeksym) > 0) {
2098 peeksym = 0;
2099 if (c == '\n')
2100 startl = 1;
2101 return(c);
2102 }
2103 nlseen = 0;
2104 e.linep = line;
2105 atstart = startl;
2106 startl = 0;
2107 yylval.i = 0;
2108
2109loop:
2110 while ((c = my_getc(0)) == ' ' || c == '\t')
2111 ;
2112 switch (c) {
2113 default:
2114 if (any(c, "0123456789")) {
2115 unget(c1 = my_getc(0));
2116 if (c1 == '<' || c1 == '>') {
2117 iounit = c - '0';
2118 goto loop;
2119 }
2120 *e.linep++ = c;
2121 c = c1;
2122 }
2123 break;
2124
2125 case '#':
2126 while ((c = my_getc(0)) != 0 && c != '\n')
2127 ;
2128 unget(c);
2129 goto loop;
2130
2131 case 0:
2132 return(c);
2133
2134 case '$':
2135 *e.linep++ = c;
2136 if ((c = my_getc(0)) == '{') {
2137 if ((c = collect(c, '}')) != '\0')
2138 return(c);
2139 goto pack;
2140 }
2141 break;
2142
2143 case '`':
2144 case '\'':
2145 case '"':
2146 if ((c = collect(c, c)) != '\0')
2147 return(c);
2148 goto pack;
2149
2150 case '|':
2151 case '&':
2152 case ';':
2153 if ((c1 = dual(c)) != '\0') {
2154 startl = 1;
2155 return(c1);
2156 }
2157 startl = 1;
2158 return(c);
2159 case '^':
2160 startl = 1;
2161 return('|');
2162 case '>':
2163 case '<':
2164 diag(c);
2165 return(c);
2166
2167 case '\n':
2168 nlseen++;
2169 gethere();
2170 startl = 1;
2171 if (multiline || cf & CONTIN) {
2172 if (interactive && e.iop <= iostack) {
2173#ifdef BB_FEATURE_COMMAND_EDITING
2174 current_prompt=cprompt->value;
2175#else
2176 prs(cprompt->value);
2177#endif
2178 }
2179 if (cf & CONTIN)
2180 goto loop;
2181 }
2182 return(c);
2183
2184 case '(':
2185 case ')':
2186 startl = 1;
2187 return(c);
2188 }
2189
2190 unget(c);
2191
2192pack:
2193 while ((c = my_getc(0)) != 0 && !any(c, "`$ '\"\t;&<>()|^\n"))
2194 if (e.linep >= elinep)
2195 err("word too long");
2196 else
2197 *e.linep++ = c;
2198 unget(c);
2199 if(any(c, "\"'`$"))
2200 goto loop;
2201 *e.linep++ = '\0';
2202 if (atstart && (c = rlookup(line))!=0) {
2203 startl = 1;
2204 return(c);
2205 }
2206 yylval.cp = strsave(line, areanum);
2207 return(WORD);
2208}
2209
2210static int
2211collect(c, c1)
2212register int c, c1;
2213{
2214 char s[2];
2215
2216 *e.linep++ = c;
2217 while ((c = my_getc(c1)) != c1) {
2218 if (c == 0) {
2219 unget(c);
2220 s[0] = c1;
2221 s[1] = 0;
2222 prs("no closing "); yyerror(s);
2223 return(YYERRCODE);
2224 }
2225 if (interactive && c == '\n' && e.iop <= iostack) {
2226#ifdef BB_FEATURE_COMMAND_EDITING
2227 current_prompt=cprompt->value;
2228#else
2229 prs(cprompt->value);
2230#endif
2231 }
2232 *e.linep++ = c;
2233 }
2234 *e.linep++ = c;
2235 return(0);
2236}
2237
2238static int
2239dual(c)
2240register int c;
2241{
2242 char s[3];
2243 register char *cp = s;
2244
2245 *cp++ = c;
2246 *cp++ = my_getc(0);
2247 *cp = 0;
2248 if ((c = rlookup(s)) == 0)
2249 unget(*--cp);
2250 return(c);
2251}
2252
2253static void
2254diag(ec)
2255register int ec;
2256{
2257 register int c;
2258
2259 c = my_getc(0);
2260 if (c == '>' || c == '<') {
2261 if (c != ec)
2262 zzerr();
2263 yylval.i = ec == '>'? IOWRITE|IOCAT: IOHERE;
2264 c = my_getc(0);
2265 } else
2266 yylval.i = ec == '>'? IOWRITE: IOREAD;
2267 if (c != '&' || yylval.i == IOHERE)
2268 unget(c);
2269 else
2270 yylval.i |= IODUP;
2271}
2272
2273static char *
2274tree(size)
2275unsigned size;
2276{
2277 register char *t;
2278
2279 if ((t = getcell(size)) == NULL) {
2280 prs("command line too complicated\n");
2281 fail();
2282 /* NOTREACHED */
2283 }
2284 return(t);
2285}
2286
2287/* VARARGS1 */
2288/* ARGSUSED */
2289
2290/* -------- exec.c -------- */
2291
2292/*
2293 * execute tree
2294 */
2295
2296
2297static int
2298execute(t, pin, pout, act)
2299register struct op *t;
2300int *pin, *pout;
2301int act;
2302{
2303 register struct op *t1;
2304 volatile int i, rv, a;
2305 char *cp, **wp, **wp2;
2306 struct var *vp;
2307 struct brkcon bc;
2308
2309#if __GNUC__
2310 /* Avoid longjmp clobbering */
2311 (void) &wp;
2312#endif
2313
2314
2315 if (t == NULL)
2316 return(0);
2317 rv = 0;
2318 a = areanum++;
2319 wp = (wp2 = t->words) != NULL
2320 ? eval(wp2, t->type == TCOM ? DOALL : DOALL & ~DOKEY)
2321 : NULL;
2322
2323 switch(t->type) {
2324 case TPAREN:
2325 case TCOM:
Eric Andersen1c039232001-07-07 00:05:55 +00002326 {
2327 int child;
2328 rv = forkexec(t, pin, pout, act, wp, &child);
2329 if (child) {
2330 exstat = rv;
2331 leave();
2332 }
Eric Andersenff9eee42001-06-29 04:57:14 +00002333 }
Eric Andersenff9eee42001-06-29 04:57:14 +00002334 break;
2335
2336 case TPIPE:
2337 {
2338 int pv[2];
2339 if ((rv = openpipe(pv)) < 0)
2340 break;
2341 pv[0] = remap(pv[0]);
2342 pv[1] = remap(pv[1]);
2343 (void) execute(t->left, pin, pv, 0);
2344 rv = execute(t->right, pv, pout, 0);
2345 }
2346 break;
2347
2348 case TLIST:
2349 (void) execute(t->left, pin, pout, 0);
2350 rv = execute(t->right, pin, pout, 0);
2351 break;
2352
2353 case TASYNC:
2354 {
2355 int hinteractive = interactive;
2356
2357 i = vfork();
2358 if (i != 0) {
2359 interactive = hinteractive;
2360 if (i != -1) {
2361 setval(lookup("!"), putn(i));
2362 if (pin != NULL)
2363 closepipe(pin);
2364 if (interactive) {
2365 prs(putn(i));
2366 prs("\n");
2367 }
2368 } else
2369 rv = -1;
2370 setstatus(rv);
2371 } else {
2372 signal(SIGINT, SIG_IGN);
2373 signal(SIGQUIT, SIG_IGN);
2374 if (interactive)
2375 signal(SIGTERM, SIG_DFL);
2376 interactive = 0;
2377 if (pin == NULL) {
2378 close(0);
2379 open("/dev/null", 0);
2380 }
2381 exit(execute(t->left, pin, pout, FEXEC));
2382 }
2383 }
2384 break;
2385
2386 case TOR:
2387 case TAND:
2388 rv = execute(t->left, pin, pout, 0);
2389 if ((t1 = t->right)!=NULL && (rv == 0) == (t->type == TAND))
2390 rv = execute(t1, pin, pout, 0);
2391 break;
2392
2393 case TFOR:
2394 if (wp == NULL) {
2395 wp = dolv+1;
2396 if ((i = dolc) < 0)
2397 i = 0;
2398 } else {
2399 i = -1;
2400 while (*wp++ != NULL)
2401 ;
2402 }
2403 vp = lookup(t->str);
2404 while (setjmp(bc.brkpt))
2405 if (isbreak)
2406 goto broken;
2407 brkset(&bc);
2408 for (t1 = t->left; i-- && *wp != NULL;) {
2409 setval(vp, *wp++);
2410 rv = execute(t1, pin, pout, 0);
2411 }
2412 brklist = brklist->nextlev;
2413 break;
2414
2415 case TWHILE:
2416 case TUNTIL:
2417 while (setjmp(bc.brkpt))
2418 if (isbreak)
2419 goto broken;
2420 brkset(&bc);
2421 t1 = t->left;
2422 while ((execute(t1, pin, pout, 0) == 0) == (t->type == TWHILE))
2423 rv = execute(t->right, pin, pout, 0);
2424 brklist = brklist->nextlev;
2425 break;
2426
2427 case TIF:
2428 case TELIF:
2429 if (t->right != NULL) {
2430 rv = !execute(t->left, pin, pout, 0) ?
2431 execute(t->right->left, pin, pout, 0):
2432 execute(t->right->right, pin, pout, 0);
2433 }
2434 break;
2435
2436 case TCASE:
2437 if ((cp = evalstr(t->str, DOSUB|DOTRIM)) == 0)
2438 cp = "";
2439 if ((t1 = findcase(t->left, cp)) != NULL)
2440 rv = execute(t1, pin, pout, 0);
2441 break;
2442
2443 case TBRACE:
2444/*
2445 if (iopp = t->ioact)
2446 while (*iopp)
2447 if (iosetup(*iopp++, pin!=NULL, pout!=NULL)) {
2448 rv = -1;
2449 break;
2450 }
2451*/
2452 if (rv >= 0 && (t1 = t->left))
2453 rv = execute(t1, pin, pout, 0);
2454 break;
2455 }
2456
2457broken:
2458 t->words = wp2;
2459 isbreak = 0;
2460 freehere(areanum);
2461 freearea(areanum);
2462 areanum = a;
2463 if (interactive && intr) {
2464 closeall();
2465 fail();
2466 }
2467 if ((i = trapset) != 0) {
2468 trapset = 0;
2469 runtrap(i);
2470 }
2471 return(rv);
2472}
2473
2474static int
2475forkexec( register struct op *t, int *pin, int *pout, int act, char **wp, int *pforked)
2476{
2477 int i, rv;
2478 int (*shcom)() = NULL;
2479 register int f;
2480 char *cp = NULL;
2481 struct ioword **iopp;
2482 int resetsig;
2483 char **owp;
2484
2485 int *hpin = pin;
2486 int *hpout = pout;
2487 int hforked;
2488 char *hwp;
2489 int hinteractive;
2490 int hintr;
2491 struct brkcon * hbrklist;
2492 int hexecflg;
2493
2494#if __GNUC__
2495 /* Avoid longjmp clobbering */
2496 (void) &pin;
2497 (void) &pout;
2498 (void) &wp;
2499 (void) &shcom;
2500 (void) &cp;
2501 (void) &resetsig;
2502 (void) &owp;
2503#endif
2504
2505 owp = wp;
2506 resetsig = 0;
2507 *pforked = 0;
2508 rv = -1; /* system-detected error */
2509 if (t->type == TCOM) {
2510 while ((cp = *wp++) != NULL)
2511 ;
2512 cp = *wp;
2513
2514 /* strip all initial assignments */
2515 /* not correct wrt PATH=yyy command etc */
2516 if (flag['x'])
2517 echo (cp ? wp: owp);
2518 if (cp == NULL && t->ioact == NULL) {
2519 while ((cp = *owp++) != NULL && assign(cp, COPYV))
2520 ;
2521 return(setstatus(0));
2522 }
2523 else if (cp != NULL)
2524 shcom = inbuilt(cp);
2525 }
2526 t->words = wp;
2527 f = act;
2528 if (shcom == NULL && (f & FEXEC) == 0) {
2529
2530 hpin = pin;
2531 hpout = pout;
2532 hforked = *pforked;
2533 hwp = *wp;
2534 hinteractive = interactive;
2535 hintr = intr;
2536 hbrklist = brklist;
2537 hexecflg = execflg;
2538
2539 i = vfork();
2540 if (i != 0) {
2541 /* who wrote this crappy non vfork safe shit? */
2542 pin = hpin;
2543 pout = hpout;
2544 *pforked = hforked;
2545 *wp = hwp;
2546 interactive = hinteractive;
2547 intr = hintr;
2548 brklist = hbrklist;
2549 execflg = hexecflg;
2550
2551 *pforked = 0;
2552 if (i == -1)
2553 return(rv);
2554 if (pin != NULL)
2555 closepipe(pin);
2556 return(pout==NULL? setstatus(waitfor(i,0)): 0);
2557 }
2558
2559 if (interactive) {
2560 signal(SIGINT, SIG_IGN);
2561 signal(SIGQUIT, SIG_IGN);
2562 resetsig = 1;
2563 }
2564 interactive = 0;
2565 intr = 0;
2566 (*pforked)++;
2567 brklist = 0;
2568 execflg = 0;
2569 }
2570 if (owp != NULL)
2571 while ((cp = *owp++) != NULL && assign(cp, COPYV))
2572 if (shcom == NULL)
2573 export(lookup(cp));
2574#ifdef COMPIPE
2575 if ((pin != NULL || pout != NULL) && shcom != NULL && shcom != doexec) {
2576 err("piping to/from shell builtins not yet done");
2577 return(-1);
2578 }
2579#endif
2580 if (pin != NULL) {
2581 dup2(pin[0], 0);
2582 closepipe(pin);
2583 }
2584 if (pout != NULL) {
2585 dup2(pout[1], 1);
2586 closepipe(pout);
2587 }
2588 if ((iopp = t->ioact) != NULL) {
2589 if (shcom != NULL && shcom != doexec) {
2590 prs(cp);
2591 err(": cannot redirect shell command");
2592 return(-1);
2593 }
2594 while (*iopp)
2595 if (iosetup(*iopp++, pin!=NULL, pout!=NULL))
2596 return(rv);
2597 }
2598 if (shcom)
2599 return(setstatus((*shcom)(t)));
2600 /* should use FIOCEXCL */
2601 for (i=FDBASE; i<NOFILE; i++)
2602 close(i);
2603 if (resetsig) {
2604 signal(SIGINT, SIG_DFL);
2605 signal(SIGQUIT, SIG_DFL);
2606 }
2607 if (t->type == TPAREN)
2608 exit(execute(t->left, NOPIPE, NOPIPE, FEXEC));
2609 if (wp[0] == NULL)
2610 exit(0);
2611
2612 cp = rexecve(wp[0], wp, makenv());
2613 prs(wp[0]); prs(": "); warn(cp);
2614 if (!execflg)
2615 trap[0] = NULL;
2616 leave();
2617 /* NOTREACHED */
2618 exit(1);
2619}
2620
2621/*
2622 * 0< 1> are ignored as required
2623 * within pipelines.
2624 */
2625static int
2626iosetup(iop, pipein, pipeout)
2627register struct ioword *iop;
2628int pipein, pipeout;
2629{
2630 register int u = -1;
2631 char *cp=NULL, *msg;
2632
2633 if (iop->io_unit == IODEFAULT) /* take default */
2634 iop->io_unit = iop->io_flag&(IOREAD|IOHERE)? 0: 1;
2635 if (pipein && iop->io_unit == 0)
2636 return(0);
2637 if (pipeout && iop->io_unit == 1)
2638 return(0);
2639 msg = iop->io_flag&(IOREAD|IOHERE)? "open": "create";
2640 if ((iop->io_flag & IOHERE) == 0) {
2641 cp = iop->io_name;
2642 if ((cp = evalstr(cp, DOSUB|DOTRIM)) == NULL)
2643 return(1);
2644 }
2645 if (iop->io_flag & IODUP) {
2646 if (cp[1] || (!isdigit(*cp) && *cp != '-')) {
2647 prs(cp);
2648 err(": illegal >& argument");
2649 return(1);
2650 }
2651 if (*cp == '-')
2652 iop->io_flag = IOCLOSE;
2653 iop->io_flag &= ~(IOREAD|IOWRITE);
2654 }
2655 switch (iop->io_flag) {
2656 case IOREAD:
2657 u = open(cp, 0);
2658 break;
2659
2660 case IOHERE:
2661 case IOHERE|IOXHERE:
2662 u = herein(iop->io_name, iop->io_flag&IOXHERE);
2663 cp = "here file";
2664 break;
2665
2666 case IOWRITE|IOCAT:
2667 if ((u = open(cp, 1)) >= 0) {
2668 lseek(u, (long)0, 2);
2669 break;
2670 }
2671 case IOWRITE:
2672 u = creat(cp, 0666);
2673 break;
2674
2675 case IODUP:
2676 u = dup2(*cp-'0', iop->io_unit);
2677 break;
2678
2679 case IOCLOSE:
2680 close(iop->io_unit);
2681 return(0);
2682 }
2683 if (u < 0) {
2684 prs(cp);
2685 prs(": cannot ");
2686 warn(msg);
2687 return(1);
2688 } else {
2689 if (u != iop->io_unit) {
2690 dup2(u, iop->io_unit);
2691 close(u);
2692 }
2693 }
2694 return(0);
2695}
2696
2697static void
2698echo(wp)
2699register char **wp;
2700{
2701 register int i;
2702
2703 prs("+");
2704 for (i=0; wp[i]; i++) {
2705 if (i)
2706 prs(" ");
2707 prs(wp[i]);
2708 }
2709 prs("\n");
2710}
2711
2712static struct op **
2713find1case(t, w)
2714struct op *t;
2715char *w;
2716{
2717 register struct op *t1;
2718 struct op **tp;
2719 register char **wp, *cp;
2720
2721 if (t == NULL)
2722 return((struct op **)NULL);
2723 if (t->type == TLIST) {
2724 if ((tp = find1case(t->left, w)) != NULL)
2725 return(tp);
2726 t1 = t->right; /* TPAT */
2727 } else
2728 t1 = t;
2729 for (wp = t1->words; *wp;)
2730 if ((cp = evalstr(*wp++, DOSUB)) && gmatch(w, cp))
2731 return(&t1->left);
2732 return((struct op **)NULL);
2733}
2734
2735static struct op *
2736findcase(t, w)
2737struct op *t;
2738char *w;
2739{
2740 register struct op **tp;
2741
2742 return((tp = find1case(t, w)) != NULL? *tp: (struct op *)NULL);
2743}
2744
2745/*
2746 * Enter a new loop level (marked for break/continue).
2747 */
2748static void
2749brkset(bc)
2750struct brkcon *bc;
2751{
2752 bc->nextlev = brklist;
2753 brklist = bc;
2754}
2755
2756/*
2757 * Wait for the last process created.
2758 * Print a message for each process found
2759 * that was killed by a signal.
2760 * Ignore interrupt signals while waiting
2761 * unless `canintr' is true.
2762 */
2763static int
2764waitfor(lastpid, canintr)
2765register int lastpid;
2766int canintr;
2767{
2768 register int pid, rv;
2769 int s;
2770 int oheedint = heedint;
2771
2772 heedint = 0;
2773 rv = 0;
2774 do {
2775 pid = wait(&s);
2776 if (pid == -1) {
2777 if (errno != EINTR || canintr)
2778 break;
2779 } else {
2780 if ((rv = WAITSIG(s)) != 0) {
2781 if (rv < NSIGNAL) {
2782 if (signame[rv] != NULL) {
2783 if (pid != lastpid) {
2784 prn(pid);
2785 prs(": ");
2786 }
2787 prs(signame[rv]);
2788 }
2789 } else {
2790 if (pid != lastpid) {
2791 prn(pid);
2792 prs(": ");
2793 }
2794 prs("Signal "); prn(rv); prs(" ");
2795 }
2796 if (WAITCORE(s))
2797 prs(" - core dumped");
2798 if (rv >= NSIGNAL || signame[rv])
2799 prs("\n");
2800 rv = -1;
2801 } else
2802 rv = WAITVAL(s);
2803 }
2804 } while (pid != lastpid);
2805 heedint = oheedint;
2806 if (intr) {
2807 if (interactive) {
2808 if (canintr)
2809 intr = 0;
2810 } else {
2811 if (exstat == 0) exstat = rv;
2812 onintr(0);
2813 }
2814 }
2815 return(rv);
2816}
2817
2818static int
2819setstatus(s)
2820register int s;
2821{
2822 exstat = s;
2823 setval(lookup("?"), putn(s));
2824 return(s);
2825}
2826
2827/*
2828 * PATH-searching interface to execve.
2829 * If getenv("PATH") were kept up-to-date,
2830 * execvp might be used.
2831 */
2832static char *
2833rexecve(c, v, envp)
2834char *c, **v, **envp;
2835{
2836 register int i;
2837 register char *sp, *tp;
2838 int eacces = 0, asis = 0;
2839
Eric Andersen1c039232001-07-07 00:05:55 +00002840#ifdef BB_FEATURE_SH_STANDALONE_SHELL
2841 char *name = c;
2842#ifdef BB_FEATURE_SH_APPLETS_ALWAYS_WIN
2843 name = get_last_path_component(name);
2844#endif
2845 optind = 1;
2846 if (find_applet_by_name(name)) {
2847 /* We have to exec here since we vforked. Running
2848 * run_applet_by_name() won't work and bad things
2849 * will happen. */
2850 execve("/proc/self/exe", v, envp);
2851 execve("busybox", v, envp);
2852 }
2853#endif
2854
Eric Andersenff9eee42001-06-29 04:57:14 +00002855 sp = any('/', c)? "": path->value;
2856 asis = *sp == '\0';
2857 while (asis || *sp != '\0') {
2858 asis = 0;
2859 tp = e.linep;
2860 for (; *sp != '\0'; tp++)
2861 if ((*tp = *sp++) == ':') {
2862 asis = *sp == '\0';
2863 break;
2864 }
2865 if (tp != e.linep)
2866 *tp++ = '/';
2867 for (i = 0; (*tp++ = c[i++]) != '\0';)
2868 ;
Eric Andersen1c039232001-07-07 00:05:55 +00002869
Eric Andersenff9eee42001-06-29 04:57:14 +00002870 execve(e.linep, v, envp);
2871 switch (errno) {
2872 case ENOEXEC:
2873 *v = e.linep;
2874 tp = *--v;
2875 *v = e.linep;
2876 execve("/bin/sh", v, envp);
2877 *v = tp;
2878 return("no Shell");
2879
2880 case ENOMEM:
2881 return("program too big");
2882
2883 case E2BIG:
2884 return("argument list too long");
2885
2886 case EACCES:
2887 eacces++;
2888 break;
2889 }
2890 }
2891 return(errno==ENOENT ? "not found" : "cannot execute");
2892}
2893
2894/*
2895 * Run the command produced by generator `f'
2896 * applied to stream `arg'.
2897 */
2898static int
2899run(argp, f)
2900struct ioarg *argp;
2901int (*f)();
2902{
2903 struct op *otree;
2904 struct wdblock *swdlist;
2905 struct wdblock *siolist;
2906 jmp_buf ev, rt;
2907 xint *ofail;
2908 int rv;
2909
2910#if __GNUC__
2911 /* Avoid longjmp clobbering */
2912 (void) &rv;
2913#endif
2914
2915 areanum++;
2916 swdlist = wdlist;
2917 siolist = iolist;
2918 otree = outtree;
2919 ofail = failpt;
2920 rv = -1;
2921 if (newenv(setjmp(errpt = ev)) == 0) {
2922 wdlist = 0;
2923 iolist = 0;
2924 pushio(argp, f);
2925 e.iobase = e.iop;
2926 yynerrs = 0;
2927 if (setjmp(failpt = rt) == 0 && yyparse() == 0)
2928 rv = execute(outtree, NOPIPE, NOPIPE, 0);
2929 quitenv();
2930 }
2931 wdlist = swdlist;
2932 iolist = siolist;
2933 failpt = ofail;
2934 outtree = otree;
2935 freearea(areanum--);
2936 return(rv);
2937}
2938
2939/* -------- do.c -------- */
2940
2941/*
2942 * built-in commands: doX
2943 */
2944
Eric Andersen1c039232001-07-07 00:05:55 +00002945static int dohelp()
2946{
2947 int col;
2948 const struct builtincmd *x;
2949
2950 printf("\nBuilt-in commands:\n");
2951 printf("-------------------\n");
2952
2953 for (col=0, x = builtincmds; x->builtinfunc != NULL; x++) {
2954 if (!x->name)
2955 continue;
2956 col += printf("%s%s", ((col == 0) ? "\t" : " "), x->name);
2957 if (col > 60) {
2958 printf("\n");
2959 col = 0;
2960 }
2961 }
2962#ifdef BB_FEATURE_SH_STANDALONE_SHELL
2963 {
2964 int i;
2965 const struct BB_applet *applet;
2966 extern const struct BB_applet applets[];
2967 extern const size_t NUM_APPLETS;
2968
2969 for (i=0, applet = applets; i < NUM_APPLETS; applet++, i++) {
2970 if (!applet->name)
2971 continue;
2972
2973 col += printf("%s%s", ((col == 0) ? "\t" : " "),
2974 applet->name);
2975 if (col > 60) {
2976 printf("\n");
2977 col = 0;
2978 }
2979 }
2980 }
2981#endif
2982 printf("\n\n");
2983 return EXIT_SUCCESS;
2984}
2985
2986
2987
Eric Andersenff9eee42001-06-29 04:57:14 +00002988static int
2989dolabel()
2990{
2991 return(0);
2992}
2993
2994static int
2995dochdir(t)
2996register struct op *t;
2997{
2998 register char *cp, *er;
2999
3000 if ((cp = t->words[1]) == NULL && (cp = homedir->value) == NULL)
3001 er = ": no home directory";
3002 else if(chdir(cp) < 0)
3003 er = ": bad directory";
3004 else
3005 return(0);
3006 prs(cp != NULL? cp: "cd");
3007 err(er);
3008 return(1);
3009}
3010
3011static int
3012doshift(t)
3013register struct op *t;
3014{
3015 register int n;
3016
3017 n = t->words[1]? getn(t->words[1]): 1;
3018 if(dolc < n) {
3019 err("nothing to shift");
3020 return(1);
3021 }
3022 dolv[n] = dolv[0];
3023 dolv += n;
3024 dolc -= n;
3025 setval(lookup("#"), putn(dolc));
3026 return(0);
3027}
3028
3029/*
3030 * execute login and newgrp directly
3031 */
3032static int
3033dologin(t)
3034struct op *t;
3035{
3036 register char *cp;
3037
3038 if (interactive) {
3039 signal(SIGINT, SIG_DFL);
3040 signal(SIGQUIT, SIG_DFL);
3041 }
3042 cp = rexecve(t->words[0], t->words, makenv());
3043 prs(t->words[0]); prs(": "); err(cp);
3044 return(1);
3045}
3046
3047static int
3048doumask(t)
3049register struct op *t;
3050{
3051 register int i, n;
3052 register char *cp;
3053
3054 if ((cp = t->words[1]) == NULL) {
3055 i = umask(0);
3056 umask(i);
3057 for (n=3*4; (n-=3) >= 0;)
3058 putc('0'+((i>>n)&07), stderr);
3059 putc('\n', stderr);
3060 } else {
3061 for (n=0; *cp>='0' && *cp<='9'; cp++)
3062 n = n*8 + (*cp-'0');
3063 umask(n);
3064 }
3065 return(0);
3066}
3067
3068static int
3069doexec(t)
3070register struct op *t;
3071{
3072 register int i;
3073 jmp_buf ex;
3074 xint *ofail;
3075
3076 t->ioact = NULL;
3077 for(i = 0; (t->words[i]=t->words[i+1]) != NULL; i++)
3078 ;
3079 if (i == 0)
3080 return(1);
3081 execflg = 1;
3082 ofail = failpt;
3083 if (setjmp(failpt = ex) == 0)
3084 execute(t, NOPIPE, NOPIPE, FEXEC);
3085 failpt = ofail;
3086 execflg = 0;
3087 return(1);
3088}
3089
3090static int
3091dodot(t)
3092struct op *t;
3093{
3094 register int i;
3095 register char *sp, *tp;
3096 char *cp;
3097
3098 if ((cp = t->words[1]) == NULL)
3099 return(0);
3100 sp = any('/', cp)? ":": path->value;
3101 while (*sp) {
3102 tp = e.linep;
3103 while (*sp && (*tp = *sp++) != ':')
3104 tp++;
3105 if (tp != e.linep)
3106 *tp++ = '/';
3107 for (i = 0; (*tp++ = cp[i++]) != '\0';)
3108 ;
3109 if ((i = open(e.linep, 0)) >= 0) {
3110 exstat = 0;
3111 next(remap(i));
3112 return(exstat);
3113 }
3114 }
3115 prs(cp);
3116 err(": not found");
3117 return(-1);
3118}
3119
3120static int
3121dowait(t)
3122struct op *t;
3123{
3124 register int i;
3125 register char *cp;
3126
3127 if ((cp = t->words[1]) != NULL) {
3128 i = getn(cp);
3129 if (i == 0)
3130 return(0);
3131 } else
3132 i = -1;
3133 setstatus(waitfor(i, 1));
3134 return(0);
3135}
3136
3137static int
3138doread(t)
3139struct op *t;
3140{
3141 register char *cp, **wp;
3142 register int nb = 0;
3143 register int nl = 0;
3144
3145 if (t->words[1] == NULL) {
3146 err("Usage: read name ...");
3147 return(1);
3148 }
3149 for (wp = t->words+1; *wp; wp++) {
3150 for (cp = e.linep; !nl && cp < elinep-1; cp++)
3151 if ((nb = read(0, cp, sizeof(*cp))) != sizeof(*cp) ||
3152 (nl = (*cp == '\n')) ||
3153 (wp[1] && any(*cp, ifs->value)))
3154 break;
3155 *cp = 0;
3156 if (nb <= 0)
3157 break;
3158 setval(lookup(*wp), e.linep);
3159 }
3160 return(nb <= 0);
3161}
3162
3163static int
3164doeval(t)
3165register struct op *t;
3166{
3167 return(RUN(awordlist, t->words+1, wdchar));
3168}
3169
3170static int
3171dotrap(t)
3172register struct op *t;
3173{
3174 register int n, i;
3175 register int resetsig;
3176
3177 if (t->words[1] == NULL) {
3178 for (i=0; i<=_NSIG; i++)
3179 if (trap[i]) {
3180 prn(i);
3181 prs(": ");
3182 prs(trap[i]);
3183 prs("\n");
3184 }
3185 return(0);
3186 }
3187 resetsig = isdigit(*t->words[1]);
3188 for (i = resetsig ? 1 : 2; t->words[i] != NULL; ++i) {
3189 n = getsig(t->words[i]);
3190 freecell(trap[n]);
3191 trap[n] = 0;
3192 if (!resetsig) {
3193 if (*t->words[1] != '\0') {
3194 trap[n] = strsave(t->words[1], 0);
3195 setsig(n, sig);
3196 } else
3197 setsig(n, SIG_IGN);
3198 } else {
3199 if (interactive)
3200 if (n == SIGINT)
3201 setsig(n, onintr);
3202 else
3203 setsig(n, n == SIGQUIT ? SIG_IGN
3204 : SIG_DFL);
3205 else
3206 setsig(n, SIG_DFL);
3207 }
3208 }
3209 return(0);
3210}
3211
3212static int
3213getsig(s)
3214char *s;
3215{
3216 register int n;
3217
3218 if ((n = getn(s)) < 0 || n > _NSIG) {
3219 err("trap: bad signal number");
3220 n = 0;
3221 }
3222 return(n);
3223}
3224
3225static void
3226setsig( register int n, void (*f)(int))
3227{
3228 if (n == 0)
3229 return;
3230 if (signal(n, SIG_IGN) != SIG_IGN || ourtrap[n]) {
3231 ourtrap[n] = 1;
3232 signal(n, f);
3233 }
3234}
3235
3236static int
3237getn(as)
3238char *as;
3239{
3240 register char *s;
3241 register int n, m;
3242
3243 s = as;
3244 m = 1;
3245 if (*s == '-') {
3246 m = -1;
3247 s++;
3248 }
3249 for (n = 0; isdigit(*s); s++)
3250 n = (n*10) + (*s-'0');
3251 if (*s) {
3252 prs(as);
3253 err(": bad number");
3254 }
3255 return(n*m);
3256}
3257
3258static int
3259dobreak(t)
3260struct op *t;
3261{
3262 return(brkcontin(t->words[1], 1));
3263}
3264
3265static int
3266docontinue(t)
3267struct op *t;
3268{
3269 return(brkcontin(t->words[1], 0));
3270}
3271
3272static int
3273brkcontin(cp, val)
3274register char *cp;
3275int val;
3276{
3277 register struct brkcon *bc;
3278 register int nl;
3279
3280 nl = cp == NULL? 1: getn(cp);
3281 if (nl <= 0)
3282 nl = 999;
3283 do {
3284 if ((bc = brklist) == NULL)
3285 break;
3286 brklist = bc->nextlev;
3287 } while (--nl);
3288 if (nl) {
3289 err("bad break/continue level");
3290 return(1);
3291 }
3292 isbreak = val;
3293 longjmp(bc->brkpt, 1);
3294 /* NOTREACHED */
3295}
3296
3297static int
3298doexit(t)
3299struct op *t;
3300{
3301 register char *cp;
3302
3303 execflg = 0;
3304 if ((cp = t->words[1]) != NULL)
3305 setstatus(getn(cp));
3306 leave();
3307 /* NOTREACHED */
3308 return(0);
3309}
3310
3311static int
3312doexport(t)
3313struct op *t;
3314{
3315 rdexp(t->words+1, export, EXPORT);
3316 return(0);
3317}
3318
3319static int
3320doreadonly(t)
3321struct op *t;
3322{
3323 rdexp(t->words+1, ronly, RONLY);
3324 return(0);
3325}
3326
3327static void
3328rdexp(wp, f, key)
3329register char **wp;
3330void (*f)();
3331int key;
3332{
3333 if (*wp != NULL) {
3334 for (; *wp != NULL; wp++)
3335 if (checkname(*wp))
3336 (*f)(lookup(*wp));
3337 else
3338 badid(*wp);
3339 } else
3340 putvlist(key, 1);
3341}
3342
3343static void
3344badid(s)
3345register char *s;
3346{
3347 prs(s);
3348 err(": bad identifier");
3349}
3350
3351static int
3352doset(t)
3353register struct op *t;
3354{
3355 register struct var *vp;
3356 register char *cp;
3357 register int n;
3358
3359 if ((cp = t->words[1]) == NULL) {
3360 for (vp = vlist; vp; vp = vp->next)
3361 varput(vp->name, 1);
3362 return(0);
3363 }
3364 if (*cp == '-') {
3365 /* bad: t->words++; */
3366 for(n = 0; (t->words[n]=t->words[n+1]) != NULL; n++)
3367 ;
3368 if (*++cp == 0)
3369 flag['x'] = flag['v'] = 0;
3370 else
3371 for (; *cp; cp++)
3372 switch (*cp) {
3373 case 'e':
3374 if (!interactive)
3375 flag['e']++;
3376 break;
3377
3378 default:
3379 if (*cp>='a' && *cp<='z')
3380 flag[(int)*cp]++;
3381 break;
3382 }
3383 setdash();
3384 }
3385 if (t->words[1]) {
3386 t->words[0] = dolv[0];
3387 for (n=1; t->words[n]; n++)
3388 setarea((char *)t->words[n], 0);
3389 dolc = n-1;
3390 dolv = t->words;
3391 setval(lookup("#"), putn(dolc));
3392 setarea((char *)(dolv-1), 0);
3393 }
3394 return(0);
3395}
3396
3397static void
3398varput(s, out)
3399register char *s;
3400int out;
3401{
3402 if (isalnum(*s)) {
3403 write(out, s, strlen(s));
3404 write(out, "\n", 1);
3405 }
3406}
3407
3408
3409/*
3410 * Copyright (c) 1999 Herbert Xu <herbert@debian.org>
3411 * This file contains code for the times builtin.
Eric Andersenff9eee42001-06-29 04:57:14 +00003412 */
3413static int dotimes ()
3414{
3415 struct tms buf;
3416 long int clk_tck = sysconf(_SC_CLK_TCK);
3417
3418 times(&buf);
3419 printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n",
3420 (int) (buf.tms_utime / clk_tck / 60),
3421 ((double) buf.tms_utime) / clk_tck,
3422 (int) (buf.tms_stime / clk_tck / 60),
3423 ((double) buf.tms_stime) / clk_tck,
3424 (int) (buf.tms_cutime / clk_tck / 60),
3425 ((double) buf.tms_cutime) / clk_tck,
3426 (int) (buf.tms_cstime / clk_tck / 60),
3427 ((double) buf.tms_cstime) / clk_tck);
3428 return 0;
3429}
3430
3431
Eric Andersen1c039232001-07-07 00:05:55 +00003432static int (*inbuilt(char *s))()
Eric Andersenff9eee42001-06-29 04:57:14 +00003433{
Eric Andersen1c039232001-07-07 00:05:55 +00003434 const struct builtincmd *bp;
Eric Andersenff9eee42001-06-29 04:57:14 +00003435
Eric Andersen1c039232001-07-07 00:05:55 +00003436 for (bp = builtincmds; bp->name != NULL; bp++)
3437 if (strcmp(bp->name, s) == 0)
3438 return(bp->builtinfunc);
3439
Eric Andersenff9eee42001-06-29 04:57:14 +00003440 return((int(*)())NULL);
3441}
3442
3443/* -------- eval.c -------- */
3444
3445/*
3446 * ${}
3447 * `command`
3448 * blank interpretation
3449 * quoting
3450 * glob
3451 */
3452
3453static char ** eval( char **ap, int f)
3454{
3455 struct wdblock *wb;
3456 char **wp;
3457 char **wf;
3458 jmp_buf ev;
3459
3460#if __GNUC__
3461 /* Avoid longjmp clobbering */
3462 (void) &wp;
3463 (void) &ap;
3464#endif
3465 wp = NULL;
3466 wb = NULL;
3467 wf = NULL;
3468 if (newenv(setjmp(errpt = ev)) == 0) {
3469 while (*ap && isassign(*ap))
3470 expand(*ap++, &wb, f & ~DOGLOB);
3471 if (flag['k']) {
3472 for (wf = ap; *wf; wf++) {
3473 if (isassign(*wf))
3474 expand(*wf, &wb, f & ~DOGLOB);
3475 }
3476 }
3477 for (wb = addword((char *)0, wb); *ap; ap++) {
3478 if (!flag['k'] || !isassign(*ap))
3479 expand(*ap, &wb, f & ~DOKEY);
3480 }
3481 wb = addword((char *)0, wb);
3482 wp = getwords(wb);
3483 quitenv();
3484 } else
3485 gflg = 1;
3486 return(gflg? (char **)NULL: wp);
3487}
3488
3489/*
3490 * Make the exported environment from the exported
3491 * names in the dictionary. Keyword assignments
3492 * will already have been done.
3493 */
3494static char **
3495makenv()
3496
3497{
3498 register struct wdblock *wb;
3499 register struct var *vp;
3500
3501 wb = NULL;
3502 for (vp = vlist; vp; vp = vp->next)
3503 if (vp->status & EXPORT)
3504 wb = addword(vp->name, wb);
3505 wb = addword((char *)0, wb);
3506 return(getwords(wb));
3507}
3508
3509static char *
3510evalstr(cp, f)
3511register char *cp;
3512int f;
3513{
3514 struct wdblock *wb;
3515
3516 wb = NULL;
3517 if (expand(cp, &wb, f)) {
3518 if (wb == NULL || wb->w_nword == 0 || (cp = wb->w_words[0]) == NULL)
3519 cp = "";
3520 DELETE(wb);
3521 } else
3522 cp = NULL;
3523 return(cp);
3524}
3525
3526static int
3527expand( char *cp, register struct wdblock **wbp, int f)
3528{
3529 jmp_buf ev;
3530
3531#if __GNUC__
3532 /* Avoid longjmp clobbering */
3533 (void) &cp;
3534#endif
3535 gflg = 0;
3536 if (cp == NULL)
3537 return(0);
3538 if (!anys("$`'\"", cp) &&
3539 !anys(ifs->value, cp) &&
3540 ((f&DOGLOB)==0 || !anys("[*?", cp))) {
3541 cp = strsave(cp, areanum);
3542 if (f & DOTRIM)
3543 unquote(cp);
3544 *wbp = addword(cp, *wbp);
3545 return(1);
3546 }
3547 if (newenv(setjmp(errpt = ev)) == 0) {
3548 PUSHIO(aword, cp, strchar);
3549 e.iobase = e.iop;
3550 while ((cp = blank(f)) && gflg == 0) {
3551 e.linep = cp;
3552 cp = strsave(cp, areanum);
3553 if ((f&DOGLOB) == 0) {
3554 if (f & DOTRIM)
3555 unquote(cp);
3556 *wbp = addword(cp, *wbp);
3557 } else
3558 *wbp = glob(cp, *wbp);
3559 }
3560 quitenv();
3561 } else
3562 gflg = 1;
3563 return(gflg == 0);
3564}
3565
3566/*
3567 * Blank interpretation and quoting
3568 */
3569static char *
3570blank(f)
3571int f;
3572{
3573 register int c, c1;
3574 register char *sp;
3575 int scanequals, foundequals;
3576
3577 sp = e.linep;
3578 scanequals = f & DOKEY;
3579 foundequals = 0;
3580
3581loop:
3582 switch (c = subgetc('"', foundequals)) {
3583 case 0:
3584 if (sp == e.linep)
3585 return(0);
3586 *e.linep++ = 0;
3587 return(sp);
3588
3589 default:
3590 if (f & DOBLANK && any(c, ifs->value))
3591 goto loop;
3592 break;
3593
3594 case '"':
3595 case '\'':
3596 scanequals = 0;
3597 if (INSUB())
3598 break;
3599 for (c1 = c; (c = subgetc(c1, 1)) != c1;) {
3600 if (c == 0)
3601 break;
3602 if (c == '\'' || !any(c, "$`\""))
3603 c |= QUOTE;
3604 *e.linep++ = c;
3605 }
3606 c = 0;
3607 }
3608 unget(c);
3609 if (!isalpha(c))
3610 scanequals = 0;
3611 for (;;) {
3612 c = subgetc('"', foundequals);
3613 if (c == 0 ||
3614 f & (DOBLANK && any(c, ifs->value)) ||
3615 (!INSUB() && any(c, "\"'"))) {
3616 scanequals = 0;
3617 unget(c);
3618 if (any(c, "\"'"))
3619 goto loop;
3620 break;
3621 }
3622 if (scanequals) {
3623 if (c == '=') {
3624 foundequals = 1;
3625 scanequals = 0;
3626 }
3627 else if (!isalnum(c))
3628 scanequals = 0;
3629 }
3630 *e.linep++ = c;
3631 }
3632 *e.linep++ = 0;
3633 return(sp);
3634}
3635
3636/*
3637 * Get characters, substituting for ` and $
3638 */
3639static int
3640subgetc(ec, quoted)
3641register int ec;
3642int quoted;
3643{
3644 register char c;
3645
3646again:
3647 c = my_getc(ec);
3648 if (!INSUB() && ec != '\'') {
3649 if (c == '`') {
3650 if (grave(quoted) == 0)
3651 return(0);
3652 e.iop->task = XGRAVE;
3653 goto again;
3654 }
3655 if (c == '$' && (c = dollar(quoted)) == 0) {
3656 e.iop->task = XDOLL;
3657 goto again;
3658 }
3659 }
3660 return(c);
3661}
3662
3663/*
3664 * Prepare to generate the string returned by ${} substitution.
3665 */
3666static int
3667dollar(quoted)
3668int quoted;
3669{
3670 int otask;
3671 struct io *oiop;
3672 char *dolp;
3673 register char *s, c, *cp=NULL;
3674 struct var *vp;
3675
3676 c = readc();
3677 s = e.linep;
3678 if (c != '{') {
3679 *e.linep++ = c;
3680 if (isalpha(c)) {
3681 while ((c = readc())!=0 && isalnum(c))
3682 if (e.linep < elinep)
3683 *e.linep++ = c;
3684 unget(c);
3685 }
3686 c = 0;
3687 } else {
3688 oiop = e.iop;
3689 otask = e.iop->task;
3690 e.iop->task = XOTHER;
3691 while ((c = subgetc('"', 0))!=0 && c!='}' && c!='\n')
3692 if (e.linep < elinep)
3693 *e.linep++ = c;
3694 if (oiop == e.iop)
3695 e.iop->task = otask;
3696 if (c != '}') {
3697 err("unclosed ${");
3698 gflg++;
3699 return(c);
3700 }
3701 }
3702 if (e.linep >= elinep) {
3703 err("string in ${} too long");
3704 gflg++;
3705 e.linep -= 10;
3706 }
3707 *e.linep = 0;
3708 if (*s)
3709 for (cp = s+1; *cp; cp++)
3710 if (any(*cp, "=-+?")) {
3711 c = *cp;
3712 *cp++ = 0;
3713 break;
3714 }
3715 if (s[1] == 0 && (*s == '*' || *s == '@')) {
3716 if (dolc > 1) {
3717 /* currently this does not distinguish $* and $@ */
3718 /* should check dollar */
3719 e.linep = s;
3720 PUSHIO(awordlist, dolv+1, dolchar);
3721 return(0);
3722 } else { /* trap the nasty ${=} */
3723 s[0] = '1';
3724 s[1] = 0;
3725 }
3726 }
3727 vp = lookup(s);
3728 if ((dolp = vp->value) == null) {
3729 switch (c) {
3730 case '=':
3731 if (isdigit(*s)) {
3732 err("cannot use ${...=...} with $n");
3733 gflg++;
3734 break;
3735 }
3736 setval(vp, cp);
3737 dolp = vp->value;
3738 break;
3739
3740 case '-':
3741 dolp = strsave(cp, areanum);
3742 break;
3743
3744 case '?':
3745 if (*cp == 0) {
3746 prs("missing value for ");
3747 err(s);
3748 } else
3749 err(cp);
3750 gflg++;
3751 break;
3752 }
3753 } else if (c == '+')
3754 dolp = strsave(cp, areanum);
3755 if (flag['u'] && dolp == null) {
3756 prs("unset variable: ");
3757 err(s);
3758 gflg++;
3759 }
3760 e.linep = s;
3761 PUSHIO(aword, dolp, quoted ? qstrchar : strchar);
3762 return(0);
3763}
3764
3765/*
3766 * Run the command in `...` and read its output.
3767 */
3768static int
3769grave(quoted)
3770int quoted;
3771{
3772 register int i;
3773 char *cp;
3774 int pf[2];
3775
3776#if __GNUC__
3777 /* Avoid longjmp clobbering */
3778 (void) &cp;
3779#endif
3780 for (cp = e.iop->argp->aword; *cp != '`'; cp++)
3781 if (*cp == 0) {
3782 err("no closing `");
3783 return(0);
3784 }
3785 if (openpipe(pf) < 0)
3786 return(0);
3787 if ((i = vfork()) == -1) {
3788 closepipe(pf);
3789 err("try again");
3790 return(0);
3791 }
3792 if (i != 0) {
3793 e.iop->argp->aword = ++cp;
3794 close(pf[1]);
3795 PUSHIO(afile, remap(pf[0]), quoted? qgravechar: gravechar);
3796 return(1);
3797 }
3798 *cp = 0;
3799 /* allow trapped signals */
3800 for (i=0; i<=_NSIG; i++)
3801 if (ourtrap[i] && signal(i, SIG_IGN) != SIG_IGN)
3802 signal(i, SIG_DFL);
3803 dup2(pf[1], 1);
3804 closepipe(pf);
3805 flag['e'] = 0;
3806 flag['v'] = 0;
3807 flag['n'] = 0;
3808 cp = strsave(e.iop->argp->aword, 0);
3809 areanum = 1;
3810 freehere(areanum);
3811 freearea(areanum); /* free old space */
3812 e.oenv = NULL;
3813 e.iop = (e.iobase = iostack) - 1;
3814 unquote(cp);
3815 interactive = 0;
3816 PUSHIO(aword, cp, nlchar);
3817 onecommand();
3818 exit(1);
3819}
3820
3821static char *
3822unquote(as)
3823register char *as;
3824{
3825 register char *s;
3826
3827 if ((s = as) != NULL)
3828 while (*s)
3829 *s++ &= ~QUOTE;
3830 return(as);
3831}
3832
3833/* -------- glob.c -------- */
3834
3835/*
3836 * glob
3837 */
3838
3839#define scopy(x) strsave((x), areanum)
3840#define BLKSIZ 512
3841#define NDENT ((BLKSIZ+sizeof(struct dirent)-1)/sizeof(struct dirent))
3842
3843static struct wdblock *cl, *nl;
3844static char spcl[] = "[?*";
3845
3846static struct wdblock *
3847glob(cp, wb)
3848char *cp;
3849struct wdblock *wb;
3850{
3851 register int i;
3852 register char *pp;
3853
3854 if (cp == 0)
3855 return(wb);
3856 i = 0;
3857 for (pp = cp; *pp; pp++)
3858 if (any(*pp, spcl))
3859 i++;
3860 else if (!any(*pp & ~QUOTE, spcl))
3861 *pp &= ~QUOTE;
3862 if (i != 0) {
3863 for (cl = addword(scopy(cp), (struct wdblock *)0); anyspcl(cl); cl = nl) {
3864 nl = newword(cl->w_nword*2);
3865 for(i=0; i<cl->w_nword; i++) { /* for each argument */
3866 for (pp = cl->w_words[i]; *pp; pp++)
3867 if (any(*pp, spcl)) {
3868 globname(cl->w_words[i], pp);
3869 break;
3870 }
3871 if (*pp == '\0')
3872 nl = addword(scopy(cl->w_words[i]), nl);
3873 }
3874 for(i=0; i<cl->w_nword; i++)
3875 DELETE(cl->w_words[i]);
3876 DELETE(cl);
3877 }
3878 for(i=0; i<cl->w_nword; i++)
3879 unquote(cl->w_words[i]);
3880 glob0((char *)cl->w_words, cl->w_nword, sizeof(char *), xstrcmp);
3881 if (cl->w_nword) {
3882 for (i=0; i<cl->w_nword; i++)
3883 wb = addword(cl->w_words[i], wb);
3884 DELETE(cl);
3885 return(wb);
3886 }
3887 }
3888 wb = addword(unquote(cp), wb);
3889 return(wb);
3890}
3891
3892static void
3893globname(we, pp)
3894char *we;
3895register char *pp;
3896{
3897 register char *np, *cp;
3898 char *name, *gp, *dp;
3899 int k;
3900 DIR *dirp;
3901 struct dirent *de;
3902 char dname[NAME_MAX+1];
3903 struct stat dbuf;
3904
3905 for (np = we; np != pp; pp--)
3906 if (pp[-1] == '/')
3907 break;
3908 for (dp = cp = space((int)(pp-np)+3); np < pp;)
3909 *cp++ = *np++;
3910 *cp++ = '.';
3911 *cp = '\0';
3912 for (gp = cp = space(strlen(pp)+1); *np && *np != '/';)
3913 *cp++ = *np++;
3914 *cp = '\0';
3915 dirp = opendir(dp);
3916 if (dirp == 0) {
3917 DELETE(dp);
3918 DELETE(gp);
3919 return;
3920 }
3921 dname[NAME_MAX] = '\0';
3922 while ((de=readdir(dirp))!=NULL) {
3923 /* XXX Hmmm... What this could be? (abial) */
3924 /*
3925 if (ent[j].d_ino == 0)
3926 continue;
3927 */
3928 strncpy(dname, de->d_name, NAME_MAX);
3929 if (dname[0] == '.')
3930 if (*gp != '.')
3931 continue;
3932 for(k=0; k<NAME_MAX; k++)
3933 if (any(dname[k], spcl))
3934 dname[k] |= QUOTE;
3935 if (gmatch(dname, gp)) {
3936 name = generate(we, pp, dname, np);
3937 if (*np && !anys(np, spcl)) {
3938 if (stat(name,&dbuf)) {
3939 DELETE(name);
3940 continue;
3941 }
3942 }
3943 nl = addword(name, nl);
3944 }
3945 }
3946 closedir(dirp);
3947 DELETE(dp);
3948 DELETE(gp);
3949}
3950
3951/*
3952 * generate a pathname as below.
3953 * start..end1 / middle end
3954 * the slashes come for free
3955 */
3956static char *
3957generate(start1, end1, middle, end)
3958char *start1;
3959register char *end1;
3960char *middle, *end;
3961{
3962 char *p;
3963 register char *op, *xp;
3964
3965 p = op = space((int)(end1-start1)+strlen(middle)+strlen(end)+2);
3966 for (xp = start1; xp != end1;)
3967 *op++ = *xp++;
3968 for (xp = middle; (*op++ = *xp++) != '\0';)
3969 ;
3970 op--;
3971 for (xp = end; (*op++ = *xp++) != '\0';)
3972 ;
3973 return(p);
3974}
3975
3976static int
3977anyspcl(wb)
3978register struct wdblock *wb;
3979{
3980 register int i;
3981 register char **wd;
3982
3983 wd = wb->w_words;
3984 for (i=0; i<wb->w_nword; i++)
3985 if (anys(spcl, *wd++))
3986 return(1);
3987 return(0);
3988}
3989
3990static int
3991xstrcmp(p1, p2)
3992char *p1, *p2;
3993{
3994 return(strcmp(*(char **)p1, *(char **)p2));
3995}
3996
3997/* -------- word.c -------- */
3998
3999static struct wdblock *
4000newword(nw)
4001register int nw;
4002{
4003 register struct wdblock *wb;
4004
4005 wb = (struct wdblock *) space(sizeof(*wb) + nw*sizeof(char *));
4006 wb->w_bsize = nw;
4007 wb->w_nword = 0;
4008 return(wb);
4009}
4010
4011static struct wdblock *
4012addword(wd, wb)
4013char *wd;
4014register struct wdblock *wb;
4015{
4016 register struct wdblock *wb2;
4017 register int nw;
4018
4019 if (wb == NULL)
4020 wb = newword(NSTART);
4021 if ((nw = wb->w_nword) >= wb->w_bsize) {
4022 wb2 = newword(nw * 2);
4023 memcpy((char *)wb2->w_words, (char *)wb->w_words, nw*sizeof(char *));
4024 wb2->w_nword = nw;
4025 DELETE(wb);
4026 wb = wb2;
4027 }
4028 wb->w_words[wb->w_nword++] = wd;
4029 return(wb);
4030}
4031static
4032char **
4033getwords(wb)
4034register struct wdblock *wb;
4035{
4036 register char **wd;
4037 register int nb;
4038
4039 if (wb == NULL)
4040 return((char **)NULL);
4041 if (wb->w_nword == 0) {
4042 DELETE(wb);
4043 return((char **)NULL);
4044 }
4045 wd = (char **) space(nb = sizeof(*wd) * wb->w_nword);
4046 memcpy((char *)wd, (char *)wb->w_words, nb);
4047 DELETE(wb); /* perhaps should done by caller */
4048 return(wd);
4049}
4050
4051int (*func)(char *, char *);
4052int globv;
4053
4054static void
4055glob0(a0, a1, a2, a3)
4056char *a0;
4057unsigned a1;
4058int a2;
4059int (*a3) (char *, char *);
4060{
4061 func = a3;
4062 globv = a2;
4063 glob1(a0, a0 + a1 * a2);
4064}
4065
4066static void
4067glob1(base, lim)
4068char *base, *lim;
4069{
4070 register char *i, *j;
4071 int v2;
4072 char *lptr, *hptr;
4073 int c;
4074 unsigned n;
4075
4076
4077 v2 = globv;
4078
4079top:
4080 if ((n=(int)(lim-base)) <= v2)
4081 return;
4082 n = v2 * (n / (2*v2));
4083 hptr = lptr = base+n;
4084 i = base;
4085 j = lim-v2;
4086 for(;;) {
4087 if (i < lptr) {
4088 if ((c = (*func)(i, lptr)) == 0) {
4089 glob2(i, lptr -= v2);
4090 continue;
4091 }
4092 if (c < 0) {
4093 i += v2;
4094 continue;
4095 }
4096 }
4097
4098begin:
4099 if (j > hptr) {
4100 if ((c = (*func)(hptr, j)) == 0) {
4101 glob2(hptr += v2, j);
4102 goto begin;
4103 }
4104 if (c > 0) {
4105 if (i == lptr) {
4106 glob3(i, hptr += v2, j);
4107 i = lptr += v2;
4108 goto begin;
4109 }
4110 glob2(i, j);
4111 j -= v2;
4112 i += v2;
4113 continue;
4114 }
4115 j -= v2;
4116 goto begin;
4117 }
4118
4119
4120 if (i == lptr) {
4121 if (lptr-base >= lim-hptr) {
4122 glob1(hptr+v2, lim);
4123 lim = lptr;
4124 } else {
4125 glob1(base, lptr);
4126 base = hptr+v2;
4127 }
4128 goto top;
4129 }
4130
4131
4132 glob3(j, lptr -= v2, i);
4133 j = hptr -= v2;
4134 }
4135}
4136
4137static void
4138glob2(i, j)
4139char *i, *j;
4140{
4141 register char *index1, *index2, c;
4142 int m;
4143
4144 m = globv;
4145 index1 = i;
4146 index2 = j;
4147 do {
4148 c = *index1;
4149 *index1++ = *index2;
4150 *index2++ = c;
4151 } while(--m);
4152}
4153
4154static void
4155glob3(i, j, k)
4156char *i, *j, *k;
4157{
4158 register char *index1, *index2, *index3;
4159 int c;
4160 int m;
4161
4162 m = globv;
4163 index1 = i;
4164 index2 = j;
4165 index3 = k;
4166 do {
4167 c = *index1;
4168 *index1++ = *index3;
4169 *index3++ = *index2;
4170 *index2++ = c;
4171 } while(--m);
4172}
4173
4174/* -------- io.c -------- */
4175
4176/*
4177 * shell IO
4178 */
4179
4180static int my_getc( int ec)
4181{
4182 register int c;
4183
4184 if(e.linep > elinep) {
4185 while((c=readc()) != '\n' && c)
4186 ;
4187 err("input line too long");
4188 gflg++;
4189 return(c);
4190 }
4191 c = readc();
4192 if (ec != '\'' && e.iop->task != XGRAVE) {
4193 if(c == '\\') {
4194 c = readc();
4195 if (c == '\n' && ec != '\"')
4196 return(my_getc(ec));
4197 c |= QUOTE;
4198 }
4199 }
4200 return(c);
4201}
4202
4203static void
4204unget(c)
4205int c;
4206{
4207 if (e.iop >= e.iobase)
4208 e.iop->peekc = c;
4209}
4210
4211static int
4212eofc()
4213
4214{
4215 return e.iop < e.iobase || (e.iop->peekc == 0 && e.iop->prev == 0);
4216}
4217
4218static int
4219readc()
4220{
4221 register int c;
4222
4223 for (; e.iop >= e.iobase; e.iop--)
4224 if ((c = e.iop->peekc) != '\0') {
4225 e.iop->peekc = 0;
4226 return(c);
4227 }
4228 else {
4229 if (e.iop->prev != 0) {
4230 if ((c = (*e.iop->iofn)(e.iop->argp, e.iop)) != '\0') {
4231 if (c == -1) {
4232 e.iop++;
4233 continue;
4234 }
4235 if (e.iop == iostack)
4236 ioecho(c);
4237 return(e.iop->prev = c);
4238 }
4239 else if (e.iop->task == XIO && e.iop->prev != '\n') {
4240 e.iop->prev = 0;
4241 if (e.iop == iostack)
4242 ioecho('\n');
4243 return '\n';
4244 }
4245 }
4246 if (e.iop->task == XIO) {
4247 if (multiline)
4248 return e.iop->prev = 0;
4249 if (interactive && e.iop == iostack+1) {
4250#ifdef BB_FEATURE_COMMAND_EDITING
4251 current_prompt=prompt->value;
4252#else
4253 prs(prompt->value);
4254#endif
4255 }
4256 }
4257 }
4258 if (e.iop >= iostack)
4259 return(0);
4260 leave();
4261 /* NOTREACHED */
4262 return(0);
4263}
4264
4265static void
4266ioecho(c)
4267char c;
4268{
4269 if (flag['v'])
4270 write(2, &c, sizeof c);
4271}
4272
4273static void
4274pushio(argp, fn)
4275struct ioarg *argp;
4276int (*fn)();
4277{
4278 if (++e.iop >= &iostack[NPUSH]) {
4279 e.iop--;
4280 err("Shell input nested too deeply");
4281 gflg++;
4282 return;
4283 }
4284 e.iop->iofn = fn;
4285
4286 if (argp->afid != AFID_NOBUF)
4287 e.iop->argp = argp;
4288 else {
4289 e.iop->argp = ioargstack + (e.iop - iostack);
4290 *e.iop->argp = *argp;
4291 e.iop->argp->afbuf = e.iop == &iostack[0] ? &mainbuf : &sharedbuf;
4292 if (isatty(e.iop->argp->afile) == 0 &&
4293 (e.iop == &iostack[0] ||
4294 lseek(e.iop->argp->afile, 0L, 1) != -1)) {
4295 if (++bufid == AFID_NOBUF)
4296 bufid = AFID_ID;
4297 e.iop->argp->afid = bufid;
4298 }
4299 }
4300
4301 e.iop->prev = ~'\n';
4302 e.iop->peekc = 0;
4303 e.iop->xchar = 0;
4304 e.iop->nlcount = 0;
4305 if (fn == filechar || fn == linechar)
4306 e.iop->task = XIO;
4307 else if (fn == gravechar || fn == qgravechar)
4308 e.iop->task = XGRAVE;
4309 else
4310 e.iop->task = XOTHER;
4311}
4312
4313static struct io *
4314setbase(ip)
4315struct io *ip;
4316{
4317 register struct io *xp;
4318
4319 xp = e.iobase;
4320 e.iobase = ip;
4321 return(xp);
4322}
4323
4324/*
4325 * Input generating functions
4326 */
4327
4328/*
4329 * Produce the characters of a string, then a newline, then EOF.
4330 */
4331static int
4332nlchar(ap)
4333register struct ioarg *ap;
4334{
4335 register int c;
4336
4337 if (ap->aword == NULL)
4338 return(0);
4339 if ((c = *ap->aword++) == 0) {
4340 ap->aword = NULL;
4341 return('\n');
4342 }
4343 return(c);
4344}
4345
4346/*
4347 * Given a list of words, produce the characters
4348 * in them, with a space after each word.
4349 */
4350static int
4351wdchar(ap)
4352register struct ioarg *ap;
4353{
4354 register char c;
4355 register char **wl;
4356
4357 if ((wl = ap->awordlist) == NULL)
4358 return(0);
4359 if (*wl != NULL) {
4360 if ((c = *(*wl)++) != 0)
4361 return(c & 0177);
4362 ap->awordlist++;
4363 return(' ');
4364 }
4365 ap->awordlist = NULL;
4366 return('\n');
4367}
4368
4369/*
4370 * Return the characters of a list of words,
4371 * producing a space between them.
4372 */
4373static int
4374dolchar(ap)
4375register struct ioarg *ap;
4376{
4377 register char *wp;
4378
4379 if ((wp = *ap->awordlist++) != NULL) {
4380 PUSHIO(aword, wp, *ap->awordlist == NULL? strchar: xxchar);
4381 return(-1);
4382 }
4383 return(0);
4384}
4385
4386static int
4387xxchar(ap)
4388register struct ioarg *ap;
4389{
4390 register int c;
4391
4392 if (ap->aword == NULL)
4393 return(0);
4394 if ((c = *ap->aword++) == '\0') {
4395 ap->aword = NULL;
4396 return(' ');
4397 }
4398 return(c);
4399}
4400
4401/*
4402 * Produce the characters from a single word (string).
4403 */
4404static int
4405strchar(ap)
4406register struct ioarg *ap;
4407{
4408 register int c;
4409
4410 if (ap->aword == NULL || (c = *ap->aword++) == 0)
4411 return(0);
4412 return(c);
4413}
4414
4415/*
4416 * Produce quoted characters from a single word (string).
4417 */
4418static int
4419qstrchar(ap)
4420register struct ioarg *ap;
4421{
4422 register int c;
4423
4424 if (ap->aword == NULL || (c = *ap->aword++) == 0)
4425 return(0);
4426 return(c|QUOTE);
4427}
4428
4429/*
4430 * Return the characters from a file.
4431 */
4432static int
4433filechar(ap)
4434register struct ioarg *ap;
4435{
4436 register int i;
4437 char c;
4438 struct iobuf *bp = ap->afbuf;
4439
4440 if (ap->afid != AFID_NOBUF) {
4441 if ((i = ap->afid != bp->id) || bp->bufp == bp->ebufp) {
4442 if (i)
4443 lseek(ap->afile, ap->afpos, 0);
4444 do {
4445 i = read(ap->afile, bp->buf, sizeof(bp->buf));
4446 } while (i < 0 && errno == EINTR);
4447 if (i <= 0) {
4448 closef(ap->afile);
4449 return 0;
4450 }
4451 bp->id = ap->afid;
4452 bp->ebufp = (bp->bufp = bp->buf) + i;
4453 }
4454 ap->afpos++;
4455 return *bp->bufp++ & 0177;
4456 }
4457
4458#ifdef BB_FEATURE_COMMAND_EDITING
4459 if (interactive) {
4460 static char mycommand[BUFSIZ];
4461 static int position = 0, size = 0;
4462
4463 while (size == 0 || position >= size) {
4464 cmdedit_read_input(current_prompt, mycommand);
4465 cmdedit_terminate();
4466 size = strlen(mycommand);
4467 position = 0;
4468 }
4469 c = mycommand[position];
4470 position++;
4471 return(c);
4472 } else
4473#endif
4474 {
4475 do {
4476 i = read(ap->afile, &c, sizeof(c));
4477 } while (i < 0 && errno == EINTR);
4478 return(i == sizeof(c)? c&0177: (closef(ap->afile), 0));
4479 }
4480}
4481
4482/*
4483 * Return the characters from a here temp file.
4484 */
4485static int
4486herechar(ap)
4487register struct ioarg *ap;
4488{
4489 char c;
4490
4491
4492 if (read(ap->afile, &c, sizeof(c)) != sizeof(c)) {
4493 close(ap->afile);
4494 c = 0;
4495 }
4496 return (c);
4497
4498}
4499
4500/*
4501 * Return the characters produced by a process (`...`).
4502 * Quote them if required, and remove any trailing newline characters.
4503 */
4504static int
4505gravechar(ap, iop)
4506struct ioarg *ap;
4507struct io *iop;
4508{
4509 register int c;
4510
4511 if ((c = qgravechar(ap, iop)&~QUOTE) == '\n')
4512 c = ' ';
4513 return(c);
4514}
4515
4516static int
4517qgravechar(ap, iop)
4518register struct ioarg *ap;
4519struct io *iop;
4520{
4521 register int c;
4522
4523 if (iop->xchar) {
4524 if (iop->nlcount) {
4525 iop->nlcount--;
4526 return('\n'|QUOTE);
4527 }
4528 c = iop->xchar;
4529 iop->xchar = 0;
4530 } else if ((c = filechar(ap)) == '\n') {
4531 iop->nlcount = 1;
4532 while ((c = filechar(ap)) == '\n')
4533 iop->nlcount++;
4534 iop->xchar = c;
4535 if (c == 0)
4536 return(c);
4537 iop->nlcount--;
4538 c = '\n';
4539 }
4540 return(c!=0? c|QUOTE: 0);
4541}
4542
4543/*
4544 * Return a single command (usually the first line) from a file.
4545 */
4546static int
4547linechar(ap)
4548register struct ioarg *ap;
4549{
4550 register int c;
4551
4552 if ((c = filechar(ap)) == '\n') {
4553 if (!multiline) {
4554 closef(ap->afile);
4555 ap->afile = -1; /* illegal value */
4556 }
4557 }
4558 return(c);
4559}
4560
4561static void
4562prs(s)
4563register char *s;
4564{
4565 if (*s)
4566 write(2, s, strlen(s));
4567}
4568
4569static void
4570prn(u)
4571unsigned u;
4572{
4573 prs(itoa(u, 0));
4574}
4575
4576static void
4577closef(i)
4578register int i;
4579{
4580 if (i > 2)
4581 close(i);
4582}
4583
4584static void
4585closeall()
4586{
4587 register int u;
4588
4589 for (u=NUFILE; u<NOFILE;)
4590 close(u++);
4591}
4592
4593/*
4594 * remap fd into Shell's fd space
4595 */
4596static int
4597remap(fd)
4598register int fd;
4599{
4600 register int i;
4601 int map[NOFILE];
4602
4603 if (fd < e.iofd) {
4604 for (i=0; i<NOFILE; i++)
4605 map[i] = 0;
4606 do {
4607 map[fd] = 1;
4608 fd = dup(fd);
4609 } while (fd >= 0 && fd < e.iofd);
4610 for (i=0; i<NOFILE; i++)
4611 if (map[i])
4612 close(i);
4613 if (fd < 0)
4614 err("too many files open in shell");
4615 }
4616 return(fd);
4617}
4618
4619static int
4620openpipe(pv)
4621register int *pv;
4622{
4623 register int i;
4624
4625 if ((i = pipe(pv)) < 0)
4626 err("can't create pipe - try again");
4627 return(i);
4628}
4629
4630static void
4631closepipe(pv)
4632register int *pv;
4633{
4634 if (pv != NULL) {
4635 close(*pv++);
4636 close(*pv);
4637 }
4638}
4639
4640/* -------- here.c -------- */
4641
4642/*
4643 * here documents
4644 */
4645
4646static void
4647markhere(s, iop)
4648register char *s;
4649struct ioword *iop;
4650{
4651 register struct here *h, *lh;
4652
4653 h = (struct here *) space(sizeof(struct here));
4654 if (h == 0)
4655 return;
4656 h->h_tag = evalstr(s, DOSUB);
4657 if (h->h_tag == 0)
4658 return;
4659 h->h_iop = iop;
4660 iop->io_name = 0;
4661 h->h_next = NULL;
4662 if (inhere == 0)
4663 inhere = h;
4664 else
4665 for (lh = inhere; lh!=NULL; lh = lh->h_next)
4666 if (lh->h_next == 0) {
4667 lh->h_next = h;
4668 break;
4669 }
4670 iop->io_flag |= IOHERE|IOXHERE;
4671 for (s = h->h_tag; *s; s++)
4672 if (*s & QUOTE) {
4673 iop->io_flag &= ~ IOXHERE;
4674 *s &= ~ QUOTE;
4675 }
4676 h->h_dosub = iop->io_flag & IOXHERE;
4677}
4678
4679static void
4680gethere()
4681{
4682 register struct here *h, *hp;
4683
4684 /* Scan here files first leaving inhere list in place */
4685 for (hp = h = inhere; h != NULL; hp = h, h = h->h_next)
4686 readhere(&h->h_iop->io_name, h->h_tag, h->h_dosub? 0: '\'');
4687
4688 /* Make inhere list active - keep list intact for scraphere */
4689 if (hp != NULL) {
4690 hp->h_next = acthere;
4691 acthere = inhere;
4692 inhere = NULL;
4693 }
4694}
4695
4696static void
4697readhere(name, s, ec)
4698char **name;
4699register char *s;
4700int ec;
4701{
4702 int tf;
4703 char tname[30] = ".msh_XXXXXX";
4704 register int c;
4705 jmp_buf ev;
4706 char myline [LINELIM+1];
4707 char *thenext;
4708
4709 tf = mkstemp(tname);
4710 if (tf < 0)
4711 return;
4712 *name = strsave(tname, areanum);
4713 if (newenv(setjmp(errpt = ev)) != 0)
4714 unlink(tname);
4715 else {
4716 pushio(e.iop->argp, e.iop->iofn);
4717 e.iobase = e.iop;
4718 for (;;) {
4719 if (interactive && e.iop <= iostack) {
4720#ifdef BB_FEATURE_COMMAND_EDITING
4721 current_prompt=cprompt->value;
4722#else
4723 prs(cprompt->value);
4724#endif
4725 }
4726 thenext = myline;
4727 while ((c = my_getc(ec)) != '\n' && c) {
4728 if (ec == '\'')
4729 c &= ~ QUOTE;
4730 if (thenext >= &myline[LINELIM]) {
4731 c = 0;
4732 break;
4733 }
4734 *thenext++ = c;
4735 }
4736 *thenext = 0;
4737 if (strcmp(s, myline) == 0 || c == 0)
4738 break;
4739 *thenext++ = '\n';
4740 write (tf, myline, (int)(thenext-myline));
4741 }
4742 if (c == 0) {
4743 prs("here document `"); prs(s); err("' unclosed");
4744 }
4745 quitenv();
4746 }
4747 close(tf);
4748}
4749
4750/*
4751 * open here temp file.
4752 * if unquoted here, expand here temp file into second temp file.
4753 */
4754static int
4755herein(hname, xdoll)
4756char *hname;
4757int xdoll;
4758{
4759 register int hf;
4760 int tf;
4761
4762#if __GNUC__
4763 /* Avoid longjmp clobbering */
4764 (void) &tf;
4765#endif
4766 if (hname == 0)
4767 return(-1);
4768 hf = open(hname, 0);
4769 if (hf < 0)
4770 return (-1);
4771 if (xdoll) {
4772 char c;
4773 char tname[30] = ".msh_XXXXXX";
4774 jmp_buf ev;
4775
4776 tf = mkstemp(tname);
4777 if (tf < 0)
4778 return (-1);
4779 if (newenv(setjmp(errpt = ev)) == 0) {
4780 PUSHIO(afile, hf, herechar);
4781 setbase(e.iop);
4782 while ((c = subgetc(0, 0)) != 0) {
4783 c &= ~ QUOTE;
4784 write(tf, &c, sizeof c);
4785 }
4786 quitenv();
4787 } else
4788 unlink(tname);
4789 close(tf);
4790 tf = open(tname, 0);
4791 unlink(tname);
4792 return (tf);
4793 } else
4794 return (hf);
4795}
4796
4797static void
4798scraphere()
4799{
4800 register struct here *h;
4801
4802 for (h = inhere; h != NULL; h = h->h_next) {
4803 if (h->h_iop && h->h_iop->io_name)
4804 unlink(h->h_iop->io_name);
4805 }
4806 inhere = NULL;
4807}
4808
4809/* unlink here temp files before a freearea(area) */
4810static void
4811freehere(area)
4812int area;
4813{
4814 register struct here *h, *hl;
4815
4816 hl = NULL;
4817 for (h = acthere; h != NULL; h = h->h_next)
4818 if (getarea((char *) h) >= area) {
4819 if (h->h_iop->io_name != NULL)
4820 unlink(h->h_iop->io_name);
4821 if (hl == NULL)
4822 acthere = h->h_next;
4823 else
4824 hl->h_next = h->h_next;
4825 } else
4826 hl = h;
4827}
4828
4829
4830
4831/*
4832 * Copyright (c) 1987,1997, Prentice Hall
4833 * All rights reserved.
4834 *
4835 * Redistribution and use of the MINIX operating system in source and
4836 * binary forms, with or without modification, are permitted provided
4837 * that the following conditions are met:
4838 *
4839 * Redistributions of source code must retain the above copyright
4840 * notice, this list of conditions and the following disclaimer.
4841 *
4842 * Redistributions in binary form must reproduce the above
4843 * copyright notice, this list of conditions and the following
4844 * disclaimer in the documentation and/or other materials provided
4845 * with the distribution.
4846 *
4847 * Neither the name of Prentice Hall nor the names of the software
4848 * authors or contributors may be used to endorse or promote
4849 * products derived from this software without specific prior
4850 * written permission.
4851 *
4852 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS, AUTHORS, AND
4853 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
4854 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
4855 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
4856 * IN NO EVENT SHALL PRENTICE HALL OR ANY AUTHORS OR CONTRIBUTORS BE
4857 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
4858 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
4859 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
4860 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
4861 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
4862 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
4863 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
4864 *
4865 */
4866