1 | /* Minimal /bin/sh for in-container use. |
2 | Copyright (C) 2018-2019 Free Software Foundation, Inc. |
3 | This file is part of the GNU C Library. |
4 | |
5 | The GNU C Library is free software; you can redistribute it and/or |
6 | modify it under the terms of the GNU Lesser General Public |
7 | License as published by the Free Software Foundation; either |
8 | version 2.1 of the License, or (at your option) any later version. |
9 | |
10 | The GNU C Library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Lesser General Public License for more details. |
14 | |
15 | You should have received a copy of the GNU Lesser General Public |
16 | License along with the GNU C Library; if not, see |
17 | <http://www.gnu.org/licenses/>. */ |
18 | |
19 | #define _FILE_OFFSET_BITS 64 |
20 | |
21 | #include <stdio.h> |
22 | #include <stdlib.h> |
23 | #include <string.h> |
24 | #include <sched.h> |
25 | #include <sys/syscall.h> |
26 | #include <unistd.h> |
27 | #include <sys/types.h> |
28 | #include <dirent.h> |
29 | #include <string.h> |
30 | #include <sys/stat.h> |
31 | #include <sys/fcntl.h> |
32 | #include <sys/file.h> |
33 | #include <sys/wait.h> |
34 | #include <stdarg.h> |
35 | #include <sys/sysmacros.h> |
36 | #include <ctype.h> |
37 | #include <utime.h> |
38 | #include <errno.h> |
39 | #include <error.h> |
40 | |
41 | #include <support/support.h> |
42 | |
43 | /* Design considerations |
44 | |
45 | General rule: optimize for developer time, not run time. |
46 | |
47 | Specifically: |
48 | |
49 | * Don't worry about slow algorithms |
50 | * Don't worry about free'ing memory |
51 | * Don't implement anything the testsuite doesn't need. |
52 | * Line and argument counts are limited, see below. |
53 | |
54 | */ |
55 | |
56 | #define MAX_ARG_COUNT 100 |
57 | #define MAX_LINE_LENGTH 1000 |
58 | |
59 | /* Debugging is enabled via --debug, which must be the first argument. */ |
60 | static int debug_mode = 0; |
61 | #define dprintf if (debug_mode) fprintf |
62 | |
63 | /* Emulate the "/bin/true" command. Arguments are ignored. */ |
64 | static int |
65 | true_func (char **argv) |
66 | { |
67 | return 0; |
68 | } |
69 | |
70 | /* Emulate the "/bin/echo" command. Options are ignored, arguments |
71 | are printed to stdout. */ |
72 | static int |
73 | echo_func (char **argv) |
74 | { |
75 | int i; |
76 | |
77 | for (i = 0; argv[i]; i++) |
78 | { |
79 | if (i > 0) |
80 | putchar (' '); |
81 | fputs (argv[i], stdout); |
82 | } |
83 | putchar ('\n'); |
84 | |
85 | return 0; |
86 | } |
87 | |
88 | /* Emulate the "/bin/cp" command. Options are ignored. Only copies |
89 | one source file to one destination file. Directory destinations |
90 | are not supported. */ |
91 | static int |
92 | copy_func (char **argv) |
93 | { |
94 | char *sname = argv[0]; |
95 | char *dname = argv[1]; |
96 | int sfd, dfd; |
97 | struct stat st; |
98 | |
99 | sfd = open (sname, O_RDONLY); |
100 | if (sfd < 0) |
101 | { |
102 | fprintf (stderr, "cp: unable to open %s for reading: %s\n" , |
103 | sname, strerror (errno)); |
104 | return 1; |
105 | } |
106 | |
107 | if (fstat (sfd, &st) < 0) |
108 | { |
109 | fprintf (stderr, "cp: unable to fstat %s: %s\n" , |
110 | sname, strerror (errno)); |
111 | return 1; |
112 | } |
113 | |
114 | dfd = open (dname, O_WRONLY | O_TRUNC | O_CREAT, 0600); |
115 | if (dfd < 0) |
116 | { |
117 | fprintf (stderr, "cp: unable to open %s for writing: %s\n" , |
118 | dname, strerror (errno)); |
119 | return 1; |
120 | } |
121 | |
122 | if (support_copy_file_range (sfd, 0, dfd, 0, st.st_size, 0) != st.st_size) |
123 | { |
124 | fprintf (stderr, "cp: cannot copy file %s to %s: %s\n" , |
125 | sname, dname, strerror (errno)); |
126 | return 1; |
127 | } |
128 | |
129 | close (sfd); |
130 | close (dfd); |
131 | |
132 | chmod (dname, st.st_mode & 0777); |
133 | |
134 | return 0; |
135 | |
136 | } |
137 | |
138 | /* This is a list of all the built-in commands we understand. */ |
139 | static struct { |
140 | const char *name; |
141 | int (*func) (char **argv); |
142 | } builtin_funcs[] = { |
143 | { "true" , true_func }, |
144 | { "echo" , echo_func }, |
145 | { "cp" , copy_func }, |
146 | { NULL, NULL } |
147 | }; |
148 | |
149 | /* Run one tokenized command. argv[0] is the command. argv is |
150 | NULL-terminated. */ |
151 | static void |
152 | run_command_array (char **argv) |
153 | { |
154 | int i, j; |
155 | pid_t pid; |
156 | int status; |
157 | int (*builtin_func) (char **args); |
158 | |
159 | if (argv[0] == NULL) |
160 | return; |
161 | |
162 | builtin_func = NULL; |
163 | |
164 | int new_stdin = 0; |
165 | int new_stdout = 1; |
166 | int new_stderr = 2; |
167 | |
168 | dprintf (stderr, "run_command_array starting\n" ); |
169 | for (i = 0; argv[i]; i++) |
170 | dprintf (stderr, " argv [%d] `%s'\n" , i, argv[i]); |
171 | |
172 | for (j = i = 0; argv[i]; i++) |
173 | { |
174 | if (strcmp (argv[i], "<" ) == 0 && argv[i + 1]) |
175 | { |
176 | new_stdin = open (argv[i + 1], O_WRONLY|O_CREAT|O_TRUNC, 0777); |
177 | ++i; |
178 | continue; |
179 | } |
180 | if (strcmp (argv[i], ">" ) == 0 && argv[i + 1]) |
181 | { |
182 | new_stdout = open (argv[i + 1], O_WRONLY|O_CREAT|O_TRUNC, 0777); |
183 | ++i; |
184 | continue; |
185 | } |
186 | if (strcmp (argv[i], ">>" ) == 0 && argv[i + 1]) |
187 | { |
188 | new_stdout = open (argv[i + 1], O_WRONLY|O_CREAT|O_APPEND, 0777); |
189 | ++i; |
190 | continue; |
191 | } |
192 | if (strcmp (argv[i], "2>" ) == 0 && argv[i + 1]) |
193 | { |
194 | new_stderr = open (argv[i + 1], O_WRONLY|O_CREAT|O_TRUNC, 0777); |
195 | ++i; |
196 | continue; |
197 | } |
198 | argv[j++] = argv[i]; |
199 | } |
200 | argv[j] = NULL; |
201 | |
202 | |
203 | for (i = 0; builtin_funcs[i].name != NULL; i++) |
204 | if (strcmp (argv[0], builtin_funcs[i].name) == 0) |
205 | builtin_func = builtin_funcs[i].func; |
206 | |
207 | dprintf (stderr, "builtin %p argv0 `%s'\n" , builtin_func, argv[0]); |
208 | |
209 | pid = fork (); |
210 | if (pid < 0) |
211 | { |
212 | fprintf (stderr, "sh: fork failed\n" ); |
213 | exit (1); |
214 | } |
215 | |
216 | if (pid == 0) |
217 | { |
218 | if (new_stdin != 0) |
219 | { |
220 | dup2 (new_stdin, 0); |
221 | close (new_stdin); |
222 | } |
223 | if (new_stdout != 1) |
224 | { |
225 | dup2 (new_stdout, 1); |
226 | close (new_stdout); |
227 | } |
228 | if (new_stderr != 2) |
229 | { |
230 | dup2 (new_stderr, 2); |
231 | close (new_stdout); |
232 | } |
233 | |
234 | if (builtin_func != NULL) |
235 | exit (builtin_func (argv + 1)); |
236 | |
237 | execvp (argv[0], argv); |
238 | |
239 | fprintf (stderr, "sh: execing %s failed: %s" , |
240 | argv[0], strerror (errno)); |
241 | exit (1); |
242 | } |
243 | |
244 | waitpid (pid, &status, 0); |
245 | |
246 | dprintf (stderr, "exiting run_command_array\n" ); |
247 | |
248 | if (WIFEXITED (status)) |
249 | { |
250 | int rv = WEXITSTATUS (status); |
251 | if (rv) |
252 | exit (rv); |
253 | } |
254 | else |
255 | exit (1); |
256 | } |
257 | |
258 | /* Run one command-as-a-string, by tokenizing it. Limited to |
259 | MAX_ARG_COUNT arguments. Simple substitution is done of $1 to $9 |
260 | (as whole separate tokens) from iargs[]. Quoted strings work if |
261 | the quotes wrap whole tokens; i.e. "foo bar" but not foo" bar". */ |
262 | static void |
263 | run_command_string (const char *cmdline, const char **iargs) |
264 | { |
265 | char *args[MAX_ARG_COUNT+1]; |
266 | int ap = 0; |
267 | const char *start, *end; |
268 | int nargs; |
269 | |
270 | for (nargs = 0; iargs[nargs] != NULL; ++nargs) |
271 | ; |
272 | |
273 | dprintf (stderr, "run_command_string starting: '%s'\n" , cmdline); |
274 | |
275 | while (ap < MAX_ARG_COUNT) |
276 | { |
277 | /* If the argument is quoted, this is the quote character, else NUL. */ |
278 | int in_quote = 0; |
279 | |
280 | /* Skip whitespace up to the next token. */ |
281 | while (*cmdline && isspace (*cmdline)) |
282 | cmdline ++; |
283 | if (*cmdline == 0) |
284 | break; |
285 | |
286 | start = cmdline; |
287 | /* Check for quoted argument. */ |
288 | in_quote = (*cmdline == '\'' || *cmdline == '"') ? *cmdline : 0; |
289 | |
290 | /* Skip to end of token; either by whitespace or matching quote. */ |
291 | dprintf (stderr, "in_quote %d\n" , in_quote); |
292 | while (*cmdline |
293 | && (!isspace (*cmdline) || in_quote)) |
294 | { |
295 | if (*cmdline == in_quote |
296 | && cmdline != start) |
297 | in_quote = 0; |
298 | dprintf (stderr, "[%c]%d " , *cmdline, in_quote); |
299 | cmdline ++; |
300 | } |
301 | dprintf (stderr, "\n" ); |
302 | |
303 | /* Allocate space for this token and store it in args[]. */ |
304 | end = cmdline; |
305 | dprintf (stderr, "start<%s> end<%s>\n" , start, end); |
306 | args[ap] = (char *) xmalloc (end - start + 1); |
307 | memcpy (args[ap], start, end - start); |
308 | args[ap][end - start] = 0; |
309 | |
310 | /* Strip off quotes, if found. */ |
311 | dprintf (stderr, "args[%d] = <%s>\n" , ap, args[ap]); |
312 | if (args[ap][0] == '\'' |
313 | && args[ap][strlen (args[ap])-1] == '\'') |
314 | { |
315 | args[ap][strlen (args[ap])-1] = 0; |
316 | args[ap] ++; |
317 | } |
318 | |
319 | else if (args[ap][0] == '"' |
320 | && args[ap][strlen (args[ap])-1] == '"') |
321 | { |
322 | args[ap][strlen (args[ap])-1] = 0; |
323 | args[ap] ++; |
324 | } |
325 | |
326 | /* Replace positional parameters like $4. */ |
327 | else if (args[ap][0] == '$' |
328 | && isdigit (args[ap][1]) |
329 | && args[ap][2] == 0) |
330 | { |
331 | int a = args[ap][1] - '1'; |
332 | if (0 <= a && a < nargs) |
333 | args[ap] = strdup (iargs[a]); |
334 | } |
335 | |
336 | ap ++; |
337 | |
338 | if (*cmdline == 0) |
339 | break; |
340 | } |
341 | |
342 | /* Lastly, NULL terminate the array and run it. */ |
343 | args[ap] = NULL; |
344 | run_command_array (args); |
345 | } |
346 | |
347 | /* Run a script by reading lines and passing them to the above |
348 | function. */ |
349 | static void |
350 | run_script (const char *filename, const char **args) |
351 | { |
352 | char line[MAX_LINE_LENGTH + 1]; |
353 | dprintf (stderr, "run_script starting: '%s'\n" , filename); |
354 | FILE *f = fopen (filename, "r" ); |
355 | if (f == NULL) |
356 | { |
357 | fprintf (stderr, "sh: %s: %s\n" , filename, strerror (errno)); |
358 | exit (1); |
359 | } |
360 | while (fgets (line, sizeof (line), f) != NULL) |
361 | { |
362 | if (line[0] == '#') |
363 | { |
364 | dprintf (stderr, "comment: %s\n" , line); |
365 | continue; |
366 | } |
367 | run_command_string (line, args); |
368 | } |
369 | fclose (f); |
370 | } |
371 | |
372 | int |
373 | main (int argc, const char **argv) |
374 | { |
375 | int i; |
376 | |
377 | if (strcmp (argv[1], "--debug" ) == 0) |
378 | { |
379 | debug_mode = 1; |
380 | --argc; |
381 | ++argv; |
382 | } |
383 | |
384 | dprintf (stderr, "container-sh starting:\n" ); |
385 | for (i = 0; i < argc; i++) |
386 | dprintf (stderr, " argv[%d] is `%s'\n" , i, argv[i]); |
387 | |
388 | if (strcmp (argv[1], "-c" ) == 0) |
389 | run_command_string (argv[2], argv+3); |
390 | else |
391 | run_script (argv[1], argv+2); |
392 | |
393 | dprintf (stderr, "normal exit 0\n" ); |
394 | return 0; |
395 | } |
396 | |