#define bb_need_full_version
#define BB_DECLARE_EXTERN
#include "messages.c"
+#include "usage.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#include <stdlib.h>
+#include <limits.h>
#include <sys/ioctl.h>
#include <sys/utsname.h> /* for uname(2) */
/* Busybox mount uses either /proc/filesystems or /dev/mtab to get the
* list of available filesystems used for the -t auto option */
-#if defined BB_FEATURE_USE_PROCFS && defined BB_FEATURE_USE_DEVPS_PATCH
-//#error Sorry, but busybox can't use both /proc and /dev/ps at the same time -- Pick one and try again.
-#error "Sorry, but busybox can't use both /proc and /dev/ps at the same time -- Pick one and try again."
-#endif
-
-
#if defined BB_MOUNT || defined BB_UMOUNT || defined BB_DF
# if defined BB_MTAB
const char mtab_file[] = "/etc/mtab";
# else
-# if defined BB_FEATURE_USE_PROCFS
-const char mtab_file[] = "/proc/mounts";
-# else
# if defined BB_FEATURE_USE_DEVPS_PATCH
const char mtab_file[] = "/dev/mtab";
# else
-# error With (BB_MOUNT||BB_UMOUNT||BB_DF) defined, you must define either BB_MTAB or ( BB_FEATURE_USE_PROCFS | BB_FEATURE_USE_DEVPS_PATCH)
+const char mtab_file[] = "/proc/mounts";
# endif
# endif
-# endif
#endif
-extern void usage(const char *usage)
+static struct BB_applet *applet_using;
+
+extern void show_usage(void)
{
- fprintf(stderr, "%s\n\nUsage: %s\n", full_version, usage);
+ static const char no_help[] = "No help available.\n";
+
+ const char *usage_string = no_help;
+ int i;
+
+ if (applet_using->usage_index >= 0) {
+ usage_string = usage_messages;
+ for (i=applet_using->usage_index ; i>0 ; ) {
+ if (!*usage_string++) {
+ --i;
+ }
+ }
+ }
+ fprintf(stderr, "%s\n\nUsage: %s %s\n\n", full_version,
+ applet_using->name, usage_string);
exit(EXIT_FAILURE);
}
+
static void verror_msg(const char *s, va_list p)
{
fflush(stdout);
va_start(p, s);
verror_msg(s, p);
va_end(p);
+ putc('\n', stderr);
}
extern void error_msg_and_die(const char *s, ...)
va_start(p, s);
verror_msg(s, p);
va_end(p);
+ putc('\n', stderr);
exit(EXIT_FAILURE);
}
extern int get_kernel_revision(void)
{
struct utsname name;
- int major = 0, minor = 0, patch = 0;
+ char *s;
+ int i, r;
if (uname(&name) == -1) {
perror_msg("cannot get system information");
return (0);
}
- major = atoi(strtok(name.release, "."));
- minor = atoi(strtok(NULL, "."));
- patch = atoi(strtok(NULL, "."));
- return major * 65536 + minor * 256 + patch;
+
+ s = name.release;
+ r = 0;
+ for (i=0 ; i<3 ; i++) {
+ r = r * 256 + atoi(strtok(s, "."));
+ s = NULL;
+ }
+ return r;
}
#endif /* BB_INIT */
#endif
-#if defined (BB_CP_MV)
+#if defined (BB_CP_MV) || defined BB_DPKG
/*
* Copy one file to another, while possibly preserving its modes, times, and
* modes. Returns TRUE if successful, or FALSE on a failure with an error
if ((srcStatBuf.st_dev == dstStatBuf.st_dev) &&
(srcStatBuf.st_ino == dstStatBuf.st_ino)) {
- error_msg("Copying file \"%s\" to itself\n", srcName);
+ error_msg("Copying file \"%s\" to itself", srcName);
return FALSE;
}
|| defined (BB_MKFIFO) || defined (BB_MKNOD) || defined (BB_AR)
/* [ugoa]{+|-|=}[rwxst] */
-
-
extern int parse_mode(const char *s, mode_t * theMode)
{
- mode_t andMode =
+ static const mode_t group_set[] = {
+ S_ISUID | S_IRWXU, /* u */
+ S_ISGID | S_IRWXG, /* g */
+ S_IRWXO, /* o */
+ S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO /* a */
+ };
+
+ static const mode_t mode_set[] = {
+ S_IRUSR | S_IRGRP | S_IROTH, /* r */
+ S_IWUSR | S_IWGRP | S_IWOTH, /* w */
+ S_IXUSR | S_IXGRP | S_IXOTH, /* x */
+ S_ISUID | S_ISGID, /* s */
+ S_ISVTX /* t */
+ };
+
+ static const char group_string[] = "ugoa";
+ static const char mode_string[] = "rwxst";
+
+ const char *p;
+ mode_t andMode =
S_ISVTX | S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;
mode_t orMode = 0;
- mode_t mode = 0;
- mode_t groups = 0;
+ mode_t mode;
+ mode_t groups;
char type;
char c;
- if (s==NULL)
+ if (s==NULL) {
return (FALSE);
+ }
do {
- for (;;) {
- switch (c = *s++) {
- case '\0':
- return -1;
- case 'u':
- groups |= S_ISUID | S_IRWXU;
- continue;
- case 'g':
- groups |= S_ISGID | S_IRWXG;
- continue;
- case 'o':
- groups |= S_IRWXO;
- continue;
- case 'a':
- groups |= S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;
- continue;
- case '+':
+ mode = 0;
+ groups = 0;
+ NEXT_GROUP:
+ if ((c = *s++) == '\0') {
+ return -1;
+ }
+ for (p=group_string ; *p ; p++) {
+ if (*p == c) {
+ groups |= group_set[(int)(p-group_string)];
+ goto NEXT_GROUP;
+ }
+ }
+ switch (c) {
case '=':
+ case '+':
case '-':
type = c;
- if (groups == 0) /* The default is "all" */
- groups |=
- S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;
+ if (groups == 0) { /* The default is "all" */
+ groups |= S_ISUID | S_ISGID | S_ISVTX
+ | S_IRWXU | S_IRWXG | S_IRWXO;
+ }
break;
default:
- if (isdigit(c) && c >= '0' && c <= '7' &&
- mode == 0 && groups == 0) {
+ if ((c < '0') || (c > '7') || (mode | groups)) {
+ return (FALSE);
+ } else {
*theMode = strtol(--s, NULL, 8);
return (TRUE);
- } else
- return (FALSE);
- }
- break;
+ }
}
- while ((c = *s++) != '\0') {
- switch (c) {
- case ',':
- break;
- case 'r':
- mode |= S_IRUSR | S_IRGRP | S_IROTH;
- continue;
- case 'w':
- mode |= S_IWUSR | S_IWGRP | S_IWOTH;
- continue;
- case 'x':
- mode |= S_IXUSR | S_IXGRP | S_IXOTH;
- continue;
- case 's':
- mode |= S_IXGRP | S_ISUID | S_ISGID;
- continue;
- case 't':
- mode |= 0;
- continue;
- default:
- *theMode &= andMode;
- *theMode |= orMode;
- return (TRUE);
+ NEXT_MODE:
+ if (((c = *s++) != '\0') && (c != ',')) {
+ for (p=mode_string ; *p ; p++) {
+ if (*p == c) {
+ mode |= mode_set[(int)(p-mode_string)];
+ goto NEXT_MODE;
+ }
}
- break;
+ break; /* We're done so break out of loop.*/
}
switch (type) {
- case '=':
- andMode &= ~(groups);
- /* fall through */
- case '+':
- orMode |= mode & groups;
- break;
- case '-':
- andMode &= ~(mode & groups);
- orMode &= andMode;
- break;
+ case '=':
+ andMode &= ~(groups); /* Now fall through. */
+ case '+':
+ orMode |= mode & groups;
+ break;
+ case '-':
+ andMode &= ~(mode & groups);
+ orMode &= ~(mode & groups);
+ break;
}
} while (c == ',');
+
*theMode &= andMode;
*theMode |= orMode;
- return (TRUE);
-}
+ return TRUE;
+}
#endif
/* BB_CHMOD_CHOWN_CHGRP || BB_MKDIR || BB_MKFIFO || BB_MKNOD */
myuser = getpwnam(name);
if (myuser==NULL)
- error_msg_and_die( "unknown username: %s\n", name);
+ return(-1);
return myuser->pw_uid;
}
mygroup = getgrnam(name);
if (mygroup==NULL)
- error_msg_and_die( "unknown group: %s\n", name);
+ return(-1);
return (mygroup->gr_gid);
}
myuser = getpwuid(uid);
if (myuser==NULL)
- error_msg_and_die( "unknown uid %ld\n", (long)uid);
-
- strcpy(name, myuser->pw_name);
+ sprintf(name, "%-8ld ", (long)uid);
+ else
+ strcpy(name, myuser->pw_name);
}
/* gets a groupname given a gid */
mygroup = getgrgid(gid);
if (mygroup==NULL)
- error_msg_and_die( "unknown gid %ld\n", (long)gid);
-
- strcpy(group, mygroup->gr_name);
+ sprintf(group, "%-8ld ", (long)gid);
+ else
+ strcpy(group, mygroup->gr_name);
}
#if defined BB_ID
myuser=getpwnam(name);
if (myuser==NULL)
- error_msg_and_die( "unknown user name: %s\n", name);
+ error_msg_and_die( "unknown user name: %s", name);
mygroup = getgrgid(myuser->pw_gid);
if (mygroup==NULL)
- error_msg_and_die( "unknown gid %ld\n", (long)myuser->pw_gid);
+ error_msg_and_die( "unknown gid %ld", (long)myuser->pw_gid);
return mygroup->gr_gid;
}
if (is_a_console(fd))
return fd;
- error_msg("Couldnt get a file descriptor referring to the console\n");
+ error_msg("Couldnt get a file descriptor referring to the console");
return -1; /* total failure */
}
return pidList;
}
#else /* BB_FEATURE_USE_DEVPS_PATCH */
-#if ! defined BB_FEATURE_USE_PROCFS
-#error Sorry, I depend on the /proc filesystem right now.
-#endif
/* find_pid_by_name()
*
char *t;
if (s == NULL)
- error_msg_and_die("xstrndup bug\n");
+ error_msg_and_die("xstrndup bug");
t = xmalloc(n+1);
strncpy(t,s,n);
}
#endif
+#if defined BB_IFCONFIG || defined BB_ROUTE
+/* Like strncpy but make sure the resulting string is always 0 terminated. */
+extern char * safe_strncpy(char *dst, const char *src, size_t size)
+{
+ dst[size-1] = '\0';
+ return strncpy(dst, src, size-1);
+}
+#endif
#if (__GLIBC__ < 2) && (defined BB_SYSLOGD || defined BB_INIT)
extern int vdprintf(int d, const char *format, va_list ap)
char fileName[BUFSIZ];
if (stat("/", &rootStat) != 0) {
- error_msg("could not stat '/'\n");
+ error_msg("could not stat '/'");
return( FALSE);
}
dir = opendir("/dev");
if (!dir) {
- error_msg("could not open '/dev'\n");
+ error_msg("could not open '/dev'");
return( FALSE);
}
#if defined BB_ECHO || defined BB_SH || defined BB_TR
char process_escape_sequence(char **ptr)
{
- char c;
-
- switch (c = *(*ptr)++) {
- case 'a':
- c = '\a';
- break;
- case 'b':
- c = '\b';
- break;
- case 'f':
- c = '\f';
- break;
- case 'n':
- c = '\n';
- break;
- case 'r':
- c = '\r';
- break;
- case 't':
- c = '\t';
- break;
- case 'v':
- c = '\v';
- break;
- case '\\':
- c = '\\';
- break;
- case '0': case '1': case '2': case '3':
- case '4': case '5': case '6': case '7':
- c -= '0';
- if ('0' <= **ptr && **ptr <= '7') {
- c = c * 8 + (*(*ptr)++ - '0');
- if ('0' <= **ptr && **ptr <= '7')
- c = c * 8 + (*(*ptr)++ - '0');
- }
- break;
- default:
- (*ptr)--;
- c = '\\';
- break;
- }
- return c;
+ static const char charmap[] = {
+ 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', 0,
+ '\a', '\b', '\f', '\n', '\r', '\t', '\v', '\\', '\\' };
+
+ const char *p;
+ char *q;
+ int num_digits;
+ unsigned int n;
+
+ n = 0;
+ q = *ptr;
+
+ for ( num_digits = 0 ; num_digits < 3 ; ++num_digits) {
+ if ((*q < '0') || (*q > '7')) { /* not a digit? */
+ break;
+ }
+ n = n * 8 + (*q++ - '0');
+ }
+
+ if (num_digits == 0) { /* mnemonic escape sequence? */
+ for (p=charmap ; *p ; p++) {
+ if (*p == *q) {
+ q++;
+ break;
+ }
+ }
+ n = *(p+(sizeof(charmap)/2));
+ }
+
+ /* doesn't hurt to fall through to here from mnemonic case */
+ if (n > UCHAR_MAX) { /* is octal code too big for a char? */
+ n /= 8; /* adjust value and */
+ --q; /* back up one char */
+ }
+
+ *ptr = q;
+ return (char) n;
}
#endif
#if defined BB_BASENAME || defined BB_LN || defined BB_SH || defined BB_INIT || \
- defined BB_FEATURE_USE_PROCFS || defined BB_WGET
+ ! defined BB_FEATURE_USE_DEVPS_PATCH || defined BB_WGET
char *get_last_path_component(char *path)
{
char *s=path+strlen(path)-1;
int errmsgsz = regerror(ret, preg, NULL, 0);
char *errmsg = xmalloc(errmsgsz);
regerror(ret, preg, errmsg, errmsgsz);
- error_msg_and_die("xregcomp: %s\n", errmsg);
+ error_msg_and_die("xregcomp: %s", errmsg);
}
}
#endif
#if defined BB_HOSTNAME || defined BB_LOADACM || defined BB_MORE \
|| defined BB_SED || defined BB_SH || defined BB_TAR || defined BB_UNIQ \
- || defined BB_WC || defined BB_CMP || defined BB_SORT
+ || defined BB_WC || defined BB_CMP || defined BB_SORT || defined BB_WGET \
+ || defined BB_MOUNT
FILE *xfopen(const char *path, const char *mode)
{
FILE *fp;
}
#endif
-int applet_name_compare(const void *x, const void *y)
+static int applet_name_compare(const void *x, const void *y)
+{
+ const char *name = x;
+ const struct BB_applet *applet = y;
+
+ return strcmp(name, applet->name);
+}
+
+extern size_t NUM_APPLETS;
+
+struct BB_applet *find_applet_by_name(const char *name)
{
- const struct BB_applet *applet1 = x;
- const struct BB_applet *applet2 = y;
+ return bsearch(name, applets, NUM_APPLETS, sizeof(struct BB_applet),
+ applet_name_compare);
+}
- return strcmp(applet1->name, applet2->name);
+void run_applet_by_name(const char *name, int argc, char **argv)
+{
+ /* Do a binary search to find the applet entry given the name. */
+ if ((applet_using = find_applet_by_name(name)) != NULL) {
+ applet_name = applet_using->name;
+ if (argv[1] && strcmp(argv[1], "--help") == 0)
+ show_usage();
+ exit((*(applet_using->main)) (argc, argv));
+ }
}
#if defined BB_DD || defined BB_TAIL
-unsigned long parse_number(const char *numstr, struct suffix_mult *suffixes)
+unsigned long parse_number(const char *numstr,
+ const struct suffix_mult *suffixes)
{
- struct suffix_mult *sm;
+ const struct suffix_mult *sm;
unsigned long int ret;
int len;
char *end;
ret = strtoul(numstr, &end, 10);
if (numstr == end)
- error_msg_and_die("invalid number `%s'\n", numstr);
+ error_msg_and_die("invalid number `%s'", numstr);
while (end[0] != '\0') {
for (sm = suffixes; sm->suffix != NULL; sm++) {
len = strlen(sm->suffix);
}
}
if (sm->suffix == NULL)
- error_msg_and_die("invalid number `%s'\n", numstr);
+ error_msg_and_die("invalid number `%s'", numstr);
}
return ret;
}
#endif
#ifdef BB_FEATURE_HUMAN_READABLE
-char *format(unsigned long val, unsigned long hr)
+const char *format(unsigned long val, unsigned long hr)
{
- static char str[10] = "\0";
-
- if(val == 0)
- return("0");
- if(hr)
- snprintf(str, 9, "%ld", val/hr);
- else if(val >= GIGABYTE)
- snprintf(str, 9, "%.1LfG", ((long double)(val)/GIGABYTE));
- else if(val >= MEGABYTE)
- snprintf(str, 9, "%.1LfM", ((long double)(val)/MEGABYTE));
- else if(val >= KILOBYTE)
- snprintf(str, 9, "%.1Lfk", ((long double)(val)/KILOBYTE));
- else
- snprintf(str, 9, "%ld", (val));
- return(str);
+ static const char strings[] = { '0', 0, 'k', 0, 'M', 0, 'G', 0 };
+ static const char fmt[] = "%lu";
+ static const char fmt_u[] = "%lu.%lu%s";
+
+ static char str[10];
+
+ unsigned long frac __attribute__ ((unused)); /* 'may be uninitialized' warning is ok */
+ const char *u;
+ const char *f;
+
+#if 1
+ if(val == 0) { /* This may be omitted to reduce size */
+ return strings; /* at the cost of speed. */
+ }
+#endif
+
+ u = strings;
+ f = fmt;
+ if (hr) {
+ val /= hr;
+ } else {
+ while ((val >= KILOBYTE) && (*u != 'G')) {
+ f = fmt_u;
+ u += 2;
+ frac = (((val % KILOBYTE) * 10) + (KILOBYTE/2)) / KILOBYTE;
+ val /= KILOBYTE;
+ if (frac >= 10) { /* We need to round up here. */
+ ++val;
+ frac = 0;
+ }
+ }
+ }
+
+ /* If f==fmt then 'frac' and 'u' are ignored and need not be set. */
+ snprintf(str, sizeof(str), f, val, frac, u);
+
+ return str;
+}
+#endif
+
+#if defined(BB_GREP) || defined(BB_HOSTNAME) || defined(BB_SED) || defined(BB_TAR) || defined(BB_WGET) || defined(BB_XARGS)
+void chomp(char *s)
+{
+ size_t len = strlen(s);
+
+ if (len == 0)
+ return;
+
+ if (s[len-1] == '\n')
+ s[len-1] = '\0';
}
#endif