hush: get rid of charmap[]
[oweals/busybox.git] / libbb / appletlib.c
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 the GPL.
11  *
12  * Licensed under GPLv2 or later, see file License in this tarball for details.
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
30 #include <assert.h>
31 #include "busybox.h"
32
33
34 /* Declare <applet>_main() */
35 #define PROTOTYPES
36 #include "applets.h"
37 #undef PROTOTYPES
38
39 #if ENABLE_SHOW_USAGE && !ENABLE_FEATURE_COMPRESS_USAGE
40 /* Define usage_messages[] */
41 static const char usage_messages[] ALIGN1 = ""
42 #define MAKE_USAGE
43 #include "usage.h"
44 #include "applets.h"
45 ;
46 #undef MAKE_USAGE
47 #else
48 #define usage_messages 0
49 #endif /* SHOW_USAGE */
50
51
52 /* Include generated applet names, pointers to <applet>_main, etc */
53 #include "applet_tables.h"
54 /* ...and if applet_tables generator says we have only one applet... */
55 #ifdef SINGLE_APPLET_MAIN
56 #undef ENABLE_FEATURE_INDIVIDUAL
57 #define ENABLE_FEATURE_INDIVIDUAL 1
58 #undef USE_FEATURE_INDIVIDUAL
59 #define USE_FEATURE_INDIVIDUAL(...) __VA_ARGS__
60 #endif
61
62
63 #if ENABLE_FEATURE_COMPRESS_USAGE
64
65 #include "usage_compressed.h"
66 #include "unarchive.h"
67
68 static const char *unpack_usage_messages(void)
69 {
70         char *outbuf = NULL;
71         bunzip_data *bd;
72         int i;
73
74         i = start_bunzip(&bd,
75                         /* src_fd: */ -1,
76 //FIXME: can avoid storing these 2 bytes!
77                         /* inbuf:  */ (void *)packed_usage + 2,
78                         /* len:    */ sizeof(packed_usage));
79         /* read_bunzip can longjmp to start_bunzip, and ultimately
80          * end up here with i != 0 on read data errors! Not trivial */
81         if (!i) {
82                 /* Cannot use xmalloc: will leak bd in NOFORK case! */
83                 outbuf = malloc_or_warn(SIZEOF_usage_messages);
84                 if (outbuf)
85                         read_bunzip(bd, outbuf, SIZEOF_usage_messages);
86         }
87         dealloc_bunzip(bd);
88         return outbuf;
89 }
90 #define dealloc_usage_messages(s) free(s)
91
92 #else
93
94 #define unpack_usage_messages() usage_messages
95 #define dealloc_usage_messages(s) ((void)(s))
96
97 #endif /* FEATURE_COMPRESS_USAGE */
98
99
100 static void full_write2_str(const char *str)
101 {
102         xwrite_str(STDERR_FILENO, str);
103 }
104
105 void FAST_FUNC bb_show_usage(void)
106 {
107         if (ENABLE_SHOW_USAGE) {
108 #ifdef SINGLE_APPLET_STR
109                 /* Imagine that this applet is "true". Dont suck in printf! */
110                 const char *p;
111                 const char *usage_string = p = unpack_usage_messages();
112
113                 if (*p == '\b') {
114                         full_write2_str("No help available.\n\n");
115                 } else {
116                         full_write2_str("Usage: "SINGLE_APPLET_STR" ");
117                         full_write2_str(p);
118                         full_write2_str("\n\n");
119                 }
120                 dealloc_usage_messages((char*)usage_string);
121 #else
122                 const char *p;
123                 const char *usage_string = p = unpack_usage_messages();
124                 int ap = find_applet_by_name(applet_name);
125
126                 if (ap < 0) /* never happens, paranoia */
127                         xfunc_die();
128                 while (ap) {
129                         while (*p++) continue;
130                         ap--;
131                 }
132                 full_write2_str(bb_banner);
133                 full_write2_str(" multi-call binary\n");
134                 if (*p == '\b')
135                         full_write2_str("\nNo help available.\n\n");
136                 else {
137                         full_write2_str("\nUsage: ");
138                         full_write2_str(applet_name);
139                         full_write2_str(" ");
140                         full_write2_str(p);
141                         full_write2_str("\n\n");
142                 }
143                 dealloc_usage_messages((char*)usage_string);
144 #endif
145         }
146         xfunc_die();
147 }
148
149 #if NUM_APPLETS > 8
150 /* NB: any char pointer will work as well, not necessarily applet_names */
151 static int applet_name_compare(const void *name, const void *v)
152 {
153         int i = (const char *)v - applet_names;
154         return strcmp(name, APPLET_NAME(i));
155 }
156 #endif
157 int FAST_FUNC find_applet_by_name(const char *name)
158 {
159 #if NUM_APPLETS > 8
160         /* Do a binary search to find the applet entry given the name. */
161         const char *p;
162         p = bsearch(name, applet_names, ARRAY_SIZE(applet_main), 1, applet_name_compare);
163         if (!p)
164                 return -1;
165         return p - applet_names;
166 #else
167         /* A version which does not pull in bsearch */
168         int i = 0;
169         const char *p = applet_names;
170         while (i < NUM_APPLETS) {
171                 if (strcmp(name, p) == 0)
172                         return i;
173                 p += strlen(p) + 1;
174                 i++;
175         }
176         return -1;
177 #endif
178 }
179
180
181 void lbb_prepare(const char *applet
182                 USE_FEATURE_INDIVIDUAL(, char **argv))
183                                 MAIN_EXTERNALLY_VISIBLE;
184 void lbb_prepare(const char *applet
185                 USE_FEATURE_INDIVIDUAL(, char **argv))
186 {
187 #ifdef __GLIBC__
188         (*(int **)&bb_errno) = __errno_location();
189         barrier();
190 #endif
191         applet_name = applet;
192
193         /* Set locale for everybody except 'init' */
194         if (ENABLE_LOCALE_SUPPORT && getpid() != 1)
195                 setlocale(LC_ALL, "");
196
197 #if ENABLE_FEATURE_INDIVIDUAL
198         /* Redundant for busybox (run_applet_and_exit covers that case)
199          * but needed for "individual applet" mode */
200         if (argv[1] && !argv[2] && strcmp(argv[1], "--help") == 0) {
201                 /* Special case. POSIX says "test --help"
202                  * should be no different from e.g. "test --foo".  */
203                 if (!ENABLE_TEST || strcmp(applet_name, "test") != 0)
204                         bb_show_usage();
205         }
206 #endif
207 }
208
209 /* The code below can well be in applets/applets.c, as it is used only
210  * for busybox binary, not "individual" binaries.
211  * However, keeping it here and linking it into libbusybox.so
212  * (together with remaining tiny applets/applets.o)
213  * makes it possible to avoid --whole-archive at link time.
214  * This makes (shared busybox) + libbusybox smaller.
215  * (--gc-sections would be even better....)
216  */
217
218 const char *applet_name;
219 #if !BB_MMU
220 bool re_execed;
221 #endif
222
223
224 /* If not built as a single-applet executable... */
225 #if !defined(SINGLE_APPLET_MAIN)
226
227 USE_FEATURE_SUID(static uid_t ruid;)  /* real uid */
228
229 #if ENABLE_FEATURE_SUID_CONFIG
230
231 /* applets[] is const, so we have to define this "override" structure */
232 static struct BB_suid_config {
233         int m_applet;
234         uid_t m_uid;
235         gid_t m_gid;
236         mode_t m_mode;
237         struct BB_suid_config *m_next;
238 } *suid_config;
239
240 static bool suid_cfg_readable;
241
242 /* check if u is member of group g */
243 static int ingroup(uid_t u, gid_t g)
244 {
245         struct group *grp = getgrgid(g);
246
247         if (grp) {
248                 char **mem;
249
250                 for (mem = grp->gr_mem; *mem; mem++) {
251                         struct passwd *pwd = getpwnam(*mem);
252
253                         if (pwd && (pwd->pw_uid == u))
254                                 return 1;
255                 }
256         }
257         return 0;
258 }
259
260 /* This should probably be a libbb routine.  In that case,
261  * I'd probably rename it to something like bb_trimmed_slice.
262  */
263 static char *get_trimmed_slice(char *s, char *e)
264 {
265         /* First, consider the value at e to be nul and back up until we
266          * reach a non-space char.  Set the char after that (possibly at
267          * the original e) to nul. */
268         while (e-- > s) {
269                 if (!isspace(*e)) {
270                         break;
271                 }
272         }
273         e[1] = '\0';
274
275         /* Next, advance past all leading space and return a ptr to the
276          * first non-space char; possibly the terminating nul. */
277         return skip_whitespace(s);
278 }
279
280 /* Don't depend on the tools to combine strings. */
281 static const char config_file[] ALIGN1 = "/etc/busybox.conf";
282
283 /* We don't supply a value for the nul, so an index adjustment is
284  * necessary below.  Also, we use unsigned short here to save some
285  * space even though these are really mode_t values. */
286 static const unsigned short mode_mask[] ALIGN2 = {
287         /*  SST     sst                 xxx         --- */
288         S_ISUID,    S_ISUID|S_IXUSR,    S_IXUSR,    0,  /* user */
289         S_ISGID,    S_ISGID|S_IXGRP,    S_IXGRP,    0,  /* group */
290         0,          S_IXOTH,            S_IXOTH,    0   /* other */
291 };
292
293 #define parse_error(x)  do { errmsg = x; goto pe_label; } while (0)
294
295 static void parse_config_file(void)
296 {
297         struct BB_suid_config *sct_head;
298         struct BB_suid_config *sct;
299         int applet_no;
300         FILE *f;
301         const char *errmsg;
302         char *s;
303         char *e;
304         int i;
305         unsigned lc;
306         smallint section;
307         char buffer[256];
308         struct stat st;
309
310         assert(!suid_config); /* Should be set to NULL by bss init. */
311
312         ruid = getuid();
313         if (ruid == 0) /* run by root - don't need to even read config file */
314                 return;
315
316         if ((stat(config_file, &st) != 0)       /* No config file? */
317          || !S_ISREG(st.st_mode)                /* Not a regular file? */
318          || (st.st_uid != 0)                    /* Not owned by root? */
319          || (st.st_mode & (S_IWGRP | S_IWOTH))  /* Writable by non-root? */
320          || !(f = fopen_for_read(config_file))      /* Cannot open? */
321         ) {
322                 return;
323         }
324
325         suid_cfg_readable = 1;
326         sct_head = NULL;
327         section = lc = 0;
328
329         while (1) {
330                 s = buffer;
331
332                 if (!fgets(s, sizeof(buffer), f)) { /* Are we done? */
333 // why?
334                         if (ferror(f)) {   /* Make sure it wasn't a read error. */
335                                 parse_error("reading");
336                         }
337                         fclose(f);
338                         suid_config = sct_head; /* Success, so set the pointer. */
339                         return;
340                 }
341
342                 lc++;                                   /* Got a (partial) line. */
343
344                 /* If a line is too long for our buffer, we consider it an error.
345                  * The following test does mistreat one corner case though.
346                  * If the final line of the file does not end with a newline and
347                  * yet exactly fills the buffer, it will be treated as too long
348                  * even though there isn't really a problem.  But it isn't really
349                  * worth adding code to deal with such an unlikely situation, and
350                  * we do err on the side of caution.  Besides, the line would be
351                  * too long if it did end with a newline. */
352                 if (!strchr(s, '\n') && !feof(f)) {
353                         parse_error("line too long");
354                 }
355
356                 /* Trim leading and trailing whitespace, ignoring comments, and
357                  * check if the resulting string is empty. */
358                 s = get_trimmed_slice(s, strchrnul(s, '#'));
359                 if (!*s) {
360                         continue;
361                 }
362
363                 /* Check for a section header. */
364
365                 if (*s == '[') {
366                         /* Unlike the old code, we ignore leading and trailing
367                          * whitespace for the section name.  We also require that
368                          * there are no stray characters after the closing bracket. */
369                         e = strchr(s, ']');
370                         if (!e   /* Missing right bracket? */
371                          || e[1] /* Trailing characters? */
372                          || !*(s = get_trimmed_slice(s+1, e)) /* Missing name? */
373                         ) {
374                                 parse_error("section header");
375                         }
376                         /* Right now we only have one section so just check it.
377                          * If more sections are added in the future, please don't
378                          * resort to cascading ifs with multiple strcasecmp calls.
379                          * That kind of bloated code is all too common.  A loop
380                          * and a string table would be a better choice unless the
381                          * number of sections is very small. */
382                         if (strcasecmp(s, "SUID") == 0) {
383                                 section = 1;
384                                 continue;
385                         }
386                         section = -1;   /* Unknown section so set to skip. */
387                         continue;
388                 }
389
390                 /* Process sections. */
391
392                 if (section == 1) {             /* SUID */
393                         /* Since we trimmed leading and trailing space above, we're
394                          * now looking for strings of the form
395                          *    <key>[::space::]*=[::space::]*<value>
396                          * where both key and value could contain inner whitespace. */
397
398                         /* First get the key (an applet name in our case). */
399                         e = strchr(s, '=');
400                         if (e) {
401                                 s = get_trimmed_slice(s, e);
402                         }
403                         if (!e || !*s) {        /* Missing '=' or empty key. */
404                                 parse_error("keyword");
405                         }
406
407                         /* Ok, we have an applet name.  Process the rhs if this
408                          * applet is currently built in and ignore it otherwise.
409                          * Note: this can hide config file bugs which only pop
410                          * up when the busybox configuration is changed. */
411                         applet_no = find_applet_by_name(s);
412                         if (applet_no >= 0) {
413                                 /* Note: We currently don't check for duplicates!
414                                  * The last config line for each applet will be the
415                                  * one used since we insert at the head of the list.
416                                  * I suppose this could be considered a feature. */
417                                 sct = xmalloc(sizeof(struct BB_suid_config));
418                                 sct->m_applet = applet_no;
419                                 sct->m_mode = 0;
420                                 sct->m_next = sct_head;
421                                 sct_head = sct;
422
423                                 /* Get the specified mode. */
424
425                                 e = skip_whitespace(e+1);
426
427                                 for (i = 0; i < 3; i++) {
428                                         /* There are 4 chars + 1 nul for each of user/group/other. */
429                                         static const char mode_chars[] ALIGN1 = "Ssx-\0" "Ssx-\0" "Ttx-";
430
431                                         const char *q;
432                                         q = strchrnul(mode_chars + 5*i, *e++);
433                                         if (!*q) {
434                                                 parse_error("mode");
435                                         }
436                                         /* Adjust by -i to account for nul. */
437                                         sct->m_mode |= mode_mask[(q - mode_chars) - i];
438                                 }
439
440                                 /* Now get the the user/group info. */
441
442                                 s = skip_whitespace(e);
443
444                                 /* Note: we require whitespace between the mode and the
445                                  * user/group info. */
446                                 if ((s == e) || !(e = strchr(s, '.'))) {
447                                         parse_error("<uid>.<gid>");
448                                 }
449                                 *e++ = '\0';
450
451                                 /* We can't use get_ug_id here since it would exit()
452                                  * if a uid or gid was not found.  Oh well... */
453                                 sct->m_uid = bb_strtoul(s, NULL, 10);
454                                 if (errno) {
455                                         struct passwd *pwd = getpwnam(s);
456                                         if (!pwd) {
457                                                 parse_error("user");
458                                         }
459                                         sct->m_uid = pwd->pw_uid;
460                                 }
461
462                                 sct->m_gid = bb_strtoul(e, NULL, 10);
463                                 if (errno) {
464                                         struct group *grp;
465                                         grp = getgrnam(e);
466                                         if (!grp) {
467                                                 parse_error("group");
468                                         }
469                                         sct->m_gid = grp->gr_gid;
470                                 }
471                         }
472                         continue;
473                 }
474
475                 /* Unknown sections are ignored. */
476
477                 /* Encountering configuration lines prior to seeing a
478                  * section header is treated as an error.  This is how
479                  * the old code worked, but it may not be desirable.
480                  * We may want to simply ignore such lines in case they
481                  * are used in some future version of busybox. */
482                 if (!section) {
483                         parse_error("keyword outside section");
484                 }
485
486         } /* while (1) */
487
488  pe_label:
489         fprintf(stderr, "Parse error in %s, line %d: %s\n",
490                         config_file, lc, errmsg);
491
492         fclose(f);
493         /* Release any allocated memory before returning. */
494         while (sct_head) {
495                 sct = sct_head->m_next;
496                 free(sct_head);
497                 sct_head = sct;
498         }
499 }
500 #else
501 static inline void parse_config_file(void)
502 {
503         USE_FEATURE_SUID(ruid = getuid();)
504 }
505 #endif /* FEATURE_SUID_CONFIG */
506
507
508 #if ENABLE_FEATURE_SUID
509 static void check_suid(int applet_no)
510 {
511         gid_t rgid;  /* real gid */
512
513         if (ruid == 0) /* set by parse_config_file() */
514                 return; /* run by root - no need to check more */
515         rgid = getgid();
516
517 #if ENABLE_FEATURE_SUID_CONFIG
518         if (suid_cfg_readable) {
519                 uid_t uid;
520                 struct BB_suid_config *sct;
521                 mode_t m;
522
523                 for (sct = suid_config; sct; sct = sct->m_next) {
524                         if (sct->m_applet == applet_no)
525                                 goto found;
526                 }
527                 goto check_need_suid;
528  found:
529                 m = sct->m_mode;
530                 if (sct->m_uid == ruid)
531                         /* same uid */
532                         m >>= 6;
533                 else if ((sct->m_gid == rgid) || ingroup(ruid, sct->m_gid))
534                         /* same group / in group */
535                         m >>= 3;
536
537                 if (!(m & S_IXOTH))           /* is x bit not set ? */
538                         bb_error_msg_and_die("you have no permission to run this applet!");
539
540                 /* _both_ sgid and group_exec have to be set for setegid */
541                 if ((sct->m_mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP))
542                         rgid = sct->m_gid;
543                 /* else (no setegid) we will set egid = rgid */
544
545                 /* We set effective AND saved ids. If saved-id is not set
546                  * like we do below, seteiud(0) can still later succeed! */
547                 if (setresgid(-1, rgid, rgid))
548                         bb_perror_msg_and_die("setresgid");
549
550                 /* do we have to set effective uid? */
551                 uid = ruid;
552                 if (sct->m_mode & S_ISUID)
553                         uid = sct->m_uid;
554                 /* else (no seteuid) we will set euid = ruid */
555
556                 if (setresuid(-1, uid, uid))
557                         bb_perror_msg_and_die("setresuid");
558                 return;
559         }
560 #if !ENABLE_FEATURE_SUID_CONFIG_QUIET
561         {
562                 static bool onetime = 0;
563
564                 if (!onetime) {
565                         onetime = 1;
566                         fprintf(stderr, "Using fallback suid method\n");
567                 }
568         }
569 #endif
570  check_need_suid:
571 #endif
572         if (APPLET_SUID(applet_no) == _BB_SUID_ALWAYS) {
573                 /* Real uid is not 0. If euid isn't 0 too, suid bit
574                  * is most probably not set on our executable */
575                 if (geteuid())
576                         bb_error_msg_and_die("must be suid to work properly");
577         } else if (APPLET_SUID(applet_no) == _BB_SUID_NEVER) {
578                 xsetgid(rgid);  /* drop all privileges */
579                 xsetuid(ruid);
580         }
581 }
582 #else
583 #define check_suid(x) ((void)0)
584 #endif /* FEATURE_SUID */
585
586
587 #if ENABLE_FEATURE_INSTALLER
588 /* create (sym)links for each applet */
589 static void install_links(const char *busybox, int use_symbolic_links)
590 {
591         /* directory table
592          * this should be consistent w/ the enum,
593          * busybox.h::bb_install_loc_t, or else... */
594         static const char usr_bin [] ALIGN1 = "/usr/bin";
595         static const char usr_sbin[] ALIGN1 = "/usr/sbin";
596         static const char *const install_dir[] = {
597                 &usr_bin [8], /* "", equivalent to "/" for concat_path_file() */
598                 &usr_bin [4], /* "/bin" */
599                 &usr_sbin[4], /* "/sbin" */
600                 usr_bin,
601                 usr_sbin
602         };
603
604         int (*lf)(const char *, const char *);
605         char *fpc;
606         unsigned i;
607         int rc;
608
609         lf = link;
610         if (use_symbolic_links)
611                 lf = symlink;
612
613         for (i = 0; i < ARRAY_SIZE(applet_main); i++) {
614                 fpc = concat_path_file(
615                                 install_dir[APPLET_INSTALL_LOC(i)],
616                                 APPLET_NAME(i));
617                 // debug: bb_error_msg("%slinking %s to busybox",
618                 //              use_symbolic_links ? "sym" : "", fpc);
619                 rc = lf(busybox, fpc);
620                 if (rc != 0 && errno != EEXIST) {
621                         bb_simple_perror_msg(fpc);
622                 }
623                 free(fpc);
624         }
625 }
626 #else
627 #define install_links(x,y) ((void)0)
628 #endif /* FEATURE_INSTALLER */
629
630 /* If we were called as "busybox..." */
631 static int busybox_main(char **argv)
632 {
633         if (!argv[1]) {
634                 /* Called without arguments */
635                 const char *a;
636                 unsigned col, output_width;
637  help:
638                 output_width = 80;
639                 if (ENABLE_FEATURE_AUTOWIDTH) {
640                         /* Obtain the terminal width */
641                         get_terminal_width_height(0, &output_width, NULL);
642                 }
643                 /* leading tab and room to wrap */
644                 output_width -= MAX_APPLET_NAME_LEN + 8;
645
646                 dup2(1, 2);
647                 full_write2_str(bb_banner); /* reuse const string... */
648                 full_write2_str(" multi-call binary\n"
649                        "Copyright (C) 1998-2008 Erik Andersen, Rob Landley, Denys Vlasenko\n"
650                        "and others. Licensed under GPLv2.\n"
651                        "See source distribution for full notice.\n"
652                        "\n"
653                        "Usage: busybox [function] [arguments]...\n"
654                        "   or: function [arguments]...\n"
655                        "\n"
656                        "\tBusyBox is a multi-call binary that combines many common Unix\n"
657                        "\tutilities into a single executable.  Most people will create a\n"
658                        "\tlink to busybox for each function they wish to use and BusyBox\n"
659                        "\twill act like whatever it was invoked as!\n"
660                        "\n"
661                        "Currently defined functions:\n");
662                 col = 0;
663                 a = applet_names;
664                 while (*a) {
665                         int len;
666                         if (col > output_width) {
667                                 full_write2_str(",\n");
668                                 col = 0;
669                         }
670                         full_write2_str(col ? ", " : "\t");
671                         full_write2_str(a);
672                         len = strlen(a);
673                         col += len + 2;
674                         a += len + 1;
675                 }
676                 full_write2_str("\n\n");
677                 return 0;
678         }
679
680         if (ENABLE_FEATURE_INSTALLER && strcmp(argv[1], "--install") == 0) {
681                 const char *busybox;
682                 busybox = xmalloc_readlink(bb_busybox_exec_path);
683                 if (!busybox)
684                         busybox = bb_busybox_exec_path;
685                 /* -s makes symlinks */
686                 install_links(busybox, argv[2] && strcmp(argv[2], "-s") == 0);
687                 return 0;
688         }
689
690         if (strcmp(argv[1], "--help") == 0) {
691                 /* "busybox --help [<applet>]" */
692                 if (!argv[2])
693                         goto help;
694                 /* convert to "<applet> --help" */
695                 argv[0] = argv[2];
696                 argv[2] = NULL;
697         } else {
698                 /* "busybox <applet> arg1 arg2 ..." */
699                 argv++;
700         }
701         /* We support "busybox /a/path/to/applet args..." too. Allows for
702          * "#!/bin/busybox"-style wrappers */
703         applet_name = bb_get_last_path_component_nostrip(argv[0]);
704         run_applet_and_exit(applet_name, argv);
705
706         /*bb_error_msg_and_die("applet not found"); - sucks in printf */
707         full_write2_str(applet_name);
708         full_write2_str(": applet not found\n");
709         xfunc_die();
710 }
711
712 void FAST_FUNC run_applet_no_and_exit(int applet_no, char **argv)
713 {
714         int argc = 1;
715
716         while (argv[argc])
717                 argc++;
718
719         /* Reinit some shared global data */
720         xfunc_error_retval = EXIT_FAILURE;
721
722         applet_name = APPLET_NAME(applet_no);
723         if (argc == 2 && strcmp(argv[1], "--help") == 0) {
724                 /* Special case. POSIX says "test --help"
725                  * should be no different from e.g. "test --foo".  */
726 //TODO: just compare applet_no with APPLET_NO_test
727                 if (!ENABLE_TEST || strcmp(applet_name, "test") != 0)
728                         bb_show_usage();
729         }
730         if (ENABLE_FEATURE_SUID)
731                 check_suid(applet_no);
732         exit(applet_main[applet_no](argc, argv));
733 }
734
735 void FAST_FUNC run_applet_and_exit(const char *name, char **argv)
736 {
737         int applet = find_applet_by_name(name);
738         if (applet >= 0)
739                 run_applet_no_and_exit(applet, argv);
740         if (!strncmp(name, "busybox", 7))
741                 exit(busybox_main(argv));
742 }
743
744 #endif /* !defined(SINGLE_APPLET_MAIN) */
745
746
747
748 #if ENABLE_BUILD_LIBBUSYBOX
749 int lbb_main(char **argv)
750 #else
751 int main(int argc UNUSED_PARAM, char **argv)
752 #endif
753 {
754 #if defined(SINGLE_APPLET_MAIN)
755         /* Only one applet is selected by the user! */
756         /* applet_names in this case is just "applet\0\0" */
757         lbb_prepare(applet_names USE_FEATURE_INDIVIDUAL(, argv));
758         return SINGLE_APPLET_MAIN(argc, argv);
759 #else
760         lbb_prepare("busybox" USE_FEATURE_INDIVIDUAL(, argv));
761
762 #if !BB_MMU
763         /* NOMMU re-exec trick sets high-order bit in first byte of name */
764         if (argv[0][0] & 0x80) {
765                 re_execed = 1;
766                 argv[0][0] &= 0x7f;
767         }
768 #endif
769         applet_name = argv[0];
770         if (applet_name[0] == '-')
771                 applet_name++;
772         applet_name = bb_basename(applet_name);
773
774         parse_config_file(); /* ...maybe, if FEATURE_SUID_CONFIG */
775
776         run_applet_and_exit(applet_name, argv);
777
778         /*bb_error_msg_and_die("applet not found"); - sucks in printf */
779         full_write2_str(applet_name);
780         full_write2_str(": applet not found\n");
781         xfunc_die();
782 #endif
783 }