blob: bb7e905dbf151567aa405c0d6169ee360eaf1be6
1 | /* vi: set sw=4 ts=4: */ |
2 | /* |
3 | * Utility routines. |
4 | * |
5 | * Copyright (C) tons of folks. Tracking down who wrote what |
6 | * isn't something I'm going to worry about... If you wrote something |
7 | * here, please feel free to acknowledge your work. |
8 | * |
9 | * Based in part on code from sash, Copyright (c) 1999 by David I. Bell |
10 | * Permission has been granted to redistribute this code under GPL. |
11 | * |
12 | * Licensed under GPLv2 or later, see file LICENSE in this source tree. |
13 | */ |
14 | |
15 | /* We are trying to not use printf, this benefits the case when selected |
16 | * applets are really simple. Example: |
17 | * |
18 | * $ ./busybox |
19 | * ... |
20 | * Currently defined functions: |
21 | * basename, false, true |
22 | * |
23 | * $ size busybox |
24 | * text data bss dec hex filename |
25 | * 4473 52 72 4597 11f5 busybox |
26 | * |
27 | * FEATURE_INSTALLER or FEATURE_SUID will still link printf routines in. :( |
28 | */ |
29 | #include "busybox.h" |
30 | |
31 | #if !(defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) \ |
32 | || defined(__APPLE__) \ |
33 | ) |
34 | # include <malloc.h> /* for mallopt */ |
35 | #endif |
36 | |
37 | |
38 | /* Declare <applet>_main() */ |
39 | #define PROTOTYPES |
40 | #include "applets.h" |
41 | #undef PROTOTYPES |
42 | |
43 | /* Include generated applet names, pointers to <applet>_main, etc */ |
44 | #include "applet_tables.h" |
45 | /* ...and if applet_tables generator says we have only one applet... */ |
46 | #ifdef SINGLE_APPLET_MAIN |
47 | # undef ENABLE_FEATURE_INDIVIDUAL |
48 | # define ENABLE_FEATURE_INDIVIDUAL 1 |
49 | # undef IF_FEATURE_INDIVIDUAL |
50 | # define IF_FEATURE_INDIVIDUAL(...) __VA_ARGS__ |
51 | #endif |
52 | |
53 | #include "usage_compressed.h" |
54 | |
55 | #if ENABLE_SHOW_USAGE && !ENABLE_FEATURE_COMPRESS_USAGE |
56 | static const char usage_messages[] ALIGN1 = UNPACKED_USAGE; |
57 | #else |
58 | # define usage_messages 0 |
59 | #endif |
60 | |
61 | #if ENABLE_FEATURE_COMPRESS_USAGE |
62 | |
63 | static const char packed_usage[] ALIGN1 = { PACKED_USAGE }; |
64 | # include "bb_archive.h" |
65 | static const char *unpack_usage_messages(void) |
66 | { |
67 | char *outbuf = NULL; |
68 | bunzip_data *bd; |
69 | int i; |
70 | |
71 | i = start_bunzip(&bd, |
72 | /* src_fd: */ -1, |
73 | /* inbuf: */ packed_usage, |
74 | /* len: */ sizeof(packed_usage)); |
75 | /* read_bunzip can longjmp to start_bunzip, and ultimately |
76 | * end up here with i != 0 on read data errors! Not trivial */ |
77 | if (!i) { |
78 | /* Cannot use xmalloc: will leak bd in NOFORK case! */ |
79 | outbuf = malloc_or_warn(sizeof(UNPACKED_USAGE)); |
80 | if (outbuf) |
81 | read_bunzip(bd, outbuf, sizeof(UNPACKED_USAGE)); |
82 | } |
83 | dealloc_bunzip(bd); |
84 | return outbuf; |
85 | } |
86 | # define dealloc_usage_messages(s) free(s) |
87 | |
88 | #else |
89 | |
90 | # define unpack_usage_messages() usage_messages |
91 | # define dealloc_usage_messages(s) ((void)(s)) |
92 | |
93 | #endif /* FEATURE_COMPRESS_USAGE */ |
94 | |
95 | |
96 | void FAST_FUNC bb_show_usage(void) |
97 | { |
98 | if (ENABLE_SHOW_USAGE) { |
99 | #ifdef SINGLE_APPLET_STR |
100 | /* Imagine that this applet is "true". Dont suck in printf! */ |
101 | const char *usage_string = unpack_usage_messages(); |
102 | |
103 | if (*usage_string == '\b') { |
104 | full_write2_str("No help available.\n\n"); |
105 | } else { |
106 | full_write2_str("Usage: "SINGLE_APPLET_STR" "); |
107 | full_write2_str(usage_string); |
108 | full_write2_str("\n\n"); |
109 | } |
110 | if (ENABLE_FEATURE_CLEAN_UP) |
111 | dealloc_usage_messages((char*)usage_string); |
112 | #else |
113 | const char *p; |
114 | const char *usage_string = p = unpack_usage_messages(); |
115 | int ap = find_applet_by_name(applet_name); |
116 | |
117 | if (ap < 0) /* never happens, paranoia */ |
118 | xfunc_die(); |
119 | while (ap) { |
120 | while (*p++) continue; |
121 | ap--; |
122 | } |
123 | full_write2_str(bb_banner); |
124 | full_write2_str(" multi-call binary.\n"); |
125 | if (*p == '\b') |
126 | full_write2_str("\nNo help available.\n\n"); |
127 | else { |
128 | full_write2_str("\nUsage: "); |
129 | full_write2_str(applet_name); |
130 | full_write2_str(" "); |
131 | full_write2_str(p); |
132 | full_write2_str("\n"); |
133 | } |
134 | if (ENABLE_FEATURE_CLEAN_UP) |
135 | dealloc_usage_messages((char*)usage_string); |
136 | #endif |
137 | } |
138 | xfunc_die(); |
139 | } |
140 | |
141 | int FAST_FUNC find_applet_by_name(const char *name) |
142 | { |
143 | unsigned i, max; |
144 | int j; |
145 | const char *p; |
146 | |
147 | /* The commented-out word-at-a-time code is ~40% faster, but +160 bytes. |
148 | * "Faster" here saves ~0.5 microsecond of real time - not worth it. |
149 | */ |
150 | #if 0 /*BB_UNALIGNED_MEMACCESS_OK && BB_LITTLE_ENDIAN*/ |
151 | uint32_t n32; |
152 | |
153 | /* Handle all names < 2 chars long early */ |
154 | if (name[0] == '\0') |
155 | return -1; /* "" is not a valid applet name */ |
156 | if (name[1] == '\0') { |
157 | if (!ENABLE_TEST) |
158 | return -1; /* 1-char name is not valid */ |
159 | if (name[0] != ']') |
160 | return -1; /* 1-char name which isn't "[" is not valid */ |
161 | /* applet "[" is always applet #0: */ |
162 | return 0; |
163 | } |
164 | #endif |
165 | |
166 | p = applet_names; |
167 | i = 0; |
168 | #if KNOWN_APPNAME_OFFSETS <= 0 |
169 | max = NUM_APPLETS; |
170 | #else |
171 | max = NUM_APPLETS * KNOWN_APPNAME_OFFSETS; |
172 | for (j = ARRAY_SIZE(applet_nameofs)-1; j >= 0; j--) { |
173 | const char *pp = applet_names + applet_nameofs[j]; |
174 | if (strcmp(name, pp) >= 0) { |
175 | //bb_error_msg("name:'%s' >= pp:'%s'", name, pp); |
176 | p = pp; |
177 | i = max - NUM_APPLETS; |
178 | break; |
179 | } |
180 | max -= NUM_APPLETS; |
181 | } |
182 | max /= (unsigned)KNOWN_APPNAME_OFFSETS; |
183 | i /= (unsigned)KNOWN_APPNAME_OFFSETS; |
184 | //bb_error_msg("name:'%s' starting from:'%s' i:%u max:%u", name, p, i, max); |
185 | #endif |
186 | |
187 | /* Open-coded linear search without strcmp/strlen calls for speed */ |
188 | |
189 | #if 0 /*BB_UNALIGNED_MEMACCESS_OK && BB_LITTLE_ENDIAN*/ |
190 | /* skip "[\0" name, it's surely not it */ |
191 | if (ENABLE_TEST && LONE_CHAR(p, '[')) |
192 | i++, p += 2; |
193 | /* All remaining applet names in p[] are at least 2 chars long */ |
194 | /* name[] is also at least 2 chars long */ |
195 | |
196 | n32 = (name[0] << 0) | (name[1] << 8) | (name[2] << 16); |
197 | while (i < max) { |
198 | uint32_t p32; |
199 | char ch; |
200 | |
201 | /* Quickly check match of the first 3 bytes */ |
202 | move_from_unaligned32(p32, p); |
203 | p += 3; |
204 | if ((p32 & 0x00ffffff) != n32) { |
205 | /* Most likely case: 3 first bytes do not match */ |
206 | i++; |
207 | if ((p32 & 0x00ff0000) == '\0') |
208 | continue; // p[2] was NUL |
209 | p++; |
210 | if ((p32 & 0xff000000) == '\0') |
211 | continue; // p[3] was NUL |
212 | /* p[0..3] aren't matching and none is NUL, check the rest */ |
213 | while (*p++ != '\0') |
214 | continue; |
215 | continue; |
216 | } |
217 | |
218 | /* Unlikely branch: first 3 bytes ([0..2]) match */ |
219 | if ((p32 & 0x00ff0000) == '\0') { |
220 | /* name is 2-byte long, it is full match */ |
221 | //bb_error_msg("found:'%s' i:%u", name, i); |
222 | return i; |
223 | } |
224 | /* Check remaining bytes [3..NUL] */ |
225 | ch = (p32 >> 24); |
226 | j = 3; |
227 | while (ch == name[j]) { |
228 | if (ch == '\0') { |
229 | //bb_error_msg("found:'%s' i:%u", name, i); |
230 | return i; |
231 | } |
232 | ch = *++p; |
233 | j++; |
234 | } |
235 | /* Not a match. Skip it, including NUL */ |
236 | while (ch != '\0') |
237 | ch = *++p; |
238 | p++; |
239 | i++; |
240 | } |
241 | return -1; |
242 | #else |
243 | while (i < max) { |
244 | char ch; |
245 | j = 0; |
246 | /* Do we see "name\0" in applet_names[p] position? */ |
247 | while ((ch = *p) == name[j]) { |
248 | if (ch == '\0') { |
249 | //bb_error_msg("found:'%s' i:%u", name, i); |
250 | return i; /* yes */ |
251 | } |
252 | p++; |
253 | j++; |
254 | } |
255 | /* No. |
256 | * p => 1st non-matching char in applet_names[], |
257 | * skip to and including NUL. |
258 | */ |
259 | while (ch != '\0') |
260 | ch = *++p; |
261 | p++; |
262 | i++; |
263 | } |
264 | return -1; |
265 | #endif |
266 | } |
267 | |
268 | |
269 | void lbb_prepare(const char *applet |
270 | IF_FEATURE_INDIVIDUAL(, char **argv)) |
271 | MAIN_EXTERNALLY_VISIBLE; |
272 | void lbb_prepare(const char *applet |
273 | IF_FEATURE_INDIVIDUAL(, char **argv)) |
274 | { |
275 | #ifdef __GLIBC__ |
276 | (*(int **)&bb_errno) = __errno_location(); |
277 | barrier(); |
278 | #endif |
279 | applet_name = applet; |
280 | |
281 | if (ENABLE_LOCALE_SUPPORT) |
282 | setlocale(LC_ALL, ""); |
283 | |
284 | #if ENABLE_FEATURE_INDIVIDUAL |
285 | /* Redundant for busybox (run_applet_and_exit covers that case) |
286 | * but needed for "individual applet" mode */ |
287 | if (argv[1] |
288 | && !argv[2] |
289 | && strcmp(argv[1], "--help") == 0 |
290 | && !is_prefixed_with(applet, "busybox") |
291 | ) { |
292 | /* Special case. POSIX says "test --help" |
293 | * should be no different from e.g. "test --foo". */ |
294 | if (!ENABLE_TEST || strcmp(applet_name, "test") != 0) |
295 | bb_show_usage(); |
296 | } |
297 | #endif |
298 | } |
299 | |
300 | /* The code below can well be in applets/applets.c, as it is used only |
301 | * for busybox binary, not "individual" binaries. |
302 | * However, keeping it here and linking it into libbusybox.so |
303 | * (together with remaining tiny applets/applets.o) |
304 | * makes it possible to avoid --whole-archive at link time. |
305 | * This makes (shared busybox) + libbusybox smaller. |
306 | * (--gc-sections would be even better....) |
307 | */ |
308 | |
309 | const char *applet_name; |
310 | #if !BB_MMU |
311 | bool re_execed; |
312 | #endif |
313 | |
314 | |
315 | /* If not built as a single-applet executable... */ |
316 | #if !defined(SINGLE_APPLET_MAIN) |
317 | |
318 | IF_FEATURE_SUID(static uid_t ruid;) /* real uid */ |
319 | |
320 | # if ENABLE_FEATURE_SUID_CONFIG |
321 | |
322 | static struct suid_config_t { |
323 | /* next ptr must be first: this struct needs to be llist-compatible */ |
324 | struct suid_config_t *m_next; |
325 | struct bb_uidgid_t m_ugid; |
326 | int m_applet; |
327 | mode_t m_mode; |
328 | } *suid_config; |
329 | |
330 | static bool suid_cfg_readable; |
331 | |
332 | /* check if u is member of group g */ |
333 | static int ingroup(uid_t u, gid_t g) |
334 | { |
335 | struct group *grp = getgrgid(g); |
336 | if (grp) { |
337 | char **mem; |
338 | for (mem = grp->gr_mem; *mem; mem++) { |
339 | struct passwd *pwd = getpwnam(*mem); |
340 | if (pwd && (pwd->pw_uid == u)) |
341 | return 1; |
342 | } |
343 | } |
344 | return 0; |
345 | } |
346 | |
347 | /* libbb candidate */ |
348 | static char *get_trimmed_slice(char *s, char *e) |
349 | { |
350 | /* First, consider the value at e to be nul and back up until we |
351 | * reach a non-space char. Set the char after that (possibly at |
352 | * the original e) to nul. */ |
353 | while (e-- > s) { |
354 | if (!isspace(*e)) { |
355 | break; |
356 | } |
357 | } |
358 | e[1] = '\0'; |
359 | |
360 | /* Next, advance past all leading space and return a ptr to the |
361 | * first non-space char; possibly the terminating nul. */ |
362 | return skip_whitespace(s); |
363 | } |
364 | |
365 | static void parse_config_file(void) |
366 | { |
367 | /* Don't depend on the tools to combine strings. */ |
368 | static const char config_file[] ALIGN1 = "/etc/busybox.conf"; |
369 | |
370 | struct suid_config_t *sct_head; |
371 | int applet_no; |
372 | FILE *f; |
373 | const char *errmsg; |
374 | unsigned lc; |
375 | smallint section; |
376 | struct stat st; |
377 | |
378 | ruid = getuid(); |
379 | if (ruid == 0) /* run by root - don't need to even read config file */ |
380 | return; |
381 | |
382 | if ((stat(config_file, &st) != 0) /* No config file? */ |
383 | || !S_ISREG(st.st_mode) /* Not a regular file? */ |
384 | || (st.st_uid != 0) /* Not owned by root? */ |
385 | || (st.st_mode & (S_IWGRP | S_IWOTH)) /* Writable by non-root? */ |
386 | || !(f = fopen_for_read(config_file)) /* Cannot open? */ |
387 | ) { |
388 | return; |
389 | } |
390 | |
391 | suid_cfg_readable = 1; |
392 | sct_head = NULL; |
393 | section = lc = 0; |
394 | |
395 | while (1) { |
396 | char buffer[256]; |
397 | char *s; |
398 | |
399 | if (!fgets(buffer, sizeof(buffer), f)) { /* Are we done? */ |
400 | // Looks like bloat |
401 | //if (ferror(f)) { /* Make sure it wasn't a read error. */ |
402 | // errmsg = "reading"; |
403 | // goto pe_label; |
404 | //} |
405 | fclose(f); |
406 | suid_config = sct_head; /* Success, so set the pointer. */ |
407 | return; |
408 | } |
409 | |
410 | s = buffer; |
411 | lc++; /* Got a (partial) line. */ |
412 | |
413 | /* If a line is too long for our buffer, we consider it an error. |
414 | * The following test does mistreat one corner case though. |
415 | * If the final line of the file does not end with a newline and |
416 | * yet exactly fills the buffer, it will be treated as too long |
417 | * even though there isn't really a problem. But it isn't really |
418 | * worth adding code to deal with such an unlikely situation, and |
419 | * we do err on the side of caution. Besides, the line would be |
420 | * too long if it did end with a newline. */ |
421 | if (!strchr(s, '\n') && !feof(f)) { |
422 | errmsg = "line too long"; |
423 | goto pe_label; |
424 | } |
425 | |
426 | /* Trim leading and trailing whitespace, ignoring comments, and |
427 | * check if the resulting string is empty. */ |
428 | s = get_trimmed_slice(s, strchrnul(s, '#')); |
429 | if (!*s) { |
430 | continue; |
431 | } |
432 | |
433 | /* Check for a section header. */ |
434 | |
435 | if (*s == '[') { |
436 | /* Unlike the old code, we ignore leading and trailing |
437 | * whitespace for the section name. We also require that |
438 | * there are no stray characters after the closing bracket. */ |
439 | char *e = strchr(s, ']'); |
440 | if (!e /* Missing right bracket? */ |
441 | || e[1] /* Trailing characters? */ |
442 | || !*(s = get_trimmed_slice(s+1, e)) /* Missing name? */ |
443 | ) { |
444 | errmsg = "section header"; |
445 | goto pe_label; |
446 | } |
447 | /* Right now we only have one section so just check it. |
448 | * If more sections are added in the future, please don't |
449 | * resort to cascading ifs with multiple strcasecmp calls. |
450 | * That kind of bloated code is all too common. A loop |
451 | * and a string table would be a better choice unless the |
452 | * number of sections is very small. */ |
453 | if (strcasecmp(s, "SUID") == 0) { |
454 | section = 1; |
455 | continue; |
456 | } |
457 | section = -1; /* Unknown section so set to skip. */ |
458 | continue; |
459 | } |
460 | |
461 | /* Process sections. */ |
462 | |
463 | if (section == 1) { /* SUID */ |
464 | /* Since we trimmed leading and trailing space above, we're |
465 | * now looking for strings of the form |
466 | * <key>[::space::]*=[::space::]*<value> |
467 | * where both key and value could contain inner whitespace. */ |
468 | |
469 | /* First get the key (an applet name in our case). */ |
470 | char *e = strchr(s, '='); |
471 | if (e) { |
472 | s = get_trimmed_slice(s, e); |
473 | } |
474 | if (!e || !*s) { /* Missing '=' or empty key. */ |
475 | errmsg = "keyword"; |
476 | goto pe_label; |
477 | } |
478 | |
479 | /* Ok, we have an applet name. Process the rhs if this |
480 | * applet is currently built in and ignore it otherwise. |
481 | * Note: this can hide config file bugs which only pop |
482 | * up when the busybox configuration is changed. */ |
483 | applet_no = find_applet_by_name(s); |
484 | if (applet_no >= 0) { |
485 | unsigned i; |
486 | struct suid_config_t *sct; |
487 | |
488 | /* Note: We currently don't check for duplicates! |
489 | * The last config line for each applet will be the |
490 | * one used since we insert at the head of the list. |
491 | * I suppose this could be considered a feature. */ |
492 | sct = xzalloc(sizeof(*sct)); |
493 | sct->m_applet = applet_no; |
494 | /*sct->m_mode = 0;*/ |
495 | sct->m_next = sct_head; |
496 | sct_head = sct; |
497 | |
498 | /* Get the specified mode. */ |
499 | |
500 | e = skip_whitespace(e+1); |
501 | |
502 | for (i = 0; i < 3; i++) { |
503 | /* There are 4 chars for each of user/group/other. |
504 | * "x-xx" instead of "x-" are to make |
505 | * "idx > 3" check catch invalid chars. |
506 | */ |
507 | static const char mode_chars[] ALIGN1 = "Ssx-" "Ssx-" "x-xx"; |
508 | static const unsigned short mode_mask[] ALIGN2 = { |
509 | S_ISUID, S_ISUID|S_IXUSR, S_IXUSR, 0, /* Ssx- */ |
510 | S_ISGID, S_ISGID|S_IXGRP, S_IXGRP, 0, /* Ssx- */ |
511 | S_IXOTH, 0 /* x- */ |
512 | }; |
513 | const char *q = strchrnul(mode_chars + 4*i, *e); |
514 | unsigned idx = q - (mode_chars + 4*i); |
515 | if (idx > 3) { |
516 | errmsg = "mode"; |
517 | goto pe_label; |
518 | } |
519 | sct->m_mode |= mode_mask[q - mode_chars]; |
520 | e++; |
521 | } |
522 | |
523 | /* Now get the user/group info. */ |
524 | |
525 | s = skip_whitespace(e); |
526 | /* Default is 0.0, else parse USER.GROUP: */ |
527 | if (*s) { |
528 | /* We require whitespace between mode and USER.GROUP */ |
529 | if ((s == e) || !(e = strchr(s, '.'))) { |
530 | errmsg = "uid.gid"; |
531 | goto pe_label; |
532 | } |
533 | *e = ':'; /* get_uidgid needs USER:GROUP syntax */ |
534 | if (get_uidgid(&sct->m_ugid, s) == 0) { |
535 | errmsg = "unknown user/group"; |
536 | goto pe_label; |
537 | } |
538 | } |
539 | } |
540 | continue; |
541 | } |
542 | |
543 | /* Unknown sections are ignored. */ |
544 | |
545 | /* Encountering configuration lines prior to seeing a |
546 | * section header is treated as an error. This is how |
547 | * the old code worked, but it may not be desirable. |
548 | * We may want to simply ignore such lines in case they |
549 | * are used in some future version of busybox. */ |
550 | if (!section) { |
551 | errmsg = "keyword outside section"; |
552 | goto pe_label; |
553 | } |
554 | } /* while (1) */ |
555 | |
556 | pe_label: |
557 | fclose(f); |
558 | bb_error_msg("parse error in %s, line %u: %s", config_file, lc, errmsg); |
559 | |
560 | /* Release any allocated memory before returning. */ |
561 | llist_free((llist_t*)sct_head, NULL); |
562 | } |
563 | # else |
564 | static inline void parse_config_file(void) |
565 | { |
566 | IF_FEATURE_SUID(ruid = getuid();) |
567 | } |
568 | # endif /* FEATURE_SUID_CONFIG */ |
569 | |
570 | |
571 | # if ENABLE_FEATURE_SUID |
572 | static void check_suid(int applet_no) |
573 | { |
574 | gid_t rgid; /* real gid */ |
575 | |
576 | if (ruid == 0) /* set by parse_config_file() */ |
577 | return; /* run by root - no need to check more */ |
578 | rgid = getgid(); |
579 | |
580 | # if ENABLE_FEATURE_SUID_CONFIG |
581 | if (suid_cfg_readable) { |
582 | uid_t uid; |
583 | struct suid_config_t *sct; |
584 | mode_t m; |
585 | |
586 | for (sct = suid_config; sct; sct = sct->m_next) { |
587 | if (sct->m_applet == applet_no) |
588 | goto found; |
589 | } |
590 | goto check_need_suid; |
591 | found: |
592 | /* Is this user allowed to run this applet? */ |
593 | m = sct->m_mode; |
594 | if (sct->m_ugid.uid == ruid) |
595 | /* same uid */ |
596 | m >>= 6; |
597 | else if ((sct->m_ugid.gid == rgid) || ingroup(ruid, sct->m_ugid.gid)) |
598 | /* same group / in group */ |
599 | m >>= 3; |
600 | if (!(m & S_IXOTH)) /* is x bit not set? */ |
601 | bb_error_msg_and_die("you have no permission to run this applet"); |
602 | |
603 | /* We set effective AND saved ids. If saved-id is not set |
604 | * like we do below, seteuid(0) can still later succeed! */ |
605 | |
606 | /* Are we directed to change gid |
607 | * (APPLET = *s* USER.GROUP or APPLET = *S* USER.GROUP)? |
608 | */ |
609 | if (sct->m_mode & S_ISGID) |
610 | rgid = sct->m_ugid.gid; |
611 | /* else: we will set egid = rgid, thus dropping sgid effect */ |
612 | if (setresgid(-1, rgid, rgid)) |
613 | bb_perror_msg_and_die("setresgid"); |
614 | |
615 | /* Are we directed to change uid |
616 | * (APPLET = s** USER.GROUP or APPLET = S** USER.GROUP)? |
617 | */ |
618 | uid = ruid; |
619 | if (sct->m_mode & S_ISUID) |
620 | uid = sct->m_ugid.uid; |
621 | /* else: we will set euid = ruid, thus dropping suid effect */ |
622 | if (setresuid(-1, uid, uid)) |
623 | bb_perror_msg_and_die("setresuid"); |
624 | |
625 | goto ret; |
626 | } |
627 | # if !ENABLE_FEATURE_SUID_CONFIG_QUIET |
628 | { |
629 | static bool onetime = 0; |
630 | |
631 | if (!onetime) { |
632 | onetime = 1; |
633 | bb_error_msg("using fallback suid method"); |
634 | } |
635 | } |
636 | # endif |
637 | check_need_suid: |
638 | # endif |
639 | if (APPLET_SUID(applet_no) == BB_SUID_REQUIRE) { |
640 | /* Real uid is not 0. If euid isn't 0 too, suid bit |
641 | * is most probably not set on our executable */ |
642 | if (geteuid()) |
643 | bb_error_msg_and_die("must be suid to work properly"); |
644 | } else if (APPLET_SUID(applet_no) == BB_SUID_DROP) { |
645 | xsetgid(rgid); /* drop all privileges */ |
646 | xsetuid(ruid); |
647 | } |
648 | # if ENABLE_FEATURE_SUID_CONFIG |
649 | ret: ; |
650 | llist_free((llist_t*)suid_config, NULL); |
651 | # endif |
652 | } |
653 | # else |
654 | # define check_suid(x) ((void)0) |
655 | # endif /* FEATURE_SUID */ |
656 | |
657 | |
658 | # if ENABLE_FEATURE_INSTALLER |
659 | static const char usr_bin [] ALIGN1 = "/usr/bin/"; |
660 | static const char usr_sbin[] ALIGN1 = "/usr/sbin/"; |
661 | static const char *const install_dir[] = { |
662 | &usr_bin [8], /* "/" */ |
663 | &usr_bin [4], /* "/bin/" */ |
664 | &usr_sbin[4] /* "/sbin/" */ |
665 | # if !ENABLE_INSTALL_NO_USR |
666 | ,usr_bin |
667 | ,usr_sbin |
668 | # endif |
669 | }; |
670 | |
671 | /* create (sym)links for each applet */ |
672 | static void install_links(const char *busybox, int use_symbolic_links, |
673 | char *custom_install_dir) |
674 | { |
675 | /* directory table |
676 | * this should be consistent w/ the enum, |
677 | * busybox.h::bb_install_loc_t, or else... */ |
678 | int (*lf)(const char *, const char *); |
679 | char *fpc; |
680 | const char *appname = applet_names; |
681 | unsigned i; |
682 | int rc; |
683 | |
684 | lf = link; |
685 | if (use_symbolic_links) |
686 | lf = symlink; |
687 | |
688 | for (i = 0; i < ARRAY_SIZE(applet_main); i++) { |
689 | fpc = concat_path_file( |
690 | custom_install_dir ? custom_install_dir : install_dir[APPLET_INSTALL_LOC(i)], |
691 | appname); |
692 | // debug: bb_error_msg("%slinking %s to busybox", |
693 | // use_symbolic_links ? "sym" : "", fpc); |
694 | rc = lf(busybox, fpc); |
695 | if (rc != 0 && errno != EEXIST) { |
696 | bb_simple_perror_msg(fpc); |
697 | } |
698 | free(fpc); |
699 | while (*appname++ != '\0') |
700 | continue; |
701 | } |
702 | } |
703 | # elif ENABLE_BUSYBOX |
704 | static void install_links(const char *busybox UNUSED_PARAM, |
705 | int use_symbolic_links UNUSED_PARAM, |
706 | char *custom_install_dir UNUSED_PARAM) |
707 | { |
708 | } |
709 | # endif |
710 | |
711 | # if ENABLE_BUSYBOX |
712 | static void run_applet_and_exit(const char *name, char **argv) NORETURN; |
713 | |
714 | /* If we were called as "busybox..." */ |
715 | static int busybox_main(char **argv) |
716 | { |
717 | if (!argv[1]) { |
718 | /* Called without arguments */ |
719 | const char *a; |
720 | int col; |
721 | unsigned output_width; |
722 | help: |
723 | output_width = 80; |
724 | if (ENABLE_FEATURE_AUTOWIDTH) { |
725 | /* Obtain the terminal width */ |
726 | output_width = get_terminal_width(2); |
727 | } |
728 | |
729 | dup2(1, 2); |
730 | full_write2_str(bb_banner); /* reuse const string */ |
731 | full_write2_str(" multi-call binary.\n"); /* reuse */ |
732 | full_write2_str( |
733 | "BusyBox is copyrighted by many authors between 1998-2015.\n" |
734 | "Licensed under GPLv2. See source distribution for detailed\n" |
735 | "copyright notices.\n" |
736 | "\n" |
737 | "Usage: busybox [function [arguments]...]\n" |
738 | " or: busybox --list"IF_FEATURE_INSTALLER("[-full]")"\n" |
739 | IF_FEATURE_INSTALLER( |
740 | " or: busybox --install [-s] [DIR]\n" |
741 | ) |
742 | " or: function [arguments]...\n" |
743 | "\n" |
744 | IF_NOT_FEATURE_SH_STANDALONE( |
745 | "\tBusyBox is a multi-call binary that combines many common Unix\n" |
746 | "\tutilities into a single executable. Most people will create a\n" |
747 | "\tlink to busybox for each function they wish to use and BusyBox\n" |
748 | "\twill act like whatever it was invoked as.\n" |
749 | ) |
750 | IF_FEATURE_SH_STANDALONE( |
751 | "\tBusyBox is a multi-call binary that combines many common Unix\n" |
752 | "\tutilities into a single executable. The shell in this build\n" |
753 | "\tis configured to run built-in utilities without $PATH search.\n" |
754 | "\tYou don't need to install a link to busybox for each utility.\n" |
755 | "\tTo run external program, use full path (/sbin/ip instead of ip).\n" |
756 | ) |
757 | "\n" |
758 | "Currently defined functions:\n" |
759 | ); |
760 | col = 0; |
761 | a = applet_names; |
762 | /* prevent last comma to be in the very last pos */ |
763 | output_width--; |
764 | while (*a) { |
765 | int len2 = strlen(a) + 2; |
766 | if (col >= (int)output_width - len2) { |
767 | full_write2_str(",\n"); |
768 | col = 0; |
769 | } |
770 | if (col == 0) { |
771 | col = 6; |
772 | full_write2_str("\t"); |
773 | } else { |
774 | full_write2_str(", "); |
775 | } |
776 | full_write2_str(a); |
777 | col += len2; |
778 | a += len2 - 1; |
779 | } |
780 | full_write2_str("\n\n"); |
781 | return 0; |
782 | } |
783 | |
784 | if (is_prefixed_with(argv[1], "--list")) { |
785 | unsigned i = 0; |
786 | const char *a = applet_names; |
787 | dup2(1, 2); |
788 | while (*a) { |
789 | # if ENABLE_FEATURE_INSTALLER |
790 | if (argv[1][6]) /* --list-full? */ |
791 | full_write2_str(install_dir[APPLET_INSTALL_LOC(i)] + 1); |
792 | # endif |
793 | full_write2_str(a); |
794 | full_write2_str("\n"); |
795 | i++; |
796 | while (*a++ != '\0') |
797 | continue; |
798 | } |
799 | return 0; |
800 | } |
801 | |
802 | if (ENABLE_FEATURE_INSTALLER && strcmp(argv[1], "--install") == 0) { |
803 | int use_symbolic_links; |
804 | const char *busybox; |
805 | |
806 | busybox = xmalloc_readlink(bb_busybox_exec_path); |
807 | if (!busybox) { |
808 | /* bb_busybox_exec_path is usually "/proc/self/exe". |
809 | * In chroot, readlink("/proc/self/exe") usually fails. |
810 | * In such case, better use argv[0] as symlink target |
811 | * if it is a full path name. |
812 | */ |
813 | if (argv[0][0] != '/') |
814 | bb_error_msg_and_die("'%s' is not an absolute path", argv[0]); |
815 | busybox = argv[0]; |
816 | } |
817 | /* busybox --install [-s] [DIR]: |
818 | * -s: make symlinks |
819 | * DIR: directory to install links to |
820 | */ |
821 | use_symbolic_links = (argv[2] && strcmp(argv[2], "-s") == 0 && ++argv); |
822 | install_links(busybox, use_symbolic_links, argv[2]); |
823 | return 0; |
824 | } |
825 | |
826 | if (strcmp(argv[1], "--help") == 0) { |
827 | /* "busybox --help [<applet>]" */ |
828 | if (!argv[2]) |
829 | goto help; |
830 | /* convert to "<applet> --help" */ |
831 | argv[0] = argv[2]; |
832 | argv[2] = NULL; |
833 | } else { |
834 | /* "busybox <applet> arg1 arg2 ..." */ |
835 | argv++; |
836 | } |
837 | /* We support "busybox /a/path/to/applet args..." too. Allows for |
838 | * "#!/bin/busybox"-style wrappers */ |
839 | applet_name = bb_get_last_path_component_nostrip(argv[0]); |
840 | run_applet_and_exit(applet_name, argv); |
841 | } |
842 | # endif |
843 | |
844 | # if NUM_APPLETS > 0 |
845 | void FAST_FUNC run_applet_no_and_exit(int applet_no, char **argv) |
846 | { |
847 | int argc = 1; |
848 | |
849 | while (argv[argc]) |
850 | argc++; |
851 | |
852 | /* Reinit some shared global data */ |
853 | xfunc_error_retval = EXIT_FAILURE; |
854 | applet_name = bb_get_last_path_component_nostrip(argv[0]); |
855 | |
856 | /* Special case. POSIX says "test --help" |
857 | * should be no different from e.g. "test --foo". |
858 | * Thus for "test", we skip --help check. |
859 | * "true" and "false" are also special. |
860 | */ |
861 | if (1 |
862 | # if defined APPLET_NO_test |
863 | && applet_no != APPLET_NO_test |
864 | # endif |
865 | # if defined APPLET_NO_true |
866 | && applet_no != APPLET_NO_true |
867 | # endif |
868 | # if defined APPLET_NO_false |
869 | && applet_no != APPLET_NO_false |
870 | # endif |
871 | ) { |
872 | if (argc == 2 && strcmp(argv[1], "--help") == 0) { |
873 | /* Make "foo --help" exit with 0: */ |
874 | xfunc_error_retval = 0; |
875 | bb_show_usage(); |
876 | } |
877 | } |
878 | if (ENABLE_FEATURE_SUID) |
879 | check_suid(applet_no); |
880 | xfunc_error_retval = applet_main[applet_no](argc, argv); |
881 | /* Note: applet_main() may also not return (die on a xfunc or such) */ |
882 | xfunc_die(); |
883 | } |
884 | # endif /* NUM_APPLETS > 0 */ |
885 | |
886 | # if ENABLE_BUSYBOX || NUM_APPLETS > 0 |
887 | static NORETURN void run_applet_and_exit(const char *name, char **argv) |
888 | { |
889 | # if ENABLE_BUSYBOX |
890 | if (is_prefixed_with(name, "busybox")) |
891 | exit(busybox_main(argv)); |
892 | # endif |
893 | # if NUM_APPLETS > 0 |
894 | /* find_applet_by_name() search is more expensive, so goes second */ |
895 | { |
896 | int applet = find_applet_by_name(name); |
897 | if (applet >= 0) |
898 | run_applet_no_and_exit(applet, argv); |
899 | } |
900 | # endif |
901 | |
902 | /*bb_error_msg_and_die("applet not found"); - links in printf */ |
903 | full_write2_str(applet_name); |
904 | full_write2_str(": applet not found\n"); |
905 | /* POSIX: "If a command is not found, the exit status shall be 127" */ |
906 | exit(127); |
907 | } |
908 | # endif |
909 | |
910 | #endif /* !defined(SINGLE_APPLET_MAIN) */ |
911 | |
912 | |
913 | #if ENABLE_BUILD_LIBBUSYBOX |
914 | int lbb_main(char **argv) |
915 | #else |
916 | int main(int argc UNUSED_PARAM, char **argv) |
917 | #endif |
918 | { |
919 | #if 0 |
920 | /* TODO: find a use for a block of memory between end of .bss |
921 | * and end of page. For example, I'm getting "_end:0x812e698 2408 bytes" |
922 | * - more than 2k of wasted memory (in this particular build) |
923 | * *per each running process*! |
924 | * (If your linker does not generate "_end" name, weak attribute |
925 | * makes &_end == NULL, end_len == 0 here.) |
926 | */ |
927 | extern char _end[] __attribute__((weak)); |
928 | unsigned end_len = (-(int)_end) & 0xfff; |
929 | printf("_end:%p %u bytes\n", &_end, end_len); |
930 | #endif |
931 | |
932 | /* Tweak malloc for reduced memory consumption */ |
933 | #ifdef M_TRIM_THRESHOLD |
934 | /* M_TRIM_THRESHOLD is the maximum amount of freed top-most memory |
935 | * to keep before releasing to the OS |
936 | * Default is way too big: 256k |
937 | */ |
938 | mallopt(M_TRIM_THRESHOLD, 8 * 1024); |
939 | #endif |
940 | #ifdef M_MMAP_THRESHOLD |
941 | /* M_MMAP_THRESHOLD is the request size threshold for using mmap() |
942 | * Default is too big: 256k |
943 | */ |
944 | mallopt(M_MMAP_THRESHOLD, 32 * 1024 - 256); |
945 | #endif |
946 | #if 0 /*def M_TOP_PAD*/ |
947 | /* When the program break is increased, then M_TOP_PAD bytes are added |
948 | * to the sbrk(2) request. When the heap is trimmed because of free(3), |
949 | * this much free space is preserved at the top of the heap. |
950 | * glibc default seems to be way too big: 128k, but need to verify. |
951 | */ |
952 | mallopt(M_TOP_PAD, 8 * 1024); |
953 | #endif |
954 | |
955 | #if !BB_MMU |
956 | /* NOMMU re-exec trick sets high-order bit in first byte of name */ |
957 | if (argv[0][0] & 0x80) { |
958 | re_execed = 1; |
959 | argv[0][0] &= 0x7f; |
960 | } |
961 | #endif |
962 | |
963 | #if defined(SINGLE_APPLET_MAIN) |
964 | |
965 | /* Only one applet is selected in .config */ |
966 | if (argv[1] && is_prefixed_with(argv[0], "busybox")) { |
967 | /* "busybox <applet> <params>" should still work as expected */ |
968 | argv++; |
969 | } |
970 | /* applet_names in this case is just "applet\0\0" */ |
971 | lbb_prepare(applet_names IF_FEATURE_INDIVIDUAL(, argv)); |
972 | return SINGLE_APPLET_MAIN(argc, argv); |
973 | |
974 | #elif !ENABLE_BUSYBOX && NUM_APPLETS == 0 |
975 | |
976 | full_write2_str(bb_basename(argv[0])); |
977 | full_write2_str(": no applets enabled\n"); |
978 | exit(127); |
979 | |
980 | #else |
981 | |
982 | lbb_prepare("busybox" IF_FEATURE_INDIVIDUAL(, argv)); |
983 | # if !ENABLE_BUSYBOX |
984 | if (argv[1] && is_prefixed_with(bb_basename(argv[0]), "busybox")) |
985 | argv++; |
986 | # endif |
987 | applet_name = argv[0]; |
988 | if (applet_name[0] == '-') |
989 | applet_name++; |
990 | applet_name = bb_basename(applet_name); |
991 | parse_config_file(); /* ...maybe, if FEATURE_SUID_CONFIG */ |
992 | run_applet_and_exit(applet_name, argv); |
993 | |
994 | #endif |
995 | } |
996 |