-
Notifications
You must be signed in to change notification settings - Fork 13
/
Copy pathhush.c
3679 lines (3419 loc) · 93.2 KB
/
hush.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* sh.c -- a prototype Bourne shell grammar parser
* Intended to follow the original Thompson and Ritchie
* "small and simple is beautiful" philosophy, which
* incidentally is a good match to today's BusyBox.
*
* Copyright (C) 2000,2001 Larry Doolittle <larry@doolittle.boa.org>
*
* Credits:
* The parser routines proper are all original material, first
* written Dec 2000 and Jan 2001 by Larry Doolittle.
* The execution engine, the builtins, and much of the underlying
* support has been adapted from busybox-0.49pre's lash,
* which is Copyright (C) 2000 by Lineo, Inc., and
* written by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>.
* That, in turn, is based in part on ladsh.c, by Michael K. Johnson and
* Erik W. Troan, which they placed in the public domain. I don't know
* how much of the Johnson/Troan code has survived the repeated rewrites.
* Other credits:
* b_addchr() derived from similar w_addchar function in glibc-2.2
* setup_redirect(), redirect_opt_num(), and big chunks of main()
* and many builtins derived from contributions by Erik Andersen
* miscellaneous bugfixes from Matt Kraai
*
* There are two big (and related) architecture differences between
* this parser and the lash parser. One is that this version is
* actually designed from the ground up to understand nearly all
* of the Bourne grammar. The second, consequential change is that
* the parser and input reader have been turned inside out. Now,
* the parser is in control, and asks for input as needed. The old
* way had the input reader in control, and it asked for parsing to
* take place as needed. The new way makes it much easier to properly
* handle the recursion implicit in the various substitutions, especially
* across continuation lines.
*
* Bash grammar not implemented: (how many of these were in original sh?)
* $@ (those sure look like weird quoting rules)
* $_
* ! negation operator for pipes
* &> and >& redirection of stdout+stderr
* Brace Expansion
* Tilde Expansion
* fancy forms of Parameter Expansion
* aliases
* Arithmetic Expansion
* <(list) and >(list) Process Substitution
* reserved words: case, esac, select, function
* Here Documents ( << word )
* Functions
* Major bugs:
* job handling woefully incomplete and buggy
* reserved word execution woefully incomplete and buggy
* to-do:
* port selected bugfixes from post-0.49 busybox lash - done?
* finish implementing reserved words: for, while, until, do, done
* change { and } from special chars to reserved words
* builtins: break, continue, eval, return, set, trap, ulimit
* test magic exec
* handle children going into background
* clean up recognition of null pipes
* check setting of global_argc and global_argv
* control-C handling, probably with longjmp
* follow IFS rules more precisely, including update semantics
* figure out what to do with backslash-newline
* explain why we use signal instead of sigaction
* propagate syntax errors, die on resource errors?
* continuation lines, both explicit and implicit - done?
* memory leak finding and plugging - done?
* more testing, especially quoting rules and redirection
* document how quoting rules not precisely followed for variable assignments
* maybe change map[] to use 2-bit entries
* (eventually) remove all the printf's
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#define __U_BOOT__
#ifdef __U_BOOT__
#include <malloc.h> /* malloc, free, realloc*/
#include <linux/ctype.h> /* isalpha, isdigit */
#include <common.h> /* readline */
#include <hush.h>
#include <command.h> /* find_cmd */
#ifndef CONFIG_SYS_PROMPT_HUSH_PS2
#define CONFIG_SYS_PROMPT_HUSH_PS2 "> "
#endif
#endif
#ifndef __U_BOOT__
#include <ctype.h> /* isalpha, isdigit */
#include <unistd.h> /* getpid */
#include <stdlib.h> /* getenv, atoi */
#include <string.h> /* strchr */
#include <stdio.h> /* popen etc. */
#include <glob.h> /* glob, of course */
#include <stdarg.h> /* va_list */
#include <errno.h>
#include <fcntl.h>
#include <getopt.h> /* should be pretty obvious */
#include <sys/stat.h> /* ulimit */
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
/* #include <dmalloc.h> */
#if 1
#include "busybox.h"
#include "cmdedit.h"
#else
#define applet_name "hush"
#include "standalone.h"
#define hush_main main
#undef CONFIG_FEATURE_SH_FANCY_PROMPT
#define BB_BANNER
#endif
#endif
#define SPECIAL_VAR_SYMBOL 03
#define SUBSTED_VAR_SYMBOL 04
#ifndef __U_BOOT__
#define FLAG_EXIT_FROM_LOOP 1
#define FLAG_PARSE_SEMICOLON (1 << 1) /* symbol ';' is special for parser */
#define FLAG_REPARSING (1 << 2) /* >= 2nd pass */
#endif
#ifdef __U_BOOT__
DECLARE_GLOBAL_DATA_PTR;
#define EXIT_SUCCESS 0
#define EOF -1
#define syntax() syntax_err()
#define xstrdup strdup
#define error_msg printf
#else
typedef enum {
REDIRECT_INPUT = 1,
REDIRECT_OVERWRITE = 2,
REDIRECT_APPEND = 3,
REDIRECT_HEREIS = 4,
REDIRECT_IO = 5
} redir_type;
/* The descrip member of this structure is only used to make debugging
* output pretty */
struct {int mode; int default_fd; char *descrip;} redir_table[] = {
{ 0, 0, "()" },
{ O_RDONLY, 0, "<" },
{ O_CREAT|O_TRUNC|O_WRONLY, 1, ">" },
{ O_CREAT|O_APPEND|O_WRONLY, 1, ">>" },
{ O_RDONLY, -1, "<<" },
{ O_RDWR, 1, "<>" }
};
#endif
typedef enum {
PIPE_SEQ = 1,
PIPE_AND = 2,
PIPE_OR = 3,
PIPE_BG = 4,
} pipe_style;
/* might eventually control execution */
typedef enum {
RES_NONE = 0,
RES_IF = 1,
RES_THEN = 2,
RES_ELIF = 3,
RES_ELSE = 4,
RES_FI = 5,
RES_FOR = 6,
RES_WHILE = 7,
RES_UNTIL = 8,
RES_DO = 9,
RES_DONE = 10,
RES_XXXX = 11,
RES_IN = 12,
RES_SNTX = 13
} reserved_style;
#define FLAG_END (1<<RES_NONE)
#define FLAG_IF (1<<RES_IF)
#define FLAG_THEN (1<<RES_THEN)
#define FLAG_ELIF (1<<RES_ELIF)
#define FLAG_ELSE (1<<RES_ELSE)
#define FLAG_FI (1<<RES_FI)
#define FLAG_FOR (1<<RES_FOR)
#define FLAG_WHILE (1<<RES_WHILE)
#define FLAG_UNTIL (1<<RES_UNTIL)
#define FLAG_DO (1<<RES_DO)
#define FLAG_DONE (1<<RES_DONE)
#define FLAG_IN (1<<RES_IN)
#define FLAG_START (1<<RES_XXXX)
/* This holds pointers to the various results of parsing */
struct p_context {
struct child_prog *child;
struct pipe *list_head;
struct pipe *pipe;
#ifndef __U_BOOT__
struct redir_struct *pending_redirect;
#endif
reserved_style w;
int old_flag; /* for figuring out valid reserved words */
struct p_context *stack;
int type; /* define type of parser : ";$" common or special symbol */
/* How about quoting status? */
};
#ifndef __U_BOOT__
struct redir_struct {
redir_type type; /* type of redirection */
int fd; /* file descriptor being redirected */
int dup; /* -1, or file descriptor being duplicated */
struct redir_struct *next; /* pointer to the next redirect in the list */
glob_t word; /* *word.gl_pathv is the filename */
};
#endif
struct child_prog {
#ifndef __U_BOOT__
pid_t pid; /* 0 if exited */
#endif
char **argv; /* program name and arguments */
#ifdef __U_BOOT__
int argc; /* number of program arguments */
#endif
struct pipe *group; /* if non-NULL, first in group or subshell */
#ifndef __U_BOOT__
int subshell; /* flag, non-zero if group must be forked */
struct redir_struct *redirects; /* I/O redirections */
glob_t glob_result; /* result of parameter globbing */
int is_stopped; /* is the program currently running? */
struct pipe *family; /* pointer back to the child's parent pipe */
#endif
int sp; /* number of SPECIAL_VAR_SYMBOL */
int type;
};
struct pipe {
#ifndef __U_BOOT__
int jobid; /* job number */
#endif
int num_progs; /* total number of programs in job */
#ifndef __U_BOOT__
int running_progs; /* number of programs running */
char *text; /* name of job */
char *cmdbuf; /* buffer various argv's point into */
pid_t pgrp; /* process group ID for the job */
#endif
struct child_prog *progs; /* array of commands in pipe */
struct pipe *next; /* to track background commands */
#ifndef __U_BOOT__
int stopped_progs; /* number of programs alive, but stopped */
int job_context; /* bitmask defining current context */
#endif
pipe_style followup; /* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */
reserved_style r_mode; /* supports if, for, while, until */
};
#ifndef __U_BOOT__
struct close_me {
int fd;
struct close_me *next;
};
#endif
struct variables {
char *name;
char *value;
int flg_export;
int flg_read_only;
struct variables *next;
};
/* globals, connect us to the outside world
* the first three support $?, $#, and $1 */
#ifndef __U_BOOT__
char **global_argv;
unsigned int global_argc;
#endif
static unsigned int last_return_code;
#ifndef __U_BOOT__
extern char **environ; /* This is in <unistd.h>, but protected with __USE_GNU */
#endif
/* "globals" within this file */
static uchar *ifs;
static char map[256];
#ifndef __U_BOOT__
static int fake_mode;
static int interactive;
static struct close_me *close_me_head;
static const char *cwd;
static struct pipe *job_list;
static unsigned int last_bg_pid;
static unsigned int last_jobid;
static unsigned int shell_terminal;
static char *PS1;
static char *PS2;
struct variables shell_ver = { "HUSH_VERSION", "0.01", 1, 1, 0 };
struct variables *top_vars = &shell_ver;
#else
static int flag_repeat = 0;
static int do_repeat = 0;
static struct variables *top_vars = NULL ;
#endif /*__U_BOOT__ */
#define B_CHUNK (100)
#define B_NOSPAC 1
typedef struct {
char *data;
int length;
int maxlen;
int quote;
int nonnull;
} o_string;
#define NULL_O_STRING {NULL,0,0,0,0}
/* used for initialization:
o_string foo = NULL_O_STRING; */
/* I can almost use ordinary FILE *. Is open_memstream() universally
* available? Where is it documented? */
struct in_str {
const char *p;
#ifndef __U_BOOT__
char peek_buf[2];
#endif
int __promptme;
int promptmode;
#ifndef __U_BOOT__
FILE *file;
#endif
int (*get) (struct in_str *);
int (*peek) (struct in_str *);
};
#define b_getch(input) ((input)->get(input))
#define b_peek(input) ((input)->peek(input))
#ifndef __U_BOOT__
#define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
struct built_in_command {
char *cmd; /* name */
char *descr; /* description */
int (*function) (struct child_prog *); /* function ptr */
};
#endif
/* define DEBUG_SHELL for debugging output (obviously ;-)) */
#if 0
#define DEBUG_SHELL
#endif
/* This should be in utility.c */
#ifdef DEBUG_SHELL
#ifndef __U_BOOT__
static void debug_printf(const char *format, ...)
{
va_list args;
va_start(args, format);
vfprintf(stderr, format, args);
va_end(args);
}
#else
#define debug_printf(fmt,args...) printf (fmt ,##args)
#endif
#else
static inline void debug_printf(const char *format, ...) { }
#endif
#define final_printf debug_printf
#ifdef __U_BOOT__
static void syntax_err(void) {
printf("syntax error\n");
}
#else
static void __syntax(char *file, int line) {
error_msg("syntax error %s:%d", file, line);
}
#define syntax() __syntax(__FILE__, __LINE__)
#endif
#ifdef __U_BOOT__
static void *xmalloc(size_t size);
static void *xrealloc(void *ptr, size_t size);
#else
/* Index of subroutines: */
/* function prototypes for builtins */
static int builtin_cd(struct child_prog *child);
static int builtin_env(struct child_prog *child);
static int builtin_eval(struct child_prog *child);
static int builtin_exec(struct child_prog *child);
static int builtin_exit(struct child_prog *child);
static int builtin_export(struct child_prog *child);
static int builtin_fg_bg(struct child_prog *child);
static int builtin_help(struct child_prog *child);
static int builtin_jobs(struct child_prog *child);
static int builtin_pwd(struct child_prog *child);
static int builtin_read(struct child_prog *child);
static int builtin_set(struct child_prog *child);
static int builtin_shift(struct child_prog *child);
static int builtin_source(struct child_prog *child);
static int builtin_umask(struct child_prog *child);
static int builtin_unset(struct child_prog *child);
static int builtin_not_written(struct child_prog *child);
#endif
/* o_string manipulation: */
static int b_check_space(o_string *o, int len);
static int b_addchr(o_string *o, int ch);
static void b_reset(o_string *o);
static int b_addqchr(o_string *o, int ch, int quote);
#ifndef __U_BOOT__
static int b_adduint(o_string *o, unsigned int i);
#endif
/* in_str manipulations: */
static int static_get(struct in_str *i);
static int static_peek(struct in_str *i);
static int file_get(struct in_str *i);
static int file_peek(struct in_str *i);
#ifndef __U_BOOT__
static void setup_file_in_str(struct in_str *i, FILE *f);
#else
static void setup_file_in_str(struct in_str *i);
#endif
static void setup_string_in_str(struct in_str *i, const char *s);
#ifndef __U_BOOT__
/* close_me manipulations: */
static void mark_open(int fd);
static void mark_closed(int fd);
static void close_all(void);
#endif
/* "run" the final data structures: */
static char *indenter(int i);
static int free_pipe_list(struct pipe *head, int indent);
static int free_pipe(struct pipe *pi, int indent);
/* really run the final data structures: */
#ifndef __U_BOOT__
static int setup_redirects(struct child_prog *prog, int squirrel[]);
#endif
static int run_list_real(struct pipe *pi);
#ifndef __U_BOOT__
static void pseudo_exec(struct child_prog *child) __attribute__ ((noreturn));
#endif
static int run_pipe_real(struct pipe *pi);
/* extended glob support: */
#ifndef __U_BOOT__
static int globhack(const char *src, int flags, glob_t *pglob);
static int glob_needed(const char *s);
static int xglob(o_string *dest, int flags, glob_t *pglob);
#endif
/* variable assignment: */
static int is_assignment(const char *s);
/* data structure manipulation: */
#ifndef __U_BOOT__
static int setup_redirect(struct p_context *ctx, int fd, redir_type style, struct in_str *input);
#endif
static void initialize_context(struct p_context *ctx);
static int done_word(o_string *dest, struct p_context *ctx);
static int done_command(struct p_context *ctx);
static int done_pipe(struct p_context *ctx, pipe_style type);
/* primary string parsing: */
#ifndef __U_BOOT__
static int redirect_dup_num(struct in_str *input);
static int redirect_opt_num(o_string *o);
static int process_command_subs(o_string *dest, struct p_context *ctx, struct in_str *input, int subst_end);
static int parse_group(o_string *dest, struct p_context *ctx, struct in_str *input, int ch);
#endif
static char *lookup_param(char *src);
static char *make_string(char **inp);
static int handle_dollar(o_string *dest, struct p_context *ctx, struct in_str *input);
#ifndef __U_BOOT__
static int parse_string(o_string *dest, struct p_context *ctx, const char *src);
#endif
static int parse_stream(o_string *dest, struct p_context *ctx, struct in_str *input0, int end_trigger);
/* setup: */
static int parse_stream_outer(struct in_str *inp, int flag);
#ifndef __U_BOOT__
static int parse_string_outer(const char *s, int flag);
static int parse_file_outer(FILE *f);
#endif
#ifndef __U_BOOT__
/* job management: */
static int checkjobs(struct pipe* fg_pipe);
static void insert_bg_job(struct pipe *pi);
static void remove_bg_job(struct pipe *pi);
#endif
/* local variable support */
static char **make_list_in(char **inp, char *name);
static char *insert_var_value(char *inp);
static char *insert_var_value_sub(char *inp, int tag_subst);
#ifndef __U_BOOT__
/* Table of built-in functions. They can be forked or not, depending on
* context: within pipes, they fork. As simple commands, they do not.
* When used in non-forking context, they can change global variables
* in the parent shell process. If forked, of course they can not.
* For example, 'unset foo | whatever' will parse and run, but foo will
* still be set at the end. */
static struct built_in_command bltins[] = {
{"bg", "Resume a job in the background", builtin_fg_bg},
{"break", "Exit for, while or until loop", builtin_not_written},
{"cd", "Change working directory", builtin_cd},
{"continue", "Continue for, while or until loop", builtin_not_written},
{"env", "Print all environment variables", builtin_env},
{"eval", "Construct and run shell command", builtin_eval},
{"exec", "Exec command, replacing this shell with the exec'd process",
builtin_exec},
{"exit", "Exit from shell()", builtin_exit},
{"export", "Set environment variable", builtin_export},
{"fg", "Bring job into the foreground", builtin_fg_bg},
{"jobs", "Lists the active jobs", builtin_jobs},
{"pwd", "Print current directory", builtin_pwd},
{"read", "Input environment variable", builtin_read},
{"return", "Return from a function", builtin_not_written},
{"set", "Set/unset shell local variables", builtin_set},
{"shift", "Shift positional parameters", builtin_shift},
{"trap", "Trap signals", builtin_not_written},
{"ulimit","Controls resource limits", builtin_not_written},
{"umask","Sets file creation mask", builtin_umask},
{"unset", "Unset environment variable", builtin_unset},
{".", "Source-in and run commands in a file", builtin_source},
{"help", "List shell built-in commands", builtin_help},
{NULL, NULL, NULL}
};
static const char *set_cwd(void)
{
if(cwd==unknown)
cwd = NULL; /* xgetcwd(arg) called free(arg) */
cwd = xgetcwd((char *)cwd);
if (!cwd)
cwd = unknown;
return cwd;
}
/* built-in 'eval' handler */
static int builtin_eval(struct child_prog *child)
{
char *str = NULL;
int rcode = EXIT_SUCCESS;
if (child->argv[1]) {
str = make_string(child->argv + 1);
parse_string_outer(str, FLAG_EXIT_FROM_LOOP |
FLAG_PARSE_SEMICOLON);
free(str);
rcode = last_return_code;
}
return rcode;
}
/* built-in 'cd <path>' handler */
static int builtin_cd(struct child_prog *child)
{
char *newdir;
if (child->argv[1] == NULL)
newdir = getenv("HOME");
else
newdir = child->argv[1];
if (chdir(newdir)) {
printf("cd: %s: %s\n", newdir, strerror(errno));
return EXIT_FAILURE;
}
set_cwd();
return EXIT_SUCCESS;
}
/* built-in 'env' handler */
static int builtin_env(struct child_prog *dummy)
{
char **e = environ;
if (e == NULL) return EXIT_FAILURE;
for (; *e; e++) {
puts(*e);
}
return EXIT_SUCCESS;
}
/* built-in 'exec' handler */
static int builtin_exec(struct child_prog *child)
{
if (child->argv[1] == NULL)
return EXIT_SUCCESS; /* Really? */
child->argv++;
pseudo_exec(child);
/* never returns */
}
/* built-in 'exit' handler */
static int builtin_exit(struct child_prog *child)
{
if (child->argv[1] == NULL)
exit(last_return_code);
exit (atoi(child->argv[1]));
}
/* built-in 'export VAR=value' handler */
static int builtin_export(struct child_prog *child)
{
int res = 0;
char *name = child->argv[1];
if (name == NULL) {
return (builtin_env(child));
}
name = strdup(name);
if(name) {
char *value = strchr(name, '=');
if (!value) {
char *tmp;
/* They are exporting something without an =VALUE */
value = get_local_var(name);
if (value) {
size_t ln = strlen(name);
tmp = realloc(name, ln+strlen(value)+2);
if(tmp==NULL)
res = -1;
else {
sprintf(tmp+ln, "=%s", value);
name = tmp;
}
} else {
/* bash does not return an error when trying to export
* an undefined variable. Do likewise. */
res = 1;
}
}
}
if (res<0)
perror_msg("export");
else if(res==0)
res = set_local_var(name, 1);
else
res = 0;
free(name);
return res;
}
/* built-in 'fg' and 'bg' handler */
static int builtin_fg_bg(struct child_prog *child)
{
int i, jobnum;
struct pipe *pi=NULL;
if (!interactive)
return EXIT_FAILURE;
/* If they gave us no args, assume they want the last backgrounded task */
if (!child->argv[1]) {
for (pi = job_list; pi; pi = pi->next) {
if (pi->jobid == last_jobid) {
break;
}
}
if (!pi) {
error_msg("%s: no current job", child->argv[0]);
return EXIT_FAILURE;
}
} else {
if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) {
error_msg("%s: bad argument '%s'", child->argv[0], child->argv[1]);
return EXIT_FAILURE;
}
for (pi = job_list; pi; pi = pi->next) {
if (pi->jobid == jobnum) {
break;
}
}
if (!pi) {
error_msg("%s: %d: no such job", child->argv[0], jobnum);
return EXIT_FAILURE;
}
}
if (*child->argv[0] == 'f') {
/* Put the job into the foreground. */
tcsetpgrp(shell_terminal, pi->pgrp);
}
/* Restart the processes in the job */
for (i = 0; i < pi->num_progs; i++)
pi->progs[i].is_stopped = 0;
if ( (i=kill(- pi->pgrp, SIGCONT)) < 0) {
if (i == ESRCH) {
remove_bg_job(pi);
} else {
perror_msg("kill (SIGCONT)");
}
}
pi->stopped_progs = 0;
return EXIT_SUCCESS;
}
/* built-in 'help' handler */
static int builtin_help(struct child_prog *dummy)
{
struct built_in_command *x;
printf("\nBuilt-in commands:\n");
printf("-------------------\n");
for (x = bltins; x->cmd; x++) {
if (x->descr==NULL)
continue;
printf("%s\t%s\n", x->cmd, x->descr);
}
printf("\n\n");
return EXIT_SUCCESS;
}
/* built-in 'jobs' handler */
static int builtin_jobs(struct child_prog *child)
{
struct pipe *job;
char *status_string;
for (job = job_list; job; job = job->next) {
if (job->running_progs == job->stopped_progs)
status_string = "Stopped";
else
status_string = "Running";
printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
}
return EXIT_SUCCESS;
}
/* built-in 'pwd' handler */
static int builtin_pwd(struct child_prog *dummy)
{
puts(set_cwd());
return EXIT_SUCCESS;
}
/* built-in 'read VAR' handler */
static int builtin_read(struct child_prog *child)
{
int res;
if (child->argv[1]) {
char string[BUFSIZ];
char *var = 0;
string[0] = 0; /* In case stdin has only EOF */
/* read string */
fgets(string, sizeof(string), stdin);
chomp(string);
var = malloc(strlen(child->argv[1])+strlen(string)+2);
if(var) {
sprintf(var, "%s=%s", child->argv[1], string);
res = set_local_var(var, 0);
} else
res = -1;
if (res)
fprintf(stderr, "read: %m\n");
free(var); /* So not move up to avoid breaking errno */
return res;
} else {
do res=getchar(); while(res!='\n' && res!=EOF);
return 0;
}
}
/* built-in 'set VAR=value' handler */
static int builtin_set(struct child_prog *child)
{
char *temp = child->argv[1];
struct variables *e;
if (temp == NULL)
for(e = top_vars; e; e=e->next)
printf("%s=%s\n", e->name, e->value);
else
set_local_var(temp, 0);
return EXIT_SUCCESS;
}
/* Built-in 'shift' handler */
static int builtin_shift(struct child_prog *child)
{
int n=1;
if (child->argv[1]) {
n=atoi(child->argv[1]);
}
if (n>=0 && n<global_argc) {
/* XXX This probably breaks $0 */
global_argc -= n;
global_argv += n;
return EXIT_SUCCESS;
} else {
return EXIT_FAILURE;
}
}
/* Built-in '.' handler (read-in and execute commands from file) */
static int builtin_source(struct child_prog *child)
{
FILE *input;
int status;
if (child->argv[1] == NULL)
return EXIT_FAILURE;
/* XXX search through $PATH is missing */
input = fopen(child->argv[1], "r");
if (!input) {
error_msg("Couldn't open file '%s'", child->argv[1]);
return EXIT_FAILURE;
}
/* Now run the file */
/* XXX argv and argc are broken; need to save old global_argv
* (pointer only is OK!) on this stack frame,
* set global_argv=child->argv+1, recurse, and restore. */
mark_open(fileno(input));
status = parse_file_outer(input);
mark_closed(fileno(input));
fclose(input);
return (status);
}
static int builtin_umask(struct child_prog *child)
{
mode_t new_umask;
const char *arg = child->argv[1];
char *end;
if (arg) {
new_umask=strtoul(arg, &end, 8);
if (*end!='\0' || end == arg) {
return EXIT_FAILURE;
}
} else {
printf("%.3o\n", (unsigned int) (new_umask=umask(0)));
}
umask(new_umask);
return EXIT_SUCCESS;
}
/* built-in 'unset VAR' handler */
static int builtin_unset(struct child_prog *child)
{
/* bash returned already true */
unset_local_var(child->argv[1]);
return EXIT_SUCCESS;
}
static int builtin_not_written(struct child_prog *child)
{
printf("builtin_%s not written\n",child->argv[0]);
return EXIT_FAILURE;
}
#endif
static int b_check_space(o_string *o, int len)
{
/* It would be easy to drop a more restrictive policy
* in here, such as setting a maximum string length */
if (o->length + len > o->maxlen) {
char *old_data = o->data;
/* assert (data == NULL || o->maxlen != 0); */
o->maxlen += max(2*len, B_CHUNK);
o->data = realloc(o->data, 1 + o->maxlen);
if (o->data == NULL) {
free(old_data);
}
}
return o->data == NULL;
}
static int b_addchr(o_string *o, int ch)
{
debug_printf("b_addchr: %c %d %p\n", ch, o->length, o);
if (b_check_space(o, 1)) return B_NOSPAC;
o->data[o->length] = ch;
o->length++;
o->data[o->length] = '\0';
return 0;
}
static void b_reset(o_string *o)
{
o->length = 0;
o->nonnull = 0;
if (o->data != NULL) *o->data = '\0';
}
static void b_free(o_string *o)
{
b_reset(o);
free(o->data);
o->data = NULL;
o->maxlen = 0;
}
/* My analysis of quoting semantics tells me that state information
* is associated with a destination, not a source.
*/
static int b_addqchr(o_string *o, int ch, int quote)
{
if (quote && strchr("*?[\\",ch)) {
int rc;
rc = b_addchr(o, '\\');
if (rc) return rc;
}
return b_addchr(o, ch);
}
#ifndef __U_BOOT__
static int b_adduint(o_string *o, unsigned int i)
{
int r;
char *p = simple_itoa(i);
/* no escape checking necessary */
do r=b_addchr(o, *p++); while (r==0 && *p);
return r;
}
#endif
static int static_get(struct in_str *i)
{
int ch = *i->p++;
if (ch=='\0') return EOF;
return ch;
}
static int static_peek(struct in_str *i)
{
return *i->p;
}
#ifndef __U_BOOT__
static inline void cmdedit_set_initial_prompt(void)
{
#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
PS1 = NULL;
#else
PS1 = getenv("PS1");
if(PS1==0)
PS1 = "\\w \\$ ";
#endif
}
static inline void setup_prompt_string(int promptmode, char **prompt_str)
{
debug_printf("setup_prompt_string %d ",promptmode);
#ifndef CONFIG_FEATURE_SH_FANCY_PROMPT
/* Set up the prompt */
if (promptmode == 1) {
free(PS1);
PS1=xmalloc(strlen(cwd)+4);
sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ? "$ ":"# ");
*prompt_str = PS1;
} else {
*prompt_str = PS2;
}
#else
*prompt_str = (promptmode==1)? PS1 : PS2;
#endif
debug_printf("result %s\n",*prompt_str);
}
#endif
static void get_user_input(struct in_str *i)
{
#ifndef __U_BOOT__
char *prompt_str;
static char the_command[BUFSIZ];
setup_prompt_string(i->promptmode, &prompt_str);
#ifdef CONFIG_FEATURE_COMMAND_EDITING
/*
** enable command line editing only while a command line
** is actually being read; otherwise, we'll end up bequeathing
** atexit() handlers and other unwanted stuff to our
** child processes (rob@sysgo.de)
*/
cmdedit_read_input(prompt_str, the_command);
#else
fputs(prompt_str, stdout);
fflush(stdout);