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
|
/* vi: set ts=4 :
*
* bbsh - busybox shell
*
* Copyright 2006 Rob Landley <rob@landley.net>
*
* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
*/
// A section of code that gets repeatedly or conditionally executed is stored
// as a string and parsed each time it's run.
// Wheee, debugging.
// Terminal control
#define ENABLE_BBSH_TTY 0
// &, fg, bg, jobs. (ctrl-z with tty.)
#define ENABLE_BBSH_JOBCTL 0
// Flow control (if, while, for, functions { })
#define ENABLE_BBSH_FLOWCTL 0
#define ENABLE_BBSH_ENVVARS 0 // Environment variable support
// Local and synthetic variables, fancy prompts, set, $?, etc.
#define ENABLE_BBSH_LOCALVARS 0
// Pipes and redirects: | > < >> << && || & () ;
#define ENABLE_BBSH_PIPES 0
/* Fun:
echo `echo hello#comment " woot` and more
*/
#include "busybox.h"
// A single executable, its arguments, and other information we know about it.
#define BBSH_FLAG_EXIT 1
#define BBSH_FLAG_SUSPEND 2
#define BBSH_FLAG_PIPE 4
#define BBSH_FLAG_AND 8
#define BBSH_FLAG_OR 16
#define BBSH_FLAG_AMP 32
#define BBSH_FLAG_SEMI 64
#define BBSH_FLAG_PAREN 128
// What we know about a single process.
struct command {
struct command *next;
int flags; // exit, suspend, && ||
int pid; // pid (or exit code)
int argc;
char *argv[0];
};
// A collection of processes piped into/waiting on each other.
struct pipeline {
struct pipeline *next;
int job_id;
struct command *cmd;
char *cmdline;
int cmdlinelen;
};
static void free_list(void *list, void (*freeit)(void *data))
{
while(list) {
void **next = (void **)list;
void *list_next = *next;
freeit(list);
free(list);
list = list_next;
}
}
// Parse one word from the command line, appending one or more argv[] entries
// to struct command. Handles environment variable substitution and
// substrings. Returns pointer to next used byte, or NULL if it
// hit an ending token.
static char *parse_word(char *start, struct command **cmd)
{
char *end;
// Detect end of line (and truncate line at comment)
if (ENABLE_BBSH_PIPES && strchr("><&|(;", *start)) return 0;
// Grab next word. (Add dequote and envvar logic here)
end = start;
end = skip_non_whitespace(end);
(*cmd)->argv[(*cmd)->argc++] = xstrndup(start, end-start);
// Allocate more space if there's no room for NULL terminator.
if (!((*cmd)->argc & 7))
*cmd = xrealloc(*cmd,
sizeof(struct command) + ((*cmd)->argc+8)*sizeof(char *));
(*cmd)->argv[(*cmd)->argc] = 0;
return end;
}
// Parse a line of text into a pipeline.
// Returns a pointer to the next line.
static char *parse_pipeline(char *cmdline, struct pipeline *line)
{
struct command **cmd = &(line->cmd);
char *start = line->cmdline = cmdline;
if (!cmdline) return 0;
if (ENABLE_BBSH_JOBCTL) line->cmdline = cmdline;
// Parse command into argv[]
for (;;) {
char *end;
// Skip leading whitespace and detect end of line.
start = skip_whitespace(start);
if (!*start || *start=='#') {
if (ENABLE_BBSH_JOBCTL) line->cmdlinelen = start-cmdline;
return 0;
}
// Allocate next command structure if necessary
if (!*cmd) *cmd = xzalloc(sizeof(struct command)+8*sizeof(char *));
// Parse next argument and add the results to argv[]
end = parse_word(start, cmd);
// If we hit the end of this command, how did it end?
if (!end) {
if (ENABLE_BBSH_PIPES && *start) {
if (*start==';') {
start++;
break;
}
// handle | & < > >> << || &&
}
break;
}
start = end;
}
if (ENABLE_BBSH_JOBCTL) line->cmdlinelen = start-cmdline;
return start;
}
// Execute the commands in a pipeline
static int run_pipeline(struct pipeline *line)
{
struct command *cmd = line->cmd;
if (!cmd || !cmd->argc) return 0;
// Handle local commands. This is totally fake and plastic.
if (cmd->argc==2 && !strcmp(cmd->argv[0],"cd"))
chdir(cmd->argv[1]);
else if(!strcmp(cmd->argv[0],"exit"))
exit(cmd->argc>1 ? atoi(cmd->argv[1]) : 0);
else {
int status;
pid_t pid=fork();
if(!pid) {
run_applet_and_exit(cmd->argv[0],cmd->argc,cmd->argv);
execvp(cmd->argv[0],cmd->argv);
printf("No %s",cmd->argv[0]);
exit(1);
} else waitpid(pid, &status, 0);
}
return 0;
}
static void free_cmd(void *data)
{
struct command *cmd=(struct command *)data;
while(cmd->argc) free(cmd->argv[--cmd->argc]);
}
static void handle(char *command)
{
struct pipeline line;
char *start = command;
for (;;) {
memset(&line,0,sizeof(struct pipeline));
start = parse_pipeline(start, &line);
if (!line.cmd) break;
run_pipeline(&line);
free_list(line.cmd, free_cmd);
}
}
int bbsh_main(int argc, char **argv);
int bbsh_main(int argc, char **argv)
{
char *command=NULL;
FILE *f;
getopt32(argc, argv, "c:", &command);
f = argv[optind] ? xfopen(argv[optind],"r") : NULL;
if (command) handle(command);
else {
unsigned cmdlen=0;
for (;;) {
if(!f) putchar('$');
if(1 > getline(&command, &cmdlen,f ? : stdin)) break;
handle(command);
}
if (ENABLE_FEATURE_CLEAN_UP) free(command);
}
return 1;
}
|
