diff options
| author |   Bjørn Mork <bjorn@mork.no> | 2015-05-15 10:20:47 +0200 |
|---|---|---|
| committer | Bjørn Mork <bjorn@mork.no> | 2015-05-15 10:20:47 +0200 |
| commit | 73b16af8feec390afbabd9356d6e5e83c0390838 (patch) | |
| tree | 3730020ba2f9caeb9d7815a975af51830b51ce11 /include | |
busybox: imported from http://www.busybox.net/downloads/busybox-1.13.3.tar.bz2busybox-1.13.3
Signed-off-by: Bjørn Mork <bjorn@mork.no>
Diffstat (limited to 'include')
| -rw-r--r-- | include/applets.h | 418 | ||||
| -rw-r--r-- | include/busybox.h | 78 | ||||
| -rw-r--r-- | include/dump.h | 60 | ||||
| -rw-r--r-- | include/grp_.h | 122 | ||||
| -rw-r--r-- | include/inet_common.h | 26 | ||||
| -rw-r--r-- | include/libbb.h | 1497 | ||||
| -rw-r--r-- | include/platform.h | 366 | ||||
| -rw-r--r-- | include/pwd_.h | 114 | ||||
| -rw-r--r-- | include/rtc_.h | 79 | ||||
| -rw-r--r-- | include/shadow_.h | 104 | ||||
| -rw-r--r-- | include/unarchive.h | 157 | ||||
| -rw-r--r-- | include/usage.h | 4757 | ||||
| -rw-r--r-- | include/volume_id.h | 23 | ||||
| -rw-r--r-- | include/xatonum.h | 176 | ||||
| -rw-r--r-- | include/xregex.h | 27 |
15 files changed, 8004 insertions, 0 deletions
diff --git a/include/applets.h b/include/applets.h new file mode 100644 index 0000000..0e4cbd5 --- /dev/null +++ b/include/applets.h @@ -0,0 +1,418 @@ +/* vi: set sw=4 ts=4: */ +/* + * applets.h - a listing of all busybox applets. + * + * If you write a new applet, you need to add an entry to this list to make + * busybox aware of it. + * + * It is CRUCIAL that this listing be kept in ascii order, otherwise the binary + * search lookup contributed by Gaute B Strokkenes stops working. If you value + * your kneecaps, you'll be sure to *make sure* that any changes made to this + * file result in the listing remaining in ascii order. You have been warned. + */ + +/* +name - applet name as it is typed on command line +name2 - applet name, converted to C (ether-wake: name2 = ether_wake) +main - corresponding <applet>_main to call (bzcat: main = bunzip2) +l - location to install link to: [/usr]/[s]bin +s - suid type: + _BB_SUID_ALWAYS: will complain if busybox isn't suid + and is run by non-root (applet_main() will not be called at all) + _BB_SUID_NEVER: will drop suid prior to applet_main() + _BB_SUID_MAYBE: neither of the above +*/ + +#if defined(PROTOTYPES) +# define APPLET(name,l,s) int name##_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +# define APPLET_ODDNAME(name,main,l,s,name2) int main##_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +# define APPLET_NOEXEC(name,main,l,s,name2) int main##_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +# define APPLET_NOFORK(name,main,l,s,name2) int main##_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; + +#elif defined(NAME_MAIN_CNAME) +# define APPLET(name,l,s) name name##_main name +# define APPLET_ODDNAME(name,main,l,s,name2) name main##_main name2 +# define APPLET_NOEXEC(name,main,l,s,name2) name main##_main name2 +# define APPLET_NOFORK(name,main,l,s,name2) name main##_main name2 + +#elif defined(MAKE_USAGE) && ENABLE_FEATURE_VERBOSE_USAGE +# define APPLET(name,l,s) name##_trivial_usage name##_full_usage "\0" +# define APPLET_ODDNAME(name,main,l,s,name2) name2##_trivial_usage name2##_full_usage "\0" +# define APPLET_NOEXEC(name,main,l,s,name2) name2##_trivial_usage name2##_full_usage "\0" +# define APPLET_NOFORK(name,main,l,s,name2) name2##_trivial_usage name2##_full_usage "\0" + +#elif defined(MAKE_USAGE) && !ENABLE_FEATURE_VERBOSE_USAGE +# define APPLET(name,l,s) name##_trivial_usage "\0" +# define APPLET_ODDNAME(name,main,l,s,name2) name2##_trivial_usage "\0" +# define APPLET_NOEXEC(name,main,l,s,name2) name2##_trivial_usage "\0" +# define APPLET_NOFORK(name,main,l,s,name2) name2##_trivial_usage "\0" + +#elif defined(MAKE_LINKS) +# define APPLET(name,l,c) LINK l name +# define APPLET_ODDNAME(name,main,l,s,name2) LINK l name +# define APPLET_NOEXEC(name,main,l,s,name2) LINK l name +# define APPLET_NOFORK(name,main,l,s,name2) LINK l name + +#else + static struct bb_applet applets[] = { /* name, main, location, need_suid */ +# define APPLET(name,l,s) { #name, #name, l, s }, +# define APPLET_ODDNAME(name,main,l,s,name2) { #name, #main, l, s }, +# define APPLET_NOEXEC(name,main,l,s,name2) { #name, #main, l, s, 1 }, +# define APPLET_NOFORK(name,main,l,s,name2) { #name, #main, l, s, 1, 1 }, +#endif + +#if ENABLE_INSTALL_NO_USR +# define _BB_DIR_USR_BIN _BB_DIR_BIN +# define _BB_DIR_USR_SBIN _BB_DIR_SBIN +#endif + + +USE_TEST(APPLET_NOFORK([, test, _BB_DIR_USR_BIN, _BB_SUID_NEVER, test)) +USE_TEST(APPLET_NOFORK([[, test, _BB_DIR_USR_BIN, _BB_SUID_NEVER, test)) +USE_ADDGROUP(APPLET(addgroup, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_ADDUSER(APPLET(adduser, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_ADJTIMEX(APPLET(adjtimex, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_AR(APPLET(ar, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_ARP(APPLET(arp, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_ARPING(APPLET(arping, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_ASH(APPLET(ash, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_AWK(APPLET_NOEXEC(awk, awk, _BB_DIR_USR_BIN, _BB_SUID_NEVER, awk)) +USE_BASENAME(APPLET_NOFORK(basename, basename, _BB_DIR_USR_BIN, _BB_SUID_NEVER, basename)) +USE_BBCONFIG(APPLET(bbconfig, _BB_DIR_BIN, _BB_SUID_NEVER)) +//USE_BBSH(APPLET(bbsh, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_BLKID(APPLET(blkid, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_BRCTL(APPLET(brctl, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_BUNZIP2(APPLET(bunzip2, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_BUNZIP2(APPLET_ODDNAME(bzcat, bunzip2, _BB_DIR_USR_BIN, _BB_SUID_NEVER, bzcat)) +USE_BZIP2(APPLET(bzip2, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_CAL(APPLET(cal, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_CAT(APPLET_NOFORK(cat, cat, _BB_DIR_BIN, _BB_SUID_NEVER, cat)) +USE_CATV(APPLET(catv, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_CHAT(APPLET(chat, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_CHATTR(APPLET(chattr, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_CHCON(APPLET(chcon, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_CHGRP(APPLET_NOEXEC(chgrp, chgrp, _BB_DIR_BIN, _BB_SUID_NEVER, chgrp)) +USE_CHMOD(APPLET_NOEXEC(chmod, chmod, _BB_DIR_BIN, _BB_SUID_NEVER, chmod)) +USE_CHOWN(APPLET_NOEXEC(chown, chown, _BB_DIR_BIN, _BB_SUID_NEVER, chown)) +USE_CHPASSWD(APPLET(chpasswd, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_CHPST(APPLET(chpst, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_CHROOT(APPLET(chroot, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_CHRT(APPLET(chrt, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_CHVT(APPLET(chvt, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_CKSUM(APPLET(cksum, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_CLEAR(APPLET(clear, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_CMP(APPLET(cmp, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_COMM(APPLET(comm, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_CP(APPLET_NOEXEC(cp, cp, _BB_DIR_BIN, _BB_SUID_NEVER, cp)) +USE_CPIO(APPLET(cpio, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_CROND(APPLET(crond, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_CRONTAB(APPLET(crontab, _BB_DIR_USR_BIN, _BB_SUID_ALWAYS)) +USE_CRYPTPW(APPLET(cryptpw, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_CTTYHACK(APPLET(cttyhack, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_CUT(APPLET_NOEXEC(cut, cut, _BB_DIR_USR_BIN, _BB_SUID_NEVER, cut)) +USE_DATE(APPLET(date, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_DC(APPLET(dc, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_DD(APPLET_NOEXEC(dd, dd, _BB_DIR_BIN, _BB_SUID_NEVER, dd)) +USE_DEALLOCVT(APPLET(deallocvt, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_DELGROUP(APPLET_ODDNAME(delgroup, deluser, _BB_DIR_BIN, _BB_SUID_NEVER, delgroup)) +USE_DELUSER(APPLET(deluser, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_DEPMOD(APPLET(depmod, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_MODPROBE_SMALL(APPLET_ODDNAME(depmod, modprobe, _BB_DIR_SBIN, _BB_SUID_NEVER, modprobe)) +USE_DEVFSD(APPLET(devfsd, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_DEVMEM(APPLET(devmem, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_DF(APPLET(df, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_APP_DHCPRELAY(APPLET(dhcprelay, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_DIFF(APPLET(diff, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_DIRNAME(APPLET_NOFORK(dirname, dirname, _BB_DIR_USR_BIN, _BB_SUID_NEVER, dirname)) +USE_DMESG(APPLET(dmesg, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_DNSD(APPLET(dnsd, _BB_DIR_USR_SBIN, _BB_SUID_ALWAYS)) +USE_DOS2UNIX(APPLET(dos2unix, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_DPKG(APPLET(dpkg, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_DPKG_DEB(APPLET_ODDNAME(dpkg-deb, dpkg_deb, _BB_DIR_USR_BIN, _BB_SUID_NEVER, dpkg_deb)) +USE_DU(APPLET(du, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_DUMPKMAP(APPLET(dumpkmap, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_APP_DUMPLEASES(APPLET(dumpleases, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +//USE_E2FSCK(APPLET(e2fsck, _BB_DIR_SBIN, _BB_SUID_NEVER)) +//USE_E2LABEL(APPLET_ODDNAME(e2label, tune2fs, _BB_DIR_SBIN, _BB_SUID_NEVER, e2label)) +USE_ECHO(APPLET_NOFORK(echo, echo, _BB_DIR_BIN, _BB_SUID_NEVER, echo)) +USE_ED(APPLET(ed, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_FEATURE_GREP_EGREP_ALIAS(APPLET_ODDNAME(egrep, grep, _BB_DIR_BIN, _BB_SUID_NEVER, egrep)) +USE_EJECT(APPLET(eject, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_ENV(APPLET_NOEXEC(env, env, _BB_DIR_USR_BIN, _BB_SUID_NEVER, env)) +USE_ENVDIR(APPLET_ODDNAME(envdir, chpst, _BB_DIR_USR_BIN, _BB_SUID_NEVER, envdir)) +USE_ENVUIDGID(APPLET_ODDNAME(envuidgid, chpst, _BB_DIR_USR_BIN, _BB_SUID_NEVER, envuidgid)) +USE_ETHER_WAKE(APPLET_ODDNAME(ether-wake, ether_wake, _BB_DIR_USR_BIN, _BB_SUID_NEVER, ether_wake)) +USE_EXPAND(APPLET(expand, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_EXPR(APPLET(expr, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_FAKEIDENTD(APPLET(fakeidentd, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_FALSE(APPLET_NOFORK(false, false, _BB_DIR_BIN, _BB_SUID_NEVER, false)) +USE_FBSET(APPLET(fbset, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_FBSPLASH(APPLET(fbsplash, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_FDFLUSH(APPLET_ODDNAME(fdflush, freeramdisk, _BB_DIR_BIN, _BB_SUID_NEVER, fdflush)) +USE_FDFORMAT(APPLET(fdformat, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_FDISK(APPLET(fdisk, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_FEATURE_GREP_FGREP_ALIAS(APPLET_ODDNAME(fgrep, grep, _BB_DIR_BIN, _BB_SUID_NEVER, fgrep)) +USE_FIND(APPLET_NOEXEC(find, find, _BB_DIR_USR_BIN, _BB_SUID_NEVER, find)) +USE_FINDFS(APPLET(findfs, _BB_DIR_SBIN, _BB_SUID_MAYBE)) +USE_FOLD(APPLET(fold, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_FREE(APPLET(free, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_FREERAMDISK(APPLET(freeramdisk, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_FSCK(APPLET(fsck, _BB_DIR_SBIN, _BB_SUID_NEVER)) +//USE_E2FSCK(APPLET_ODDNAME(fsck.ext2, e2fsck, _BB_DIR_SBIN, _BB_SUID_NEVER, fsck_ext2)) +//USE_E2FSCK(APPLET_ODDNAME(fsck.ext3, e2fsck, _BB_DIR_SBIN, _BB_SUID_NEVER, fsck_ext3)) +USE_FSCK_MINIX(APPLET_ODDNAME(fsck.minix, fsck_minix, _BB_DIR_SBIN, _BB_SUID_NEVER, fsck_minix)) +USE_FTPGET(APPLET_ODDNAME(ftpget, ftpgetput, _BB_DIR_USR_BIN, _BB_SUID_NEVER, ftpget)) +USE_FTPPUT(APPLET_ODDNAME(ftpput, ftpgetput, _BB_DIR_USR_BIN, _BB_SUID_NEVER, ftpput)) +USE_FUSER(APPLET(fuser, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_GETENFORCE(APPLET(getenforce, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_GETOPT(APPLET(getopt, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_GETSEBOOL(APPLET(getsebool, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_GETTY(APPLET(getty, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_GREP(APPLET(grep, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_GUNZIP(APPLET(gunzip, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_GZIP(APPLET(gzip, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_HALT(APPLET(halt, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_HD(APPLET_NOEXEC(hd, hexdump, _BB_DIR_USR_BIN, _BB_SUID_NEVER, hd)) +USE_HDPARM(APPLET(hdparm, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_HEAD(APPLET(head, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_HEXDUMP(APPLET_NOEXEC(hexdump, hexdump, _BB_DIR_USR_BIN, _BB_SUID_NEVER, hexdump)) +USE_HOSTID(APPLET_NOFORK(hostid, hostid, _BB_DIR_USR_BIN, _BB_SUID_NEVER, hostid)) +USE_HOSTNAME(APPLET(hostname, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_HTTPD(APPLET(httpd, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_HUSH(APPLET(hush, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_HWCLOCK(APPLET(hwclock, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_ID(APPLET(id, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_IFCONFIG(APPLET(ifconfig, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_IFUPDOWN(APPLET_ODDNAME(ifdown, ifupdown, _BB_DIR_SBIN, _BB_SUID_NEVER, ifdown)) +USE_IFENSLAVE(APPLET(ifenslave, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_IFUPDOWN(APPLET_ODDNAME(ifup, ifupdown, _BB_DIR_SBIN, _BB_SUID_NEVER, ifup)) +USE_INETD(APPLET(inetd, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_INIT(APPLET(init, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_INOTIFYD(APPLET(inotifyd, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_INSMOD(APPLET(insmod, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_MODPROBE_SMALL(APPLET_ODDNAME(insmod, modprobe, _BB_DIR_SBIN, _BB_SUID_NEVER, modprobe)) +USE_INSTALL(APPLET(install, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +#if ENABLE_FEATURE_IP_ADDRESS \ + || ENABLE_FEATURE_IP_ROUTE \ + || ENABLE_FEATURE_IP_LINK \ + || ENABLE_FEATURE_IP_TUNNEL \ + || ENABLE_FEATURE_IP_RULE +USE_IP(APPLET(ip, _BB_DIR_BIN, _BB_SUID_NEVER)) +#endif +USE_IPADDR(APPLET(ipaddr, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_IPCALC(APPLET(ipcalc, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_IPCRM(APPLET(ipcrm, _BB_DIR_USR_BIN, _BB_SUID_ALWAYS)) +USE_IPCS(APPLET(ipcs, _BB_DIR_USR_BIN, _BB_SUID_ALWAYS)) +USE_IPLINK(APPLET(iplink, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_IPROUTE(APPLET(iproute, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_IPRULE(APPLET(iprule, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_IPTUNNEL(APPLET(iptunnel, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_KBD_MODE(APPLET(kbd_mode, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_KILL(APPLET(kill, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_KILLALL(APPLET_ODDNAME(killall, kill, _BB_DIR_USR_BIN, _BB_SUID_NEVER, killall)) +USE_KILLALL5(APPLET_ODDNAME(killall5, kill, _BB_DIR_USR_BIN, _BB_SUID_NEVER, killall5)) +USE_KLOGD(APPLET(klogd, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_LASH(APPLET(lash, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_LAST(APPLET(last, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_LENGTH(APPLET_NOFORK(length, length, _BB_DIR_USR_BIN, _BB_SUID_NEVER, length)) +USE_LESS(APPLET(less, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_SETARCH(APPLET_ODDNAME(linux32, setarch, _BB_DIR_BIN, _BB_SUID_NEVER, linux32)) +USE_SETARCH(APPLET_ODDNAME(linux64, setarch, _BB_DIR_BIN, _BB_SUID_NEVER, linux64)) +USE_FEATURE_INITRD(APPLET_ODDNAME(linuxrc, init, _BB_DIR_ROOT, _BB_SUID_NEVER, linuxrc)) +USE_LN(APPLET_NOEXEC(ln, ln, _BB_DIR_BIN, _BB_SUID_NEVER, ln)) +USE_LOAD_POLICY(APPLET(load_policy, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_LOADFONT(APPLET(loadfont, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_LOADKMAP(APPLET(loadkmap, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_LOGGER(APPLET(logger, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_LOGIN(APPLET(login, _BB_DIR_BIN, _BB_SUID_ALWAYS)) +USE_LOGNAME(APPLET_NOFORK(logname, logname, _BB_DIR_USR_BIN, _BB_SUID_NEVER, logname)) +USE_LOGREAD(APPLET(logread, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_LOSETUP(APPLET(losetup, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_LPD(APPLET(lpd, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_LPQ(APPLET_ODDNAME(lpq, lpqr, _BB_DIR_USR_BIN, _BB_SUID_NEVER, lpq)) +USE_LPR(APPLET_ODDNAME(lpr, lpqr, _BB_DIR_USR_BIN, _BB_SUID_NEVER, lpr)) +USE_LS(APPLET_NOEXEC(ls, ls, _BB_DIR_BIN, _BB_SUID_NEVER, ls)) +USE_LSATTR(APPLET(lsattr, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_LSMOD(APPLET(lsmod, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_MODPROBE_SMALL(APPLET_ODDNAME(lsmod, modprobe, _BB_DIR_SBIN, _BB_SUID_NEVER, modprobe)) +USE_UNLZMA(APPLET_ODDNAME(lzmacat, unlzma, _BB_DIR_USR_BIN, _BB_SUID_NEVER, lzmacat)) +USE_MAKEDEVS(APPLET(makedevs, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_MAKEMIME(APPLET(makemime, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_MAN(APPLET(man, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_MATCHPATHCON(APPLET(matchpathcon, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_MD5SUM(APPLET_ODDNAME(md5sum, md5_sha1_sum, _BB_DIR_USR_BIN, _BB_SUID_NEVER, md5sum)) +USE_MDEV(APPLET(mdev, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_MESG(APPLET(mesg, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_MICROCOM(APPLET(microcom, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_MKDIR(APPLET_NOFORK(mkdir, mkdir, _BB_DIR_BIN, _BB_SUID_NEVER, mkdir)) +//USE_MKE2FS(APPLET(mke2fs, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_MKFIFO(APPLET(mkfifo, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +//USE_MKE2FS(APPLET_ODDNAME(mkfs.ext2, mke2fs, _BB_DIR_SBIN, _BB_SUID_NEVER, mkfs_ext2)) +//USE_MKE2FS(APPLET_ODDNAME(mkfs.ext3, mke2fs, _BB_DIR_SBIN, _BB_SUID_NEVER, mkfs_ext3)) +USE_MKFS_MINIX(APPLET_ODDNAME(mkfs.minix, mkfs_minix, _BB_DIR_SBIN, _BB_SUID_NEVER, mkfs_minix)) +USE_MKNOD(APPLET(mknod, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_MKSWAP(APPLET(mkswap, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_MKTEMP(APPLET(mktemp, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_MODPROBE(APPLET(modprobe, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_MODPROBE_SMALL(APPLET(modprobe, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_MORE(APPLET(more, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_MOUNT(APPLET(mount, _BB_DIR_BIN, USE_DESKTOP(_BB_SUID_MAYBE) SKIP_DESKTOP(_BB_SUID_NEVER))) +USE_MOUNTPOINT(APPLET(mountpoint, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_MSH(APPLET(msh, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_MT(APPLET(mt, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_MV(APPLET(mv, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_NAMEIF(APPLET(nameif, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_NC(APPLET(nc, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_NETSTAT(APPLET(netstat, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_NICE(APPLET(nice, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_NMETER(APPLET(nmeter, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_NOHUP(APPLET(nohup, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_NSLOOKUP(APPLET(nslookup, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_OD(APPLET(od, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_OPENVT(APPLET(openvt, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +//USE_PARSE(APPLET(parse, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_PASSWD(APPLET(passwd, _BB_DIR_USR_BIN, _BB_SUID_ALWAYS)) +USE_PATCH(APPLET(patch, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_PGREP(APPLET(pgrep, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_PIDOF(APPLET(pidof, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_PING(APPLET(ping, _BB_DIR_BIN, _BB_SUID_MAYBE)) +USE_PING6(APPLET(ping6, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_PIPE_PROGRESS(APPLET(pipe_progress, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_PIVOT_ROOT(APPLET(pivot_root, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_PKILL(APPLET_ODDNAME(pkill, pgrep, _BB_DIR_USR_BIN, _BB_SUID_NEVER, pkill)) +USE_POPMAILDIR(APPLET(popmaildir, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_HALT(APPLET_ODDNAME(poweroff, halt, _BB_DIR_SBIN, _BB_SUID_NEVER, poweroff)) +USE_PRINTENV(APPLET(printenv, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_PRINTF(APPLET_NOFORK(printf, printf, _BB_DIR_USR_BIN, _BB_SUID_NEVER, printf)) +USE_PS(APPLET(ps, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_PSCAN(APPLET(pscan, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_PWD(APPLET_NOFORK(pwd, pwd, _BB_DIR_BIN, _BB_SUID_NEVER, pwd)) +USE_RAIDAUTORUN(APPLET(raidautorun, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_RDATE(APPLET(rdate, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_RDEV(APPLET(rdev, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_READAHEAD(APPLET(readahead, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_READLINK(APPLET(readlink, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_READPROFILE(APPLET(readprofile, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_REALPATH(APPLET(realpath, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_HALT(APPLET_ODDNAME(reboot, halt, _BB_DIR_SBIN, _BB_SUID_NEVER, reboot)) +USE_REFORMIME(APPLET(reformime, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_RENICE(APPLET(renice, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_RESET(APPLET(reset, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_RESIZE(APPLET(resize, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_RESTORECON(APPLET_ODDNAME(restorecon, setfiles, _BB_DIR_SBIN, _BB_SUID_NEVER, restorecon)) +USE_RM(APPLET_NOFORK(rm, rm, _BB_DIR_BIN, _BB_SUID_NEVER, rm)) +USE_RMDIR(APPLET_NOFORK(rmdir, rmdir, _BB_DIR_BIN, _BB_SUID_NEVER, rmdir)) +USE_RMMOD(APPLET(rmmod, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_MODPROBE_SMALL(APPLET_ODDNAME(rmmod, modprobe, _BB_DIR_SBIN, _BB_SUID_NEVER, modprobe)) +USE_ROUTE(APPLET(route, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_RPM(APPLET(rpm, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_RPM2CPIO(APPLET(rpm2cpio, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_RTCWAKE(APPLET(rtcwake, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_RUN_PARTS(APPLET_ODDNAME(run-parts, run_parts, _BB_DIR_BIN, _BB_SUID_NEVER, run_parts)) +USE_RUNCON(APPLET(runcon, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_RUNLEVEL(APPLET(runlevel, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_RUNSV(APPLET(runsv, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_RUNSVDIR(APPLET(runsvdir, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_RX(APPLET(rx, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_SCRIPT(APPLET(script, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_SED(APPLET(sed, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_SELINUXENABLED(APPLET(selinuxenabled, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_SENDMAIL(APPLET(sendmail, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_SEQ(APPLET_NOFORK(seq, seq, _BB_DIR_USR_BIN, _BB_SUID_NEVER, seq)) +USE_SESTATUS(APPLET(sestatus, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_SETARCH(APPLET(setarch, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_SETCONSOLE(APPLET(setconsole, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_SETENFORCE(APPLET(setenforce, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_SETFILES(APPLET(setfiles, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_SETFONT(APPLET(setfont, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_SETKEYCODES(APPLET(setkeycodes, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_SETLOGCONS(APPLET(setlogcons, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_SETSEBOOL(APPLET(setsebool, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_SETSID(APPLET(setsid, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_SETUIDGID(APPLET_ODDNAME(setuidgid, chpst, _BB_DIR_USR_BIN, _BB_SUID_NEVER, setuidgid)) +USE_FEATURE_SH_IS_ASH(APPLET_ODDNAME(sh, ash, _BB_DIR_BIN, _BB_SUID_NEVER, sh)) +USE_FEATURE_SH_IS_HUSH(APPLET_ODDNAME(sh, hush, _BB_DIR_BIN, _BB_SUID_NEVER, sh)) +USE_FEATURE_SH_IS_MSH(APPLET_ODDNAME(sh, msh, _BB_DIR_BIN, _BB_SUID_NEVER, sh)) +USE_SHA1SUM(APPLET_ODDNAME(sha1sum, md5_sha1_sum, _BB_DIR_USR_BIN, _BB_SUID_NEVER, sha1sum)) +USE_SHOWKEY(APPLET(showkey, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_SLATTACH(APPLET(slattach, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_SLEEP(APPLET_NOFORK(sleep, sleep, _BB_DIR_BIN, _BB_SUID_NEVER, sleep)) +USE_SOFTLIMIT(APPLET_ODDNAME(softlimit, chpst, _BB_DIR_USR_BIN, _BB_SUID_NEVER, softlimit)) +USE_SORT(APPLET_NOEXEC(sort, sort, _BB_DIR_USR_BIN, _BB_SUID_NEVER, sort)) +USE_SPLIT(APPLET(split, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_START_STOP_DAEMON(APPLET_ODDNAME(start-stop-daemon, start_stop_daemon, _BB_DIR_SBIN, _BB_SUID_NEVER, start_stop_daemon)) +USE_STAT(APPLET(stat, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_STRINGS(APPLET(strings, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_STTY(APPLET(stty, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_SU(APPLET(su, _BB_DIR_BIN, _BB_SUID_ALWAYS)) +USE_SULOGIN(APPLET(sulogin, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_SUM(APPLET(sum, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_SV(APPLET(sv, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_SVLOGD(APPLET(svlogd, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_SWAPONOFF(APPLET_ODDNAME(swapoff, swap_on_off, _BB_DIR_SBIN, _BB_SUID_NEVER,swapoff)) +USE_SWAPONOFF(APPLET_ODDNAME(swapon, swap_on_off, _BB_DIR_SBIN, _BB_SUID_NEVER, swapon)) +USE_SWITCH_ROOT(APPLET(switch_root, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_SYNC(APPLET_NOFORK(sync, sync, _BB_DIR_BIN, _BB_SUID_NEVER, sync)) +USE_BB_SYSCTL(APPLET(sysctl, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_SYSLOGD(APPLET(syslogd, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_TAC(APPLET_NOEXEC(tac, tac, _BB_DIR_USR_BIN, _BB_SUID_NEVER, tac)) +USE_TAIL(APPLET(tail, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_TAR(APPLET(tar, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_TASKSET(APPLET(taskset, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +/* USE_TC(APPLET(tc, _BB_DIR_SBIN, _BB_SUID_NEVER)) */ +USE_TCPSVD(APPLET_ODDNAME(tcpsvd, tcpudpsvd, _BB_DIR_USR_BIN, _BB_SUID_NEVER, tcpsvd)) +USE_TEE(APPLET(tee, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_TELNET(APPLET(telnet, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_TELNETD(APPLET(telnetd, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_TEST(APPLET_NOFORK(test, test, _BB_DIR_USR_BIN, _BB_SUID_NEVER, test)) +#if ENABLE_FEATURE_TFTP_GET || ENABLE_FEATURE_TFTP_PUT +USE_TFTP(APPLET(tftp, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_TFTPD(APPLET(tftpd, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +#endif +USE_TIME(APPLET(time, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_TOP(APPLET(top, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_TOUCH(APPLET_NOFORK(touch, touch, _BB_DIR_BIN, _BB_SUID_NEVER, touch)) +USE_TR(APPLET(tr, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_TRACEROUTE(APPLET(traceroute, _BB_DIR_USR_BIN, _BB_SUID_MAYBE)) +USE_TRUE(APPLET_NOFORK(true, true, _BB_DIR_BIN, _BB_SUID_NEVER, true)) +USE_TTY(APPLET(tty, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_TTYSIZE(APPLET(ttysize, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +//USE_TUNE2FS(APPLET(tune2fs, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_APP_UDHCPC(APPLET(udhcpc, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_APP_UDHCPD(APPLET(udhcpd, _BB_DIR_USR_SBIN, _BB_SUID_NEVER)) +USE_UDPSVD(APPLET_ODDNAME(udpsvd, tcpudpsvd, _BB_DIR_USR_BIN, _BB_SUID_NEVER, udpsvd)) +USE_UMOUNT(APPLET(umount, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_UNAME(APPLET(uname, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_UNCOMPRESS(APPLET(uncompress, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_UNEXPAND(APPLET_ODDNAME(unexpand, expand, _BB_DIR_USR_BIN, _BB_SUID_NEVER, unexpand)) +USE_UNIQ(APPLET(uniq, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_UNIX2DOS(APPLET_ODDNAME(unix2dos, dos2unix, _BB_DIR_USR_BIN, _BB_SUID_NEVER, unix2dos)) +USE_UNLZMA(APPLET(unlzma, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_UNZIP(APPLET(unzip, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_UPTIME(APPLET(uptime, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_USLEEP(APPLET_NOFORK(usleep, usleep, _BB_DIR_BIN, _BB_SUID_NEVER, usleep)) +USE_UUDECODE(APPLET(uudecode, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_UUENCODE(APPLET(uuencode, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_VCONFIG(APPLET(vconfig, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_VI(APPLET(vi, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_VLOCK(APPLET(vlock, _BB_DIR_USR_BIN, _BB_SUID_ALWAYS)) +USE_WATCH(APPLET(watch, _BB_DIR_BIN, _BB_SUID_NEVER)) +USE_WATCHDOG(APPLET(watchdog, _BB_DIR_SBIN, _BB_SUID_NEVER)) +USE_WC(APPLET(wc, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_WGET(APPLET(wget, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_WHICH(APPLET(which, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_WHO(APPLET(who, _BB_DIR_USR_BIN, _BB_SUID_NEVER)) +USE_WHOAMI(APPLET_NOFORK(whoami, whoami, _BB_DIR_USR_BIN, _BB_SUID_NEVER, whoami)) +USE_XARGS(APPLET_NOEXEC(xargs, xargs, _BB_DIR_USR_BIN, _BB_SUID_NEVER, xargs)) +USE_YES(APPLET_NOFORK(yes, yes, _BB_DIR_USR_BIN, _BB_SUID_NEVER, yes)) +USE_GUNZIP(APPLET_ODDNAME(zcat, gunzip, _BB_DIR_BIN, _BB_SUID_NEVER, zcat)) +USE_ZCIP(APPLET(zcip, _BB_DIR_SBIN, _BB_SUID_NEVER)) + +#if !defined(PROTOTYPES) && !defined(NAME_MAIN_CNAME) && !defined(MAKE_USAGE) +}; +#endif + +#undef APPLET +#undef APPLET_ODDNAME +#undef APPLET_NOEXEC +#undef APPLET_NOFORK diff --git a/include/busybox.h b/include/busybox.h new file mode 100644 index 0000000..314b951 --- /dev/null +++ b/include/busybox.h @@ -0,0 +1,78 @@ +/* vi: set sw=4 ts=4: */ +/* + * Busybox main internal header file + * + * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. + */ +#ifndef _BB_INTERNAL_H_ +#define _BB_INTERNAL_H_ 1 + +#include "libbb.h" + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility push(hidden) +#endif + +/* order matters: used as index into "install_dir[]" in appletlib.c */ +typedef enum bb_install_loc_t { + _BB_DIR_ROOT = 0, + _BB_DIR_BIN, + _BB_DIR_SBIN, + _BB_DIR_USR_BIN, + _BB_DIR_USR_SBIN +} bb_install_loc_t; + +typedef enum bb_suid_t { + _BB_SUID_NEVER = 0, + _BB_SUID_MAYBE, + _BB_SUID_ALWAYS +} bb_suid_t; + + +/* Defined in appletlib.c (by including generated applet_tables.h) */ +/* Keep in sync with applets/applet_tables.c! */ +extern const char applet_names[]; +extern int (*const applet_main[])(int argc, char **argv); +extern const uint16_t applet_nameofs[]; +extern const uint8_t applet_install_loc[]; + +#if ENABLE_FEATURE_SUID || ENABLE_FEATURE_PREFER_APPLETS +#define APPLET_NAME(i) (applet_names + (applet_nameofs[i] & 0x0fff)) +#else +#define APPLET_NAME(i) (applet_names + applet_nameofs[i]) +#endif + +#if ENABLE_FEATURE_PREFER_APPLETS +#define APPLET_IS_NOFORK(i) (applet_nameofs[i] & (1 << 12)) +#define APPLET_IS_NOEXEC(i) (applet_nameofs[i] & (1 << 13)) +#endif + +#if ENABLE_FEATURE_SUID +#define APPLET_SUID(i) ((applet_nameofs[i] >> 14) & 0x3) +#endif + +#if ENABLE_FEATURE_INSTALLER +#define APPLET_INSTALL_LOC(i) ({ \ + unsigned v = (i); \ + if (v & 1) v = applet_install_loc[v/2] >> 4; \ + else v = applet_install_loc[v/2] & 0xf; \ + v; }) +#endif + + +/* Length of these names has effect on size of libbusybox + * and "individual" binaries. Keep them short. + */ +#if ENABLE_BUILD_LIBBUSYBOX +#if ENABLE_FEATURE_SHARED_BUSYBOX +int lbb_main(char **argv) EXTERNALLY_VISIBLE; +#else +int lbb_main(char **argv); +#endif +#endif + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility pop +#endif + +#endif /* _BB_INTERNAL_H_ */ diff --git a/include/dump.h b/include/dump.h new file mode 100644 index 0000000..44f2082 --- /dev/null +++ b/include/dump.h @@ -0,0 +1,60 @@ +/* vi: set sw=4 ts=4: */ + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility push(hidden) +#endif + +#define F_IGNORE 0x01 /* %_A */ +#define F_SETREP 0x02 /* rep count set, not default */ +#define F_ADDRESS 0x001 /* print offset */ +#define F_BPAD 0x002 /* blank pad */ +#define F_C 0x004 /* %_c */ +#define F_CHAR 0x008 /* %c */ +#define F_DBL 0x010 /* %[EefGf] */ +#define F_INT 0x020 /* %[di] */ +#define F_P 0x040 /* %_p */ +#define F_STR 0x080 /* %s */ +#define F_U 0x100 /* %_u */ +#define F_UINT 0x200 /* %[ouXx] */ +#define F_TEXT 0x400 /* no conversions */ + +enum dump_vflag_t { ALL, DUP, FIRST, WAIT }; /* -v values */ + +typedef struct PR { + struct PR *nextpr; /* next print unit */ + unsigned flags; /* flag values */ + int bcnt; /* byte count */ + char *cchar; /* conversion character */ + char *fmt; /* printf format */ + char *nospace; /* no whitespace version */ +} PR; + +typedef struct FU { + struct FU *nextfu; /* next format unit */ + struct PR *nextpr; /* next print unit */ + unsigned flags; /* flag values */ + int reps; /* repetition count */ + int bcnt; /* byte count */ + char *fmt; /* format string */ +} FU; + +typedef struct FS { /* format strings */ + struct FS *nextfs; /* linked list of format strings */ + struct FU *nextfu; /* linked list of format units */ + int bcnt; +} FS; + +typedef struct dumper_t { + off_t dump_skip; /* bytes to skip */ + int dump_length; /* max bytes to read */ + smallint dump_vflag; /*enum dump_vflag_t*/ + FS *fshead; +} dumper_t; + +dumper_t* alloc_dumper(void) FAST_FUNC; +extern void bb_dump_add(dumper_t *dumper, const char *fmt) FAST_FUNC; +extern int bb_dump_dump(dumper_t *dumper, char **argv) FAST_FUNC; + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility pop +#endif diff --git a/include/grp_.h b/include/grp_.h new file mode 100644 index 0000000..3d00b4a --- /dev/null +++ b/include/grp_.h @@ -0,0 +1,122 @@ +/* vi: set sw=4 ts=4: */ +/* Copyright (C) 1991,92,95,96,97,98,99,2000,01 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +/* + * POSIX Standard: 9.2.1 Group Database Access <grp.h> + */ + +#ifndef BB_GRP_H +#define BB_GRP_H 1 + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility push(hidden) +#endif + +/* This file is #included after #include <grp.h> + * We will use libc-defined structures, but will #define function names + * so that function calls are directed to bb_internal_XXX replacements + */ + +#define setgrent bb_internal_setgrent +#define endgrent bb_internal_endgrent +#define getgrent bb_internal_getgrent +#define fgetgrent bb_internal_fgetgrent +#define putgrent bb_internal_putgrent +#define getgrgid bb_internal_getgrgid +#define getgrnam bb_internal_getgrnam +#define getgrent_r bb_internal_getgrent_r +#define getgrgid_r bb_internal_getgrgid_r +#define getgrnam_r bb_internal_getgrnam_r +#define fgetgrent_r bb_internal_fgetgrent_r +#define getgrouplist bb_internal_getgrouplist +#define initgroups bb_internal_initgroups + + +/* All function names below should be remapped by #defines above + * in order to not collide with libc names. */ + + +/* Rewind the group-file stream. */ +extern void setgrent(void); + +/* Close the group-file stream. */ +extern void endgrent(void); + +/* Read an entry from the group-file stream, opening it if necessary. */ +extern struct group *getgrent(void); + +/* Read a group entry from STREAM. */ +extern struct group *fgetgrent(FILE *__stream); + +/* Write the given entry onto the given stream. */ +extern int putgrent(const struct group *__restrict __p, + FILE *__restrict __f); + +/* Search for an entry with a matching group ID. */ +extern struct group *getgrgid(gid_t __gid); + +/* Search for an entry with a matching group name. */ +extern struct group *getgrnam(const char *__name); + +/* Reentrant versions of some of the functions above. + + PLEASE NOTE: the `getgrent_r' function is not (yet) standardized. + The interface may change in later versions of this library. But + the interface is designed following the principals used for the + other reentrant functions so the chances are good this is what the + POSIX people would choose. */ + +extern int getgrent_r(struct group *__restrict __resultbuf, + char *__restrict __buffer, size_t __buflen, + struct group **__restrict __result); + +/* Search for an entry with a matching group ID. */ +extern int getgrgid_r(gid_t __gid, struct group *__restrict __resultbuf, + char *__restrict __buffer, size_t __buflen, + struct group **__restrict __result); + +/* Search for an entry with a matching group name. */ +extern int getgrnam_r(const char *__restrict __name, + struct group *__restrict __resultbuf, + char *__restrict __buffer, size_t __buflen, + struct group **__restrict __result); + +/* Read a group entry from STREAM. This function is not standardized + an probably never will. */ +extern int fgetgrent_r(FILE *__restrict __stream, + struct group *__restrict __resultbuf, + char *__restrict __buffer, size_t __buflen, + struct group **__restrict __result); + +/* Store at most *NGROUPS members of the group set for USER into + *GROUPS. Also include GROUP. The actual number of groups found is + returned in *NGROUPS. Return -1 if the if *NGROUPS is too small. */ +extern int getgrouplist(const char *__user, gid_t __group, + gid_t *__groups, int *__ngroups); + +/* Initialize the group set for the current user + by reading the group database and using all groups + of which USER is a member. Also include GROUP. */ +extern int initgroups(const char *__user, gid_t __group); + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility pop +#endif + +#endif diff --git a/include/inet_common.h b/include/inet_common.h new file mode 100644 index 0000000..f4374e5 --- /dev/null +++ b/include/inet_common.h @@ -0,0 +1,26 @@ +/* vi: set sw=4 ts=4: */ +/* + * stolen from net-tools-1.59 and stripped down for busybox by + * Erik Andersen <andersen@codepoet.org> + * + * Heavily modified by Manuel Novoa III Mar 12, 2001 + * + */ + +#include "platform.h" + +/* hostfirst!=0 If we expect this to be a hostname, + try hostname database first + */ +int INET_resolve(const char *name, struct sockaddr_in *s_in, int hostfirst) FAST_FUNC; + +/* numeric: & 0x8000: "default" instead of "*", + * & 0x4000: host instead of net, + * & 0x0fff: don't resolve + */ + +int INET6_resolve(const char *name, struct sockaddr_in6 *sin6) FAST_FUNC; + +/* These return malloced string */ +char *INET_rresolve(struct sockaddr_in *s_in, int numeric, uint32_t netmask) FAST_FUNC; +char *INET6_rresolve(struct sockaddr_in6 *sin6, int numeric) FAST_FUNC; diff --git a/include/libbb.h b/include/libbb.h new file mode 100644 index 0000000..08fed90 --- /dev/null +++ b/include/libbb.h @@ -0,0 +1,1497 @@ +/* vi: set sw=4 ts=4: */ +/* + * Busybox main internal header file + * + * Based in part on code from sash, Copyright (c) 1999 by David I. Bell + * Permission has been granted to redistribute this code under the GPL. + * + * Licensed under the GPL version 2, see the file LICENSE in this tarball. + */ +#ifndef __LIBBUSYBOX_H__ +#define __LIBBUSYBOX_H__ 1 + +#include "platform.h" + +#include <ctype.h> +#include <dirent.h> +#include <errno.h> +#include <fcntl.h> +#include <inttypes.h> +#include <netdb.h> +#include <setjmp.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <stdarg.h> +#include <stddef.h> +#include <string.h> +#include <sys/poll.h> +#include <sys/ioctl.h> +#include <sys/mman.h> +#include <sys/socket.h> +#include <sys/stat.h> +#include <sys/time.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <termios.h> +#include <time.h> +#include <unistd.h> +#include <utime.h> +/* Try to pull in PATH_MAX */ +#include <limits.h> +#include <sys/param.h> +#ifndef PATH_MAX +#define PATH_MAX 256 +#endif + +#ifdef HAVE_MNTENT_H +#include <mntent.h> +#endif + +#ifdef HAVE_SYS_STATFS_H +#include <sys/statfs.h> +#endif + +#if ENABLE_SELINUX +#include <selinux/selinux.h> +#include <selinux/context.h> +#include <selinux/flask.h> +#include <selinux/av_permissions.h> +#endif + +#if ENABLE_LOCALE_SUPPORT +#include <locale.h> +#else +#define setlocale(x,y) ((void)0) +#endif + +#ifdef DMALLOC +#include <dmalloc.h> +#endif + +#include <pwd.h> +#include <grp.h> +#if ENABLE_FEATURE_SHADOWPASSWDS +# include <shadow.h> +#endif + +/* Some libc's forget to declare these, do it ourself */ + +extern char **environ; +#if defined(__GLIBC__) && __GLIBC__ < 2 +int vdprintf(int d, const char *format, va_list ap); +#endif +/* klogctl is in libc's klog.h, but we cheat and not #include that */ +int klogctl(int type, char *b, int len); +/* This is declared here rather than #including <libgen.h> in order to avoid + * confusing the two versions of basename. See the dirname/basename man page + * for details. */ +char *dirname(char *path); +/* Include our own copy of struct sysinfo to avoid binary compatibility + * problems with Linux 2.4, which changed things. Grumble, grumble. */ +struct sysinfo { + long uptime; /* Seconds since boot */ + unsigned long loads[3]; /* 1, 5, and 15 minute load averages */ + unsigned long totalram; /* Total usable main memory size */ + unsigned long freeram; /* Available memory size */ + unsigned long sharedram; /* Amount of shared memory */ + unsigned long bufferram; /* Memory used by buffers */ + unsigned long totalswap; /* Total swap space size */ + unsigned long freeswap; /* swap space still available */ + unsigned short procs; /* Number of current processes */ + unsigned short pad; /* Padding needed for m68k */ + unsigned long totalhigh; /* Total high memory size */ + unsigned long freehigh; /* Available high memory size */ + unsigned int mem_unit; /* Memory unit size in bytes */ + char _f[20 - 2 * sizeof(long) - sizeof(int)]; /* Padding: libc5 uses this.. */ +}; +int sysinfo(struct sysinfo* info); + + +/* Make all declarations hidden (-fvisibility flag only affects definitions) */ +/* (don't include system headers after this until corresponding pop!) */ +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility push(hidden) +#endif + + +#if ENABLE_USE_BB_PWD_GRP +# include "pwd_.h" +# include "grp_.h" +#endif +#if ENABLE_FEATURE_SHADOWPASSWDS +# if ENABLE_USE_BB_SHADOW +# include "shadow_.h" +# endif +#endif + +/* Tested to work correctly with all int types (IIRC :]) */ +#define MAXINT(T) (T)( \ + ((T)-1) > 0 \ + ? (T)-1 \ + : (T)~((T)1 << (sizeof(T)*8-1)) \ + ) + +#define MININT(T) (T)( \ + ((T)-1) > 0 \ + ? (T)0 \ + : ((T)1 << (sizeof(T)*8-1)) \ + ) + +/* Large file support */ +/* Note that CONFIG_LFS=y forces bbox to be built with all common ops + * (stat, lseek etc) mapped to "largefile" variants by libc. + * Practically it means that open() automatically has O_LARGEFILE added + * and all filesize/file_offset parameters and struct members are "large" + * (in today's world - signed 64bit). For full support of large files, + * we need a few helper #defines (below) and careful use of off_t + * instead of int/ssize_t. No lseek64(), O_LARGEFILE etc necessary */ +#if ENABLE_LFS +/* CONFIG_LFS is on */ +# if ULONG_MAX > 0xffffffff +/* "long" is long enough on this system */ +# define XATOOFF(a) xatoul_range(a, 0, LONG_MAX) +/* usage: sz = BB_STRTOOFF(s, NULL, 10); if (errno || sz < 0) die(); */ +# define BB_STRTOOFF bb_strtoul +# define STRTOOFF strtoul +/* usage: printf("size: %"OFF_FMT"d (%"OFF_FMT"x)\n", sz, sz); */ +# define OFF_FMT "l" +# else +/* "long" is too short, need "long long" */ +# define XATOOFF(a) xatoull_range(a, 0, LLONG_MAX) +# define BB_STRTOOFF bb_strtoull +# define STRTOOFF strtoull +# define OFF_FMT "ll" +# endif +#else +/* CONFIG_LFS is off */ +# if UINT_MAX == 0xffffffff +/* While sizeof(off_t) == sizeof(int), off_t is typedef'ed to long anyway. + * gcc will throw warnings on printf("%d", off_t). Crap... */ +# define XATOOFF(a) xatoi_u(a) +# define BB_STRTOOFF bb_strtou +# define STRTOOFF strtol +# define OFF_FMT "l" +# else +# define XATOOFF(a) xatoul_range(a, 0, LONG_MAX) +# define BB_STRTOOFF bb_strtoul +# define STRTOOFF strtol +# define OFF_FMT "l" +# endif +#endif +/* scary. better ideas? (but do *test* them first!) */ +#define OFF_T_MAX ((off_t)~((off_t)1 << (sizeof(off_t)*8-1))) + +/* Some useful definitions */ +#undef FALSE +#define FALSE ((int) 0) +#undef TRUE +#define TRUE ((int) 1) +#undef SKIP +#define SKIP ((int) 2) + +/* for mtab.c */ +#define MTAB_GETMOUNTPT '1' +#define MTAB_GETDEVICE '2' + +#define BUF_SIZE 8192 +#define EXPAND_ALLOC 1024 + +/* Macros for min/max. */ +#ifndef MIN +#define MIN(a,b) (((a)<(b))?(a):(b)) +#endif + +#ifndef MAX +#define MAX(a,b) (((a)>(b))?(a):(b)) +#endif + +/* buffer allocation schemes */ +#if ENABLE_FEATURE_BUFFERS_GO_ON_STACK +#define RESERVE_CONFIG_BUFFER(buffer,len) char buffer[len] +#define RESERVE_CONFIG_UBUFFER(buffer,len) unsigned char buffer[len] +#define RELEASE_CONFIG_BUFFER(buffer) ((void)0) +#else +#if ENABLE_FEATURE_BUFFERS_GO_IN_BSS +#define RESERVE_CONFIG_BUFFER(buffer,len) static char buffer[len] +#define RESERVE_CONFIG_UBUFFER(buffer,len) static unsigned char buffer[len] +#define RELEASE_CONFIG_BUFFER(buffer) ((void)0) +#else +#define RESERVE_CONFIG_BUFFER(buffer,len) char *buffer = xmalloc(len) +#define RESERVE_CONFIG_UBUFFER(buffer,len) unsigned char *buffer = xmalloc(len) +#define RELEASE_CONFIG_BUFFER(buffer) free(buffer) +#endif +#endif + +#if defined(__GLIBC__) +/* glibc uses __errno_location() to get a ptr to errno */ +/* We can just memorize it once - no multithreading in busybox :) */ +extern int *const bb_errno; +#undef errno +#define errno (*bb_errno) +#endif + +unsigned long long monotonic_ns(void) FAST_FUNC; +unsigned long long monotonic_us(void) FAST_FUNC; +unsigned monotonic_sec(void) FAST_FUNC; + +extern void chomp(char *s) FAST_FUNC; +extern void trim(char *s) FAST_FUNC; +extern char *skip_whitespace(const char *) FAST_FUNC; +extern char *skip_non_whitespace(const char *) FAST_FUNC; +extern char *strrstr(const char *haystack, const char *needle) FAST_FUNC; + +//TODO: supply a pointer to char[11] buffer (avoid statics)? +extern const char *bb_mode_string(mode_t mode) FAST_FUNC; +extern int is_directory(const char *name, int followLinks, struct stat *statBuf) FAST_FUNC; +enum { /* DO NOT CHANGE THESE VALUES! cp.c, mv.c, install.c depend on them. */ + FILEUTILS_PRESERVE_STATUS = 1, + FILEUTILS_DEREFERENCE = 2, + FILEUTILS_RECUR = 4, + FILEUTILS_FORCE = 8, + FILEUTILS_INTERACTIVE = 0x10, + FILEUTILS_MAKE_HARDLINK = 0x20, + FILEUTILS_MAKE_SOFTLINK = 0x40, + FILEUTILS_DEREF_SOFTLINK = 0x80, +#if ENABLE_SELINUX + FILEUTILS_PRESERVE_SECURITY_CONTEXT = 0x100, + FILEUTILS_SET_SECURITY_CONTEXT = 0x200 +#endif +}; +#define FILEUTILS_CP_OPTSTR "pdRfilsL" USE_SELINUX("c") +extern int remove_file(const char *path, int flags) FAST_FUNC; +/* NB: without FILEUTILS_RECUR in flags, it will basically "cat" + * the source, not copy (unless "source" is a directory). + * This makes "cp /dev/null file" and "install /dev/null file" (!!!) + * work coreutils-compatibly. */ +extern int copy_file(const char *source, const char *dest, int flags) FAST_FUNC; + +enum { + ACTION_RECURSE = (1 << 0), + ACTION_FOLLOWLINKS = (1 << 1), + ACTION_FOLLOWLINKS_L0 = (1 << 2), + ACTION_DEPTHFIRST = (1 << 3), + /*ACTION_REVERSE = (1 << 4), - unused */ + ACTION_QUIET = (1 << 5), +}; +extern int recursive_action(const char *fileName, unsigned flags, + int FAST_FUNC (*fileAction)(const char *fileName, struct stat* statbuf, void* userData, int depth), + int FAST_FUNC (*dirAction)(const char *fileName, struct stat* statbuf, void* userData, int depth), + void* userData, unsigned depth) FAST_FUNC; +extern int device_open(const char *device, int mode) FAST_FUNC; +enum { GETPTY_BUFSIZE = 16 }; /* more than enough for "/dev/ttyXXX" */ +extern int xgetpty(char *line) FAST_FUNC; +extern int get_console_fd_or_die(void) FAST_FUNC; +extern void console_make_active(int fd, const int vt_num) FAST_FUNC; +extern char *find_block_device(const char *path) FAST_FUNC; +/* bb_copyfd_XX print read/write errors and return -1 if they occur */ +extern off_t bb_copyfd_eof(int fd1, int fd2) FAST_FUNC; +extern off_t bb_copyfd_size(int fd1, int fd2, off_t size) FAST_FUNC; +extern void bb_copyfd_exact_size(int fd1, int fd2, off_t size) FAST_FUNC; +/* "short" copy can be detected by return value < size */ +/* this helper yells "short read!" if param is not -1 */ +extern void complain_copyfd_and_die(off_t sz) NORETURN FAST_FUNC; +extern char bb_process_escape_sequence(const char **ptr) FAST_FUNC; +/* xxxx_strip version can modify its parameter: + * "/" -> "/" + * "abc" -> "abc" + * "abc/def" -> "def" + * "abc/def/" -> "def" !! + */ +extern char *bb_get_last_path_component_strip(char *path) FAST_FUNC; +/* "abc/def/" -> "" and it never modifies 'path' */ +extern char *bb_get_last_path_component_nostrip(const char *path) FAST_FUNC; + +int ndelay_on(int fd) FAST_FUNC; +int ndelay_off(int fd) FAST_FUNC; +int close_on_exec_on(int fd) FAST_FUNC; +void xdup2(int, int) FAST_FUNC; +void xmove_fd(int, int) FAST_FUNC; + + +DIR *xopendir(const char *path) FAST_FUNC; +DIR *warn_opendir(const char *path) FAST_FUNC; + +/* UNUSED: char *xmalloc_realpath(const char *path) FAST_FUNC; */ +char *xmalloc_readlink(const char *path) FAST_FUNC; +char *xmalloc_readlink_or_warn(const char *path) FAST_FUNC; +char *xrealloc_getcwd_or_warn(char *cwd) FAST_FUNC; + +char *xmalloc_follow_symlinks(const char *path) FAST_FUNC; + + +enum { + /* bb_signals(BB_FATAL_SIGS, handler) catches all signals which + * otherwise would kill us, except for those resulting from bugs: + * SIGSEGV, SIGILL, SIGFPE. + * Other fatal signals not included (TODO?): + * SIGBUS Bus error (bad memory access) + * SIGPOLL Pollable event. Synonym of SIGIO + * SIGPROF Profiling timer expired + * SIGSYS Bad argument to routine + * SIGTRAP Trace/breakpoint trap + * + * The only known arch with some of these sigs not fitting + * into 32 bits is parisc (SIGXCPU=33, SIGXFSZ=34, SIGSTKFLT=36). + * Dance around with long long to guard against that... + */ + BB_FATAL_SIGS = (int)(0 + + (1LL << SIGHUP) + + (1LL << SIGINT) + + (1LL << SIGTERM) + + (1LL << SIGPIPE) // Write to pipe with no readers + + (1LL << SIGQUIT) // Quit from keyboard + + (1LL << SIGABRT) // Abort signal from abort(3) + + (1LL << SIGALRM) // Timer signal from alarm(2) + + (1LL << SIGVTALRM) // Virtual alarm clock + + (1LL << SIGXCPU) // CPU time limit exceeded + + (1LL << SIGXFSZ) // File size limit exceeded + + (1LL << SIGUSR1) // Yes kids, these are also fatal! + + (1LL << SIGUSR2) + + 0), +}; +void bb_signals(int sigs, void (*f)(int)) FAST_FUNC; +/* Unlike signal() and bb_signals, sets handler with sigaction() + * and in a way that while signal handler is run, no other signals + * will be blocked: */ +void bb_signals_recursive(int sigs, void (*f)(int)) FAST_FUNC; +/* syscalls like read() will be interrupted with EINTR: */ +void signal_no_SA_RESTART_empty_mask(int sig, void (*handler)(int)) FAST_FUNC; +/* syscalls like read() won't be interrupted (though select/poll will be): */ +void signal_SA_RESTART_empty_mask(int sig, void (*handler)(int)) FAST_FUNC; +void wait_for_any_sig(void) FAST_FUNC; +void kill_myself_with_sig(int sig) NORETURN FAST_FUNC; +void sig_block(int sig) FAST_FUNC; +void sig_unblock(int sig) FAST_FUNC; +/* Will do sigaction(signum, act, NULL): */ +int sigaction_set(int sig, const struct sigaction *act) FAST_FUNC; +/* SIG_BLOCK/SIG_UNBLOCK all signals: */ +int sigprocmask_allsigs(int how) FAST_FUNC; +/* Standard handler which just records signo */ +extern smallint bb_got_signal; +void record_signo(int signo); /* not FAST_FUNC! */ + + +void xsetgid(gid_t gid) FAST_FUNC; +void xsetuid(uid_t uid) FAST_FUNC; +void xchdir(const char *path) FAST_FUNC; +void xchroot(const char *path) FAST_FUNC; +void xsetenv(const char *key, const char *value) FAST_FUNC; +void xunlink(const char *pathname) FAST_FUNC; +void xstat(const char *pathname, struct stat *buf) FAST_FUNC; +int xopen(const char *pathname, int flags) FAST_FUNC FAST_FUNC; +int xopen3(const char *pathname, int flags, int mode) FAST_FUNC; +int open_or_warn(const char *pathname, int flags) FAST_FUNC; +int open3_or_warn(const char *pathname, int flags, int mode) FAST_FUNC; +int open_or_warn_stdin(const char *pathname) FAST_FUNC; +void xrename(const char *oldpath, const char *newpath) FAST_FUNC; +int rename_or_warn(const char *oldpath, const char *newpath) FAST_FUNC; +off_t xlseek(int fd, off_t offset, int whence) FAST_FUNC; +off_t fdlength(int fd) FAST_FUNC; + +void xpipe(int filedes[2]) FAST_FUNC; +/* In this form code with pipes is much more readable */ +struct fd_pair { int rd; int wr; }; +#define piped_pair(pair) pipe(&((pair).rd)) +#define xpiped_pair(pair) xpipe(&((pair).rd)) + +/* Useful for having small structure members/global variables */ +typedef int8_t socktype_t; +typedef int8_t family_t; +struct BUG_too_small { + char BUG_socktype_t_too_small[(0 + | SOCK_STREAM + | SOCK_DGRAM + | SOCK_RDM + | SOCK_SEQPACKET + | SOCK_RAW + ) <= 127 ? 1 : -1]; + char BUG_family_t_too_small[(0 + | AF_UNSPEC + | AF_INET + | AF_INET6 + | AF_UNIX +#ifdef AF_PACKET + | AF_PACKET +#endif +#ifdef AF_NETLINK + | AF_NETLINK +#endif + /* | AF_DECnet */ + /* | AF_IPX */ + ) <= 127 ? 1 : -1]; +}; + + +int xsocket(int domain, int type, int protocol) FAST_FUNC; +void xbind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen) FAST_FUNC; +void xlisten(int s, int backlog) FAST_FUNC; +void xconnect(int s, const struct sockaddr *s_addr, socklen_t addrlen) FAST_FUNC; +ssize_t xsendto(int s, const void *buf, size_t len, const struct sockaddr *to, + socklen_t tolen) FAST_FUNC; +/* SO_REUSEADDR allows a server to rebind to an address that is already + * "in use" by old connections to e.g. previous server instance which is + * killed or crashed. Without it bind will fail until all such connections + * time out. Linux does not allow multiple live binds on same ip:port + * regardless of SO_REUSEADDR (unlike some other flavors of Unix). + * Turn it on before you call bind(). */ +void setsockopt_reuseaddr(int fd) FAST_FUNC; /* On Linux this never fails. */ +int setsockopt_broadcast(int fd) FAST_FUNC; +int setsockopt_bindtodevice(int fd, const char *iface) FAST_FUNC; +/* NB: returns port in host byte order */ +unsigned bb_lookup_port(const char *port, const char *protocol, unsigned default_port) FAST_FUNC; +typedef struct len_and_sockaddr { + socklen_t len; + union { + struct sockaddr sa; + struct sockaddr_in sin; +#if ENABLE_FEATURE_IPV6 + struct sockaddr_in6 sin6; +#endif + } u; +} len_and_sockaddr; +enum { + LSA_LEN_SIZE = offsetof(len_and_sockaddr, u), + LSA_SIZEOF_SA = sizeof( + union { + struct sockaddr sa; + struct sockaddr_in sin; +#if ENABLE_FEATURE_IPV6 + struct sockaddr_in6 sin6; +#endif + } + ) +}; +/* Create stream socket, and allocate suitable lsa. + * (lsa of correct size and lsa->sa.sa_family (AF_INET/AF_INET6)) + * af == AF_UNSPEC will result in trying to create IPv6 socket, + * and if kernel doesn't support it, IPv4. + */ +#if ENABLE_FEATURE_IPV6 +int xsocket_type(len_and_sockaddr **lsap, int af, int sock_type) FAST_FUNC; +#else +int xsocket_type(len_and_sockaddr **lsap, int sock_type) FAST_FUNC; +#define xsocket_type(lsap, af, sock_type) xsocket_type((lsap), (sock_type)) +#endif +int xsocket_stream(len_and_sockaddr **lsap) FAST_FUNC; +/* Create server socket bound to bindaddr:port. bindaddr can be NULL, + * numeric IP ("N.N.N.N") or numeric IPv6 address, + * and can have ":PORT" suffix (for IPv6 use "[X:X:...:X]:PORT"). + * Only if there is no suffix, port argument is used */ +/* NB: these set SO_REUSEADDR before bind */ +int create_and_bind_stream_or_die(const char *bindaddr, int port) FAST_FUNC; +int create_and_bind_dgram_or_die(const char *bindaddr, int port) FAST_FUNC; +/* Create client TCP socket connected to peer:port. Peer cannot be NULL. + * Peer can be numeric IP ("N.N.N.N"), numeric IPv6 address or hostname, + * and can have ":PORT" suffix (for IPv6 use "[X:X:...:X]:PORT"). + * If there is no suffix, port argument is used */ +int create_and_connect_stream_or_die(const char *peer, int port) FAST_FUNC; +/* Connect to peer identified by lsa */ +int xconnect_stream(const len_and_sockaddr *lsa) FAST_FUNC; +/* Return malloc'ed len_and_sockaddr with socket address of host:port + * Currently will return IPv4 or IPv6 sockaddrs only + * (depending on host), but in theory nothing prevents e.g. + * UNIX socket address being returned, IPX sockaddr etc... + * On error does bb_error_msg and returns NULL */ +len_and_sockaddr* host2sockaddr(const char *host, int port) FAST_FUNC; +/* Version which dies on error */ +len_and_sockaddr* xhost2sockaddr(const char *host, int port) FAST_FUNC; +len_and_sockaddr* xdotted2sockaddr(const char *host, int port) FAST_FUNC; +/* Same, useful if you want to force family (e.g. IPv6) */ +#if !ENABLE_FEATURE_IPV6 +#define host_and_af2sockaddr(host, port, af) host2sockaddr((host), (port)) +#define xhost_and_af2sockaddr(host, port, af) xhost2sockaddr((host), (port)) +#else +len_and_sockaddr* host_and_af2sockaddr(const char *host, int port, sa_family_t af) FAST_FUNC; +len_and_sockaddr* xhost_and_af2sockaddr(const char *host, int port, sa_family_t af) FAST_FUNC; +#endif +/* Assign sin[6]_port member if the socket is an AF_INET[6] one, + * otherwise no-op. Useful for ftp. + * NB: does NOT do htons() internally, just direct assignment. */ +void set_nport(len_and_sockaddr *lsa, unsigned port) FAST_FUNC; +/* Retrieve sin[6]_port or return -1 for non-INET[6] lsa's */ +int get_nport(const struct sockaddr *sa) FAST_FUNC; +/* Reverse DNS. Returns NULL on failure. */ +char* xmalloc_sockaddr2host(const struct sockaddr *sa) FAST_FUNC; +/* This one doesn't append :PORTNUM */ +char* xmalloc_sockaddr2host_noport(const struct sockaddr *sa) FAST_FUNC; +/* This one also doesn't fall back to dotted IP (returns NULL) */ +char* xmalloc_sockaddr2hostonly_noport(const struct sockaddr *sa) FAST_FUNC; +/* inet_[ap]ton on steroids */ +char* xmalloc_sockaddr2dotted(const struct sockaddr *sa) FAST_FUNC; +char* xmalloc_sockaddr2dotted_noport(const struct sockaddr *sa) FAST_FUNC; +// "old" (ipv4 only) API +// users: traceroute.c hostname.c - use _list_ of all IPs +struct hostent *xgethostbyname(const char *name) FAST_FUNC; +// Also mount.c and inetd.c are using gethostbyname(), +// + inet_common.c has additional IPv4-only stuff + + +void socket_want_pktinfo(int fd) FAST_FUNC; +ssize_t send_to_from(int fd, void *buf, size_t len, int flags, + const struct sockaddr *to, + const struct sockaddr *from, + socklen_t tolen) FAST_FUNC; +ssize_t recv_from_to(int fd, void *buf, size_t len, int flags, + struct sockaddr *from, + struct sockaddr *to, + socklen_t sa_size) FAST_FUNC; + +char *xstrdup(const char *s) FAST_FUNC; +char *xstrndup(const char *s, int n) FAST_FUNC; +void overlapping_strcpy(char *dst, const char *src) FAST_FUNC; +char *safe_strncpy(char *dst, const char *src, size_t size) FAST_FUNC; +/* Guaranteed to NOT be a macro (smallest code). Saves nearly 2k on uclibc. + * But potentially slow, don't use in one-billion-times loops */ +int bb_putchar(int ch) FAST_FUNC; +char *xasprintf(const char *format, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC; +/* Prints unprintable chars ch as ^C or M-c to file + * (M-c is used only if ch is ORed with PRINTABLE_META), + * else it is printed as-is (except for ch = 0x9b) */ +enum { PRINTABLE_META = 0x100 }; +void fputc_printable(int ch, FILE *file) FAST_FUNC; +// gcc-4.1.1 still isn't good enough at optimizing it +// (+200 bytes compared to macro) +//static ALWAYS_INLINE +//int LONE_DASH(const char *s) { return s[0] == '-' && !s[1]; } +//static ALWAYS_INLINE +//int NOT_LONE_DASH(const char *s) { return s[0] != '-' || s[1]; } +#define LONE_DASH(s) ((s)[0] == '-' && !(s)[1]) +#define NOT_LONE_DASH(s) ((s)[0] != '-' || (s)[1]) +#define LONE_CHAR(s,c) ((s)[0] == (c) && !(s)[1]) +#define NOT_LONE_CHAR(s,c) ((s)[0] != (c) || (s)[1]) +#define DOT_OR_DOTDOT(s) ((s)[0] == '.' && (!(s)[1] || ((s)[1] == '.' && !(s)[2]))) + +/* dmalloc will redefine these to it's own implementation. It is safe + * to have the prototypes here unconditionally. */ +void *malloc_or_warn(size_t size) FAST_FUNC; +void *xmalloc(size_t size) FAST_FUNC; +void *xzalloc(size_t size) FAST_FUNC; +void *xrealloc(void *old, size_t size) FAST_FUNC; +/* After xrealloc_vector(v, 4, idx) it's ok to use + * at least v[idx] and v[idx+1], for all idx values. + * shift specifies how many new elements are added (1: 2, 2: 4... 8: 256...) + * when all elements are used up. New elements are zeroed out. */ +#define xrealloc_vector(vector, shift, idx) \ + xrealloc_vector_helper((vector), (sizeof((vector)[0]) << 8) + (shift), (idx)) +void* xrealloc_vector_helper(void *vector, unsigned sizeof_and_shift, int idx) FAST_FUNC; + + +extern ssize_t safe_read(int fd, void *buf, size_t count) FAST_FUNC; +extern ssize_t nonblock_safe_read(int fd, void *buf, size_t count) FAST_FUNC; +// NB: will return short read on error, not -1, +// if some data was read before error occurred +extern ssize_t full_read(int fd, void *buf, size_t count) FAST_FUNC; +extern void xread(int fd, void *buf, size_t count) FAST_FUNC; +extern unsigned char xread_char(int fd) FAST_FUNC; +extern ssize_t read_close(int fd, void *buf, size_t maxsz) FAST_FUNC; +extern ssize_t open_read_close(const char *filename, void *buf, size_t maxsz) FAST_FUNC; +// Reads one line a-la fgets (but doesn't save terminating '\n'). +// Reads byte-by-byte. Useful when it is important to not read ahead. +// Bytes are appended to pfx (which must be malloced, or NULL). +extern char *xmalloc_reads(int fd, char *pfx, size_t *maxsz_p) FAST_FUNC; +/* Reads block up to *maxsz_p (default: MAX_INT(ssize_t)) */ +extern void *xmalloc_read(int fd, size_t *maxsz_p) FAST_FUNC; +/* Returns NULL if file can't be opened */ +extern void *xmalloc_open_read_close(const char *filename, size_t *maxsz_p) FAST_FUNC; +/* Autodetects .gz etc */ +extern int open_zipped(const char *fname) FAST_FUNC; +extern void *xmalloc_open_zipped_read_close(const char *fname, size_t *maxsz_p) FAST_FUNC; +/* Never returns NULL */ +extern void *xmalloc_xopen_read_close(const char *filename, size_t *maxsz_p) FAST_FUNC; + +extern ssize_t safe_write(int fd, const void *buf, size_t count) FAST_FUNC; +// NB: will return short write on error, not -1, +// if some data was written before error occurred +extern ssize_t full_write(int fd, const void *buf, size_t count) FAST_FUNC; +extern void xwrite(int fd, const void *buf, size_t count) FAST_FUNC; +extern void xopen_xwrite_close(const char* file, const char *str) FAST_FUNC; + +/* Reads and prints to stdout till eof, then closes FILE. Exits on error: */ +extern void xprint_and_close_file(FILE *file) FAST_FUNC; + +extern char *bb_get_chunk_from_file(FILE *file, int *end) FAST_FUNC; +extern char *bb_get_chunk_with_continuation(FILE *file, int *end, int *lineno) FAST_FUNC; +/* Reads up to (and including) TERMINATING_STRING: */ +extern char *xmalloc_fgets_str(FILE *file, const char *terminating_string) FAST_FUNC; +/* Chops off TERMINATING_STRING from the end: */ +extern char *xmalloc_fgetline_str(FILE *file, const char *terminating_string) FAST_FUNC; +/* Reads up to (and including) "\n" or NUL byte: */ +extern char *xmalloc_fgets(FILE *file) FAST_FUNC; +/* Chops off '\n' from the end, unlike fgets: */ +extern char *xmalloc_fgetline(FILE *file) FAST_FUNC; +/* Same, but doesn't try to conserve space (may have some slack after the end) */ +/* extern char *xmalloc_fgetline_fast(FILE *file) FAST_FUNC; */ + +extern void die_if_ferror(FILE *file, const char *msg) FAST_FUNC; +extern void die_if_ferror_stdout(void) FAST_FUNC; +extern void xfflush_stdout(void) FAST_FUNC; +extern void fflush_stdout_and_exit(int retval) NORETURN FAST_FUNC; +extern int fclose_if_not_stdin(FILE *file) FAST_FUNC; +extern FILE *xfopen(const char *filename, const char *mode) FAST_FUNC; +/* Prints warning to stderr and returns NULL on failure: */ +extern FILE *fopen_or_warn(const char *filename, const char *mode) FAST_FUNC; +/* "Opens" stdin if filename is special, else just opens file: */ +extern FILE *xfopen_stdin(const char *filename) FAST_FUNC; +extern FILE *fopen_or_warn_stdin(const char *filename) FAST_FUNC; +extern FILE* fopen_for_read(const char *path) FAST_FUNC; +extern FILE* xfopen_for_read(const char *path) FAST_FUNC; +extern FILE* fopen_for_write(const char *path) FAST_FUNC; +extern FILE* xfopen_for_write(const char *path) FAST_FUNC; + +int bb_pstrcmp(const void *a, const void *b) /* not FAST_FUNC! */; +void qsort_string_vector(char **sv, unsigned count) FAST_FUNC; + +/* Wrapper which restarts poll on EINTR or ENOMEM. + * On other errors complains [perror("poll")] and returns. + * Warning! May take (much) longer than timeout_ms to return! + * If this is a problem, use bare poll and open-code EINTR/ENOMEM handling */ +int safe_poll(struct pollfd *ufds, nfds_t nfds, int timeout_ms) FAST_FUNC; + +char *safe_gethostname(void) FAST_FUNC; +char *safe_getdomainname(void) FAST_FUNC; + +/* Convert each alpha char in str to lower-case */ +char* str_tolower(char *str) FAST_FUNC; + +char *utoa(unsigned n) FAST_FUNC; +char *itoa(int n) FAST_FUNC; +/* Returns a pointer past the formatted number, does NOT null-terminate */ +char *utoa_to_buf(unsigned n, char *buf, unsigned buflen) FAST_FUNC; +char *itoa_to_buf(int n, char *buf, unsigned buflen) FAST_FUNC; +/* Intelligent formatters of bignums */ +void smart_ulltoa4(unsigned long long ul, char buf[5], const char *scale) FAST_FUNC; +void smart_ulltoa5(unsigned long long ul, char buf[5], const char *scale) FAST_FUNC; +//TODO: provide pointer to buf (avoid statics)? +const char *make_human_readable_str(unsigned long long size, + unsigned long block_size, unsigned long display_unit) FAST_FUNC; +/* Put a string of hex bytes ("1b2e66fe"...), return advanced pointer */ +char *bin2hex(char *buf, const char *cp, int count) FAST_FUNC; + +/* Last element is marked by mult == 0 */ +struct suffix_mult { + char suffix[4]; + unsigned mult; +}; +#include "xatonum.h" +/* Specialized: */ +/* Using xatoi() instead of naive atoi() is not always convenient - + * in many places people want *non-negative* values, but store them + * in signed int. Therefore we need this one: + * dies if input is not in [0, INT_MAX] range. Also will reject '-0' etc */ +int xatoi_u(const char *numstr) FAST_FUNC; +/* Useful for reading port numbers */ +uint16_t xatou16(const char *numstr) FAST_FUNC; + + +/* These parse entries in /etc/passwd and /etc/group. This is desirable + * for BusyBox since we want to avoid using the glibc NSS stuff, which + * increases target size and is often not needed on embedded systems. */ +long xuname2uid(const char *name) FAST_FUNC; +long xgroup2gid(const char *name) FAST_FUNC; +/* wrapper: allows string to contain numeric uid or gid */ +unsigned long get_ug_id(const char *s, long FAST_FUNC (*xname2id)(const char *)) FAST_FUNC; +/* from chpst. Does not die, returns 0 on failure */ +struct bb_uidgid_t { + uid_t uid; + gid_t gid; +}; +/* always sets uid and gid */ +int get_uidgid(struct bb_uidgid_t*, const char*, int numeric_ok) FAST_FUNC; +/* always sets uid and gid, allows numeric; exits on failure */ +void xget_uidgid(struct bb_uidgid_t*, const char*) FAST_FUNC; +/* chown-like handling of "user[:[group]" */ +void parse_chown_usergroup_or_die(struct bb_uidgid_t *u, char *user_group) FAST_FUNC; +/* bb_getpwuid, bb_getgrgid: + * bb_getXXXid(buf, bufsz, id) - copy user/group name or id + * as a string to buf, return user/group name or NULL + * bb_getXXXid(NULL, 0, id) - return user/group name or NULL + * bb_getXXXid(NULL, -1, id) - return user/group name or exit +*/ +char *bb_getpwuid(char *name, int bufsize, long uid) FAST_FUNC; +char *bb_getgrgid(char *group, int bufsize, long gid) FAST_FUNC; +/* versions which cache results (useful for ps, ls etc) */ +const char* get_cached_username(uid_t uid) FAST_FUNC; +const char* get_cached_groupname(gid_t gid) FAST_FUNC; +void clear_username_cache(void) FAST_FUNC; +/* internally usernames are saved in fixed-sized char[] buffers */ +enum { USERNAME_MAX_SIZE = 16 - sizeof(int) }; +#if ENABLE_FEATURE_CHECK_NAMES +void die_if_bad_username(const char* name) FAST_FUNC; +#else +#define die_if_bad_username(name) ((void)(name)) +#endif + +int execable_file(const char *name) FAST_FUNC; +char *find_execable(const char *filename, char **PATHp) FAST_FUNC; +int exists_execable(const char *filename) FAST_FUNC; + +/* BB_EXECxx always execs (it's not doing NOFORK/NOEXEC stuff), + * but it may exec busybox and call applet instead of searching PATH. + */ +#if ENABLE_FEATURE_PREFER_APPLETS +int bb_execvp(const char *file, char *const argv[]) FAST_FUNC; +#define BB_EXECVP(prog,cmd) bb_execvp(prog,cmd) +#define BB_EXECLP(prog,cmd,...) \ + execlp((find_applet_by_name(prog) >= 0) ? CONFIG_BUSYBOX_EXEC_PATH : prog, \ + cmd, __VA_ARGS__) +#else +#define BB_EXECVP(prog,cmd) execvp(prog,cmd) +#define BB_EXECLP(prog,cmd,...) execlp(prog,cmd, __VA_ARGS__) +#endif + +/* NOMMU friendy fork+exec */ +pid_t spawn(char **argv) FAST_FUNC; +pid_t xspawn(char **argv) FAST_FUNC; + +pid_t safe_waitpid(pid_t pid, int *wstat, int options) FAST_FUNC; +/* Unlike waitpid, waits ONLY for one process. + * It's safe to pass negative 'pids' from failed [v]fork - + * wait4pid will return -1 (and will not clobber [v]fork's errno). + * IOW: rc = wait4pid(spawn(argv)); + * if (rc < 0) bb_perror_msg("%s", argv[0]); + * if (rc > 0) bb_error_msg("exit code: %d", rc); + */ +int wait4pid(pid_t pid) FAST_FUNC; +pid_t wait_any_nohang(int *wstat) FAST_FUNC; +#define wait_crashed(w) ((w) & 127) +#define wait_exitcode(w) ((w) >> 8) +#define wait_stopsig(w) ((w) >> 8) +#define wait_stopped(w) (((w) & 127) == 127) +/* wait4pid(spawn(argv)) + NOFORK/NOEXEC (if configured) */ +pid_t spawn_and_wait(char **argv) FAST_FUNC; +struct nofork_save_area { + jmp_buf die_jmp; + const char *applet_name; + int xfunc_error_retval; + uint32_t option_mask32; + int die_sleep; + smallint saved; +}; +void save_nofork_data(struct nofork_save_area *save) FAST_FUNC; +void restore_nofork_data(struct nofork_save_area *save) FAST_FUNC; +/* Does NOT check that applet is NOFORK, just blindly runs it */ +int run_nofork_applet(int applet_no, char **argv) FAST_FUNC; +int run_nofork_applet_prime(struct nofork_save_area *old, int applet_no, char **argv) FAST_FUNC; + +/* Helpers for daemonization. + * + * bb_daemonize(flags) = daemonize, does not compile on NOMMU + * + * bb_daemonize_or_rexec(flags, argv) = daemonizes on MMU (and ignores argv), + * rexec's itself on NOMMU with argv passed as command line. + * Thus bb_daemonize_or_rexec may cause your <applet>_main() to be re-executed + * from the start. (It will detect it and not reexec again second time). + * You have to audit carefully that you don't do something twice as a result + * (opening files/sockets, parsing config files etc...)! + * + * Both of the above will redirect fd 0,1,2 to /dev/null and drop ctty + * (will do setsid()). + * + * forkexit_or_rexec(argv) = bare-bones "fork + parent exits" on MMU, + * "vfork + re-exec ourself" on NOMMU. No fd redirection, no setsid(). + * Currently used for setsid only. On MMU ignores argv. + * + * Helper for network daemons in foreground mode: + * + * bb_sanitize_stdio() = make sure that fd 0,1,2 are opened by opening them + * to /dev/null if they are not. + */ +enum { + DAEMON_CHDIR_ROOT = 1, + DAEMON_DEVNULL_STDIO = 2, + DAEMON_CLOSE_EXTRA_FDS = 4, + DAEMON_ONLY_SANITIZE = 8, /* internal use */ +}; +#if BB_MMU + void forkexit_or_rexec(void) FAST_FUNC; + enum { re_execed = 0 }; +# define forkexit_or_rexec(argv) forkexit_or_rexec() +# define bb_daemonize_or_rexec(flags, argv) bb_daemonize_or_rexec(flags) +# define bb_daemonize(flags) bb_daemonize_or_rexec(flags, bogus) +#else + void re_exec(char **argv) NORETURN FAST_FUNC; + void forkexit_or_rexec(char **argv) FAST_FUNC; + extern bool re_execed; + int BUG_fork_is_unavailable_on_nommu(void) FAST_FUNC; + int BUG_daemon_is_unavailable_on_nommu(void) FAST_FUNC; + void BUG_bb_daemonize_is_unavailable_on_nommu(void) FAST_FUNC; +# define fork() BUG_fork_is_unavailable_on_nommu() +# define daemon(a,b) BUG_daemon_is_unavailable_on_nommu() +# define bb_daemonize(a) BUG_bb_daemonize_is_unavailable_on_nommu() +#endif +void bb_daemonize_or_rexec(int flags, char **argv) FAST_FUNC; +void bb_sanitize_stdio(void) FAST_FUNC; +/* Clear dangerous stuff, set PATH. Return 1 if was run by different user. */ +int sanitize_env_if_suid(void) FAST_FUNC; + + +extern const char *const bb_argv_dash[]; /* "-", NULL */ +extern const char *opt_complementary; +#if ENABLE_GETOPT_LONG +#define No_argument "\0" +#define Required_argument "\001" +#define Optional_argument "\002" +extern const char *applet_long_options; +#endif +extern uint32_t option_mask32; +extern uint32_t getopt32(char **argv, const char *applet_opts, ...) FAST_FUNC; + + +typedef struct llist_t { + char *data; + struct llist_t *link; +} llist_t; +void llist_add_to(llist_t **old_head, void *data) FAST_FUNC; +void llist_add_to_end(llist_t **list_head, void *data) FAST_FUNC; +void *llist_pop(llist_t **elm) FAST_FUNC; +void llist_unlink(llist_t **head, llist_t *elm) FAST_FUNC; +void llist_free(llist_t *elm, void (*freeit)(void *data)) FAST_FUNC; +llist_t *llist_rev(llist_t *list) FAST_FUNC; +/* BTW, surprisingly, changing API to + * llist_t *llist_add_to(llist_t *old_head, void *data) + * etc does not result in smaller code... */ + +/* start_stop_daemon and udhcpc are special - they want + * to create pidfiles regardless of FEATURE_PIDFILE */ +#if ENABLE_FEATURE_PIDFILE || defined(WANT_PIDFILE) +/* True only if we created pidfile which is *file*, not /dev/null etc */ +extern smallint wrote_pidfile; +void write_pidfile(const char *path) FAST_FUNC; +#define remove_pidfile(path) do { if (wrote_pidfile) unlink(path); } while (0) +#else +enum { wrote_pidfile = 0 }; +#define write_pidfile(path) ((void)0) +#define remove_pidfile(path) ((void)0) +#endif + +enum { + LOGMODE_NONE = 0, + LOGMODE_STDIO = (1 << 0), + LOGMODE_SYSLOG = (1 << 1) * ENABLE_FEATURE_SYSLOG, + LOGMODE_BOTH = LOGMODE_SYSLOG + LOGMODE_STDIO, +}; +extern const char *msg_eol; +extern smallint logmode; +extern int die_sleep; +extern int xfunc_error_retval; +extern jmp_buf die_jmp; +extern void xfunc_die(void) NORETURN FAST_FUNC; +extern void bb_show_usage(void) NORETURN FAST_FUNC; +extern void bb_error_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC; +extern void bb_error_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))) FAST_FUNC; +extern void bb_perror_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC; +extern void bb_simple_perror_msg(const char *s) FAST_FUNC; +extern void bb_perror_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))) FAST_FUNC; +extern void bb_simple_perror_msg_and_die(const char *s) __attribute__ ((noreturn)) FAST_FUNC; +extern void bb_herror_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC; +extern void bb_herror_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))) FAST_FUNC; +extern void bb_perror_nomsg_and_die(void) NORETURN FAST_FUNC; +extern void bb_perror_nomsg(void) FAST_FUNC; +extern void bb_info_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC; +extern void bb_verror_msg(const char *s, va_list p, const char *strerr) FAST_FUNC; + +/* We need to export XXX_main from libbusybox + * only if we build "individual" binaries + */ +#if ENABLE_FEATURE_INDIVIDUAL +#define MAIN_EXTERNALLY_VISIBLE EXTERNALLY_VISIBLE +#else +#define MAIN_EXTERNALLY_VISIBLE +#endif + + +/* Applets which are useful from another applets */ +int bb_cat(char** argv); +/* If shell needs them, they exist even if not enabled as applets */ +int echo_main(int argc, char** argv) USE_ECHO(MAIN_EXTERNALLY_VISIBLE); +int printf_main(int argc, char **argv) USE_PRINTF(MAIN_EXTERNALLY_VISIBLE); +int test_main(int argc, char **argv) USE_TEST(MAIN_EXTERNALLY_VISIBLE); +int kill_main(int argc, char **argv) USE_KILL(MAIN_EXTERNALLY_VISIBLE); +/* Similar, but used by chgrp, not shell */ +int chown_main(int argc, char **argv) USE_CHOWN(MAIN_EXTERNALLY_VISIBLE); +/* Don't need USE_xxx() guard for these */ +int gunzip_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int bunzip2_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; + +#if ENABLE_ROUTE +void bb_displayroutes(int noresolve, int netstatfmt) FAST_FUNC; +#endif + + +/* "Keycodes" that report an escape sequence. + * We use something which fits into signed char, + * yet doesn't represent any valid Unicode characher. + * Also, -1 is reserved for error indication and we don't use it. */ +enum { + KEYCODE_UP = -2, + KEYCODE_DOWN = -3, + KEYCODE_RIGHT = -4, + KEYCODE_LEFT = -5, + KEYCODE_HOME = -6, + KEYCODE_END = -7, + KEYCODE_INSERT = -8, + KEYCODE_DELETE = -9, + KEYCODE_PAGEUP = -10, + KEYCODE_PAGEDOWN = -11, +#if 0 + KEYCODE_FUN1 = -12, + KEYCODE_FUN2 = -13, + KEYCODE_FUN3 = -14, + KEYCODE_FUN4 = -15, + KEYCODE_FUN5 = -16, + KEYCODE_FUN6 = -17, + KEYCODE_FUN7 = -18, + KEYCODE_FUN8 = -19, + KEYCODE_FUN9 = -20, + KEYCODE_FUN10 = -21, + KEYCODE_FUN11 = -22, + KEYCODE_FUN12 = -23, +#endif + /* How long the longest ESC sequence we know? */ + KEYCODE_BUFFER_SIZE = 4 +}; +int read_key(int fd, smalluint *nbuffered, char *buffer) FAST_FUNC; + + +/* Networking */ +int create_icmp_socket(void) FAST_FUNC; +int create_icmp6_socket(void) FAST_FUNC; +/* interface.c */ +/* This structure defines protocol families and their handlers. */ +struct aftype { + const char *name; + const char *title; + int af; + int alen; + char* FAST_FUNC (*print)(unsigned char *); + const char* FAST_FUNC (*sprint)(struct sockaddr *, int numeric); + int FAST_FUNC (*input)(/*int type,*/ const char *bufp, struct sockaddr *); + void FAST_FUNC (*herror)(char *text); + int FAST_FUNC (*rprint)(int options); + int FAST_FUNC (*rinput)(int typ, int ext, char **argv); + /* may modify src */ + int FAST_FUNC (*getmask)(char *src, struct sockaddr *mask, char *name); +}; +/* This structure defines hardware protocols and their handlers. */ +struct hwtype { + const char *name; + const char *title; + int type; + int alen; + char* FAST_FUNC (*print)(unsigned char *); + int FAST_FUNC (*input)(const char *, struct sockaddr *); + int FAST_FUNC (*activate)(int fd); + int suppress_null_addr; +}; +extern smallint interface_opt_a; +int display_interfaces(char *ifname) FAST_FUNC; +#if ENABLE_FEATURE_HWIB +int in_ib(const char *bufp, struct sockaddr *sap) FAST_FUNC; +#else +#define in_ib(a, b) 1 /* fail */ +#endif +const struct aftype *get_aftype(const char *name) FAST_FUNC; +const struct hwtype *get_hwtype(const char *name) FAST_FUNC; +const struct hwtype *get_hwntype(int type) FAST_FUNC; + + +#ifndef BUILD_INDIVIDUAL +extern int find_applet_by_name(const char *name) FAST_FUNC; +/* Returns only if applet is not found. */ +extern void run_applet_and_exit(const char *name, char **argv) FAST_FUNC; +extern void run_applet_no_and_exit(int a, char **argv) NORETURN FAST_FUNC; +#endif + +#ifdef HAVE_MNTENT_H +extern int match_fstype(const struct mntent *mt, const char *fstypes) FAST_FUNC; +extern struct mntent *find_mount_point(const char *name, const char *table) FAST_FUNC; +#endif +extern void erase_mtab(const char * name) FAST_FUNC; +extern unsigned int tty_baud_to_value(speed_t speed) FAST_FUNC; +extern speed_t tty_value_to_baud(unsigned int value) FAST_FUNC; +extern void bb_warn_ignoring_args(int n) FAST_FUNC; + +extern int get_linux_version_code(void) FAST_FUNC; + +extern char *query_loop(const char *device) FAST_FUNC; +extern int del_loop(const char *device) FAST_FUNC; +/* If *devname is not NULL, use that name, otherwise try to find free one, + * malloc and return it in *devname. + * return value: 1: read-only loopdev was setup, 0: rw, < 0: error */ +extern int set_loop(char **devname, const char *file, unsigned long long offset) FAST_FUNC; + + +//TODO: pass buf pointer or return allocated buf (avoid statics)? +char *bb_askpass(int timeout, const char * prompt) FAST_FUNC; +int bb_ask_confirmation(void) FAST_FUNC; + +int bb_parse_mode(const char* s, mode_t* theMode) FAST_FUNC; + +/* + * Config file parser + */ +enum { + PARSE_COLLAPSE = 0x00010000, // treat consecutive delimiters as one + PARSE_TRIM = 0x00020000, // trim leading and trailing delimiters +// TODO: COLLAPSE and TRIM seem to always go in pair + PARSE_GREEDY = 0x00040000, // last token takes entire remainder of the line + PARSE_MIN_DIE = 0x00100000, // die if < min tokens found + // keep a copy of current line + PARSE_KEEP_COPY = 0x00200000 * ENABLE_FEATURE_CROND_D, +// PARSE_ESCAPE = 0x00400000, // process escape sequences in tokens + // NORMAL is: + // * remove leading and trailing delimiters and collapse + // multiple delimiters into one + // * warn and continue if less than mintokens delimiters found + // * grab everything into last token + PARSE_NORMAL = PARSE_COLLAPSE | PARSE_TRIM | PARSE_GREEDY, +}; +typedef struct parser_t { + FILE *fp; + char *line; + char *data; + int lineno; +} parser_t; +parser_t* config_open(const char *filename) FAST_FUNC; +parser_t* config_open2(const char *filename, FILE* FAST_FUNC (*fopen_func)(const char *path)) FAST_FUNC; +int config_read(parser_t *parser, char **tokens, unsigned flags, const char *delims) FAST_FUNC; +#define config_read(parser, tokens, max, min, str, flags) \ + config_read(parser, tokens, ((flags) | (((min) & 0xFF) << 8) | ((max) & 0xFF)), str) +void config_close(parser_t *parser) FAST_FUNC; + +/* Concatenate path and filename to new allocated buffer. + * Add "/" only as needed (no duplicate "//" are produced). + * If path is NULL, it is assumed to be "/". + * filename should not be NULL. */ +char *concat_path_file(const char *path, const char *filename) FAST_FUNC; +char *concat_subpath_file(const char *path, const char *filename) FAST_FUNC; +const char *bb_basename(const char *name) FAST_FUNC; +/* NB: can violate const-ness (similarly to strchr) */ +char *last_char_is(const char *s, int c) FAST_FUNC; + + +int bb_make_directory(char *path, long mode, int flags) FAST_FUNC; + +int get_signum(const char *name) FAST_FUNC; +const char *get_signame(int number) FAST_FUNC; +void print_signames(void) FAST_FUNC; + +char *bb_simplify_path(const char *path) FAST_FUNC; + +#define FAIL_DELAY 3 +extern void bb_do_delay(int seconds) FAST_FUNC; +extern void change_identity(const struct passwd *pw) FAST_FUNC; +extern void run_shell(const char *shell, int loginshell, const char *command, const char **additional_args) NORETURN FAST_FUNC; +extern void run_shell(const char *shell, int loginshell, const char *command, const char **additional_args) FAST_FUNC; +#if ENABLE_SELINUX +extern void renew_current_security_context(void) FAST_FUNC; +extern void set_current_security_context(security_context_t sid) FAST_FUNC; +extern context_t set_security_context_component(security_context_t cur_context, + char *user, char *role, char *type, char *range) FAST_FUNC; +extern void setfscreatecon_or_die(security_context_t scontext) FAST_FUNC; +extern void selinux_preserve_fcontext(int fdesc) FAST_FUNC; +#else +#define selinux_preserve_fcontext(fdesc) ((void)0) +#endif +extern void selinux_or_die(void) FAST_FUNC; +extern int restricted_shell(const char *shell) FAST_FUNC; + +/* setup_environment: + * if clear_env = 1: cd(pw->pw_dir), clear environment, then set + * TERM=(old value) + * USER=pw->pw_name, LOGNAME=pw->pw_name + * PATH=bb_default_[root_]path + * HOME=pw->pw_dir + * SHELL=shell + * else if change_env = 1: + * if not root (if pw->pw_uid != 0): + * USER=pw->pw_name, LOGNAME=pw->pw_name + * HOME=pw->pw_dir + * SHELL=shell + * else does nothing + */ +extern void setup_environment(const char *shell, int clear_env, int change_env, const struct passwd *pw) FAST_FUNC; +extern int correct_password(const struct passwd *pw) FAST_FUNC; +/* Returns a malloced string */ +#if !ENABLE_USE_BB_CRYPT +#define pw_encrypt(clear, salt, cleanup) pw_encrypt(clear, salt) +#endif +extern char *pw_encrypt(const char *clear, const char *salt, int cleanup) FAST_FUNC; +extern int obscure(const char *old, const char *newval, const struct passwd *pwdp) FAST_FUNC; +/* rnd is additional random input. New one is returned. + * Useful if you call crypt_make_salt many times in a row: + * rnd = crypt_make_salt(buf1, 4, 0); + * rnd = crypt_make_salt(buf2, 4, rnd); + * rnd = crypt_make_salt(buf3, 4, rnd); + * (otherwise we risk having same salt generated) + */ +extern int crypt_make_salt(char *p, int cnt, int rnd) FAST_FUNC; +/* Returns number of lines changed, or -1 on error */ +extern int update_passwd(const char *filename, const char *username, + const char *new_pw) FAST_FUNC; + +int index_in_str_array(const char *const string_array[], const char *key) FAST_FUNC; +int index_in_strings(const char *strings, const char *key) FAST_FUNC; +int index_in_substr_array(const char *const string_array[], const char *key) FAST_FUNC; +int index_in_substrings(const char *strings, const char *key) FAST_FUNC; +const char *nth_string(const char *strings, int n) FAST_FUNC; + +extern void print_login_issue(const char *issue_file, const char *tty) FAST_FUNC; +extern void print_login_prompt(void) FAST_FUNC; + +/* NB: typically you want to pass fd 0, not 1. Think 'applet | grep something' */ +int get_terminal_width_height(int fd, unsigned *width, unsigned *height) FAST_FUNC; + +int tcsetattr_stdin_TCSANOW(const struct termios *tp) FAST_FUNC; + +/* NB: "unsigned request" is crucial! "int request" will break some arches! */ +int ioctl_or_perror(int fd, unsigned request, void *argp, const char *fmt,...) __attribute__ ((format (printf, 4, 5))) FAST_FUNC; +int ioctl_or_perror_and_die(int fd, unsigned request, void *argp, const char *fmt,...) __attribute__ ((format (printf, 4, 5))) FAST_FUNC; +#if ENABLE_IOCTL_HEX2STR_ERROR +int bb_ioctl_or_warn(int fd, unsigned request, void *argp, const char *ioctl_name) FAST_FUNC; +int bb_xioctl(int fd, unsigned request, void *argp, const char *ioctl_name) FAST_FUNC; +#define ioctl_or_warn(fd,request,argp) bb_ioctl_or_warn(fd,request,argp,#request) +#define xioctl(fd,request,argp) bb_xioctl(fd,request,argp,#request) +#else +int bb_ioctl_or_warn(int fd, unsigned request, void *argp) FAST_FUNC; +int bb_xioctl(int fd, unsigned request, void *argp) FAST_FUNC; +#define ioctl_or_warn(fd,request,argp) bb_ioctl_or_warn(fd,request,argp) +#define xioctl(fd,request,argp) bb_xioctl(fd,request,argp) +#endif + +char *is_in_ino_dev_hashtable(const struct stat *statbuf) FAST_FUNC; +void add_to_ino_dev_hashtable(const struct stat *statbuf, const char *name) FAST_FUNC; +void reset_ino_dev_hashtable(void) FAST_FUNC; +#ifdef __GLIBC__ +/* At least glibc has horrendously large inline for this, so wrap it */ +unsigned long long bb_makedev(unsigned int major, unsigned int minor) FAST_FUNC; +#undef makedev +#define makedev(a,b) bb_makedev(a,b) +#endif + + +#if ENABLE_FEATURE_EDITING +/* It's NOT just ENABLEd or disabled. It's a number: */ +#ifdef CONFIG_FEATURE_EDITING_HISTORY +#define MAX_HISTORY (CONFIG_FEATURE_EDITING_HISTORY + 0) +#else +#define MAX_HISTORY 0 +#endif +typedef struct line_input_t { + int flags; + const char *path_lookup; +#if MAX_HISTORY + int cnt_history; + int cur_history; + USE_FEATURE_EDITING_SAVEHISTORY(const char *hist_file;) + char *history[MAX_HISTORY + 1]; +#endif +} line_input_t; +enum { + DO_HISTORY = 1 * (MAX_HISTORY > 0), + SAVE_HISTORY = 2 * (MAX_HISTORY > 0) * ENABLE_FEATURE_EDITING_SAVEHISTORY, + TAB_COMPLETION = 4 * ENABLE_FEATURE_TAB_COMPLETION, + USERNAME_COMPLETION = 8 * ENABLE_FEATURE_USERNAME_COMPLETION, + VI_MODE = 0x10 * ENABLE_FEATURE_EDITING_VI, + WITH_PATH_LOOKUP = 0x20, + FOR_SHELL = DO_HISTORY | SAVE_HISTORY | TAB_COMPLETION | USERNAME_COMPLETION, +}; +line_input_t *new_line_input_t(int flags) FAST_FUNC; +/* Returns: + * -1 on read errors or EOF, or on bare Ctrl-D, + * 0 on ctrl-C (the line entered is still returned in 'command'), + * >0 length of input string, including terminating '\n' + */ +int read_line_input(const char* prompt, char* command, int maxsize, line_input_t *state) FAST_FUNC; +#else +int read_line_input(const char* prompt, char* command, int maxsize) FAST_FUNC; +#define read_line_input(prompt, command, maxsize, state) \ + read_line_input(prompt, command, maxsize) +#endif + + +#ifndef COMM_LEN +#ifdef TASK_COMM_LEN +enum { COMM_LEN = TASK_COMM_LEN }; +#else +/* synchronize with sizeof(task_struct.comm) in /usr/include/linux/sched.h */ +enum { COMM_LEN = 16 }; +#endif +#endif +typedef struct procps_status_t { + DIR *dir; + uint8_t shift_pages_to_bytes; + uint8_t shift_pages_to_kb; +/* Fields are set to 0/NULL if failed to determine (or not requested) */ + uint16_t argv_len; + char *argv0; + USE_SELINUX(char *context;) + /* Everything below must contain no ptrs to malloc'ed data: + * it is memset(0) for each process in procps_scan() */ + unsigned long vsz, rss; /* we round it to kbytes */ + unsigned long stime, utime; + unsigned long start_time; + unsigned pid; + unsigned ppid; + unsigned pgid; + unsigned sid; + unsigned uid; + unsigned gid; + unsigned tty_major,tty_minor; +#if ENABLE_FEATURE_TOPMEM + unsigned long mapped_rw; + unsigned long mapped_ro; + unsigned long shared_clean; + unsigned long shared_dirty; + unsigned long private_clean; + unsigned long private_dirty; + unsigned long stack; +#endif + char state[4]; + /* basename of executable in exec(2), read from /proc/N/stat + * (if executable is symlink or script, it is NOT replaced + * by link target or interpreter name) */ + char comm[COMM_LEN]; + /* user/group? - use passwd/group parsing functions */ +#if ENABLE_FEATURE_TOP_SMP_PROCESS + int last_seen_on_cpu; +#endif +} procps_status_t; +enum { + PSSCAN_PID = 1 << 0, + PSSCAN_PPID = 1 << 1, + PSSCAN_PGID = 1 << 2, + PSSCAN_SID = 1 << 3, + PSSCAN_UIDGID = 1 << 4, + PSSCAN_COMM = 1 << 5, + /* PSSCAN_CMD = 1 << 6, - use read_cmdline instead */ + PSSCAN_ARGV0 = 1 << 7, + /* PSSCAN_EXE = 1 << 8, - not implemented */ + PSSCAN_STATE = 1 << 9, + PSSCAN_VSZ = 1 << 10, + PSSCAN_RSS = 1 << 11, + PSSCAN_STIME = 1 << 12, + PSSCAN_UTIME = 1 << 13, + PSSCAN_TTY = 1 << 14, + PSSCAN_SMAPS = (1 << 15) * ENABLE_FEATURE_TOPMEM, + /* NB: used by find_pid_by_name(). Any applet using it + * needs to be mentioned here. */ + PSSCAN_ARGVN = (1 << 16) * (ENABLE_KILLALL + || ENABLE_PGREP || ENABLE_PKILL + || ENABLE_PIDOF + || ENABLE_SESTATUS + ), + USE_SELINUX(PSSCAN_CONTEXT = 1 << 17,) + PSSCAN_START_TIME = 1 << 18, + PSSCAN_CPU = 1 << 19, + /* These are all retrieved from proc/NN/stat in one go: */ + PSSCAN_STAT = PSSCAN_PPID | PSSCAN_PGID | PSSCAN_SID + /**/ | PSSCAN_COMM | PSSCAN_STATE + /**/ | PSSCAN_VSZ | PSSCAN_RSS + /**/ | PSSCAN_STIME | PSSCAN_UTIME | PSSCAN_START_TIME + /**/ | PSSCAN_TTY +#if ENABLE_FEATURE_TOP_SMP_PROCESS + /**/ | PSSCAN_CPU +#endif +}; +//procps_status_t* alloc_procps_scan(void) FAST_FUNC; +void free_procps_scan(procps_status_t* sp) FAST_FUNC; +procps_status_t* procps_scan(procps_status_t* sp, int flags) FAST_FUNC; +/* Format cmdline (up to col chars) into char buf[col+1] */ +/* Puts [comm] if cmdline is empty (-> process is a kernel thread) */ +void read_cmdline(char *buf, int col, unsigned pid, const char *comm) FAST_FUNC; +pid_t *find_pid_by_name(const char* procName) FAST_FUNC; +pid_t *pidlist_reverse(pid_t *pidList) FAST_FUNC; + + +extern const char bb_uuenc_tbl_base64[]; +extern const char bb_uuenc_tbl_std[]; +void bb_uuencode(char *store, const void *s, int length, const char *tbl) FAST_FUNC; + +typedef struct sha1_ctx_t { + uint32_t count[2]; + uint32_t hash[5]; + uint32_t wbuf[16]; +} sha1_ctx_t; +void sha1_begin(sha1_ctx_t *ctx) FAST_FUNC; +void sha1_hash(const void *data, size_t length, sha1_ctx_t *ctx) FAST_FUNC; +void *sha1_end(void *resbuf, sha1_ctx_t *ctx) FAST_FUNC; + +typedef struct md5_ctx_t { + uint32_t A; + uint32_t B; + uint32_t C; + uint32_t D; + uint64_t total; + uint32_t buflen; + char buffer[128]; +} md5_ctx_t; +void md5_begin(md5_ctx_t *ctx) FAST_FUNC; +void md5_hash(const void *data, size_t length, md5_ctx_t *ctx) FAST_FUNC; +void *md5_end(void *resbuf, md5_ctx_t *ctx) FAST_FUNC; + +uint32_t *crc32_filltable(uint32_t *tbl256, int endian) FAST_FUNC; + +typedef struct masks_labels_t { + const char *labels; + const int masks[]; +} masks_labels_t; +int print_flags_separated(const int *masks, const char *labels, + int flags, const char *separator) FAST_FUNC; +int print_flags(const masks_labels_t *ml, int flags) FAST_FUNC; + + +extern const char *applet_name; +/* "BusyBox vN.N.N (timestamp or extra_version)" */ +extern const char bb_banner[]; +extern const char bb_msg_memory_exhausted[]; +extern const char bb_msg_invalid_date[]; +extern const char bb_msg_read_error[]; +extern const char bb_msg_write_error[]; +extern const char bb_msg_unknown[]; +extern const char bb_msg_can_not_create_raw_socket[]; +extern const char bb_msg_perm_denied_are_you_root[]; +extern const char bb_msg_requires_arg[]; +extern const char bb_msg_invalid_arg[]; +extern const char bb_msg_standard_input[]; +extern const char bb_msg_standard_output[]; + +extern const char bb_str_default[]; +/* NB: (bb_hexdigits_upcase[i] | 0x20) -> lowercase hex digit */ +extern const char bb_hexdigits_upcase[]; + +extern const char bb_path_mtab_file[]; +extern const char bb_path_passwd_file[]; +extern const char bb_path_shadow_file[]; +extern const char bb_path_gshadow_file[]; +extern const char bb_path_group_file[]; +extern const char bb_path_motd_file[]; +extern const char bb_path_wtmp_file[]; +extern const char bb_dev_null[]; +extern const char bb_busybox_exec_path[]; +/* util-linux manpage says /sbin:/bin:/usr/sbin:/usr/bin, + * but I want to save a few bytes here */ +extern const char bb_PATH_root_path[]; /* "PATH=/sbin:/usr/sbin:/bin:/usr/bin" */ +#define bb_default_root_path (bb_PATH_root_path + sizeof("PATH")) +#define bb_default_path (bb_PATH_root_path + sizeof("PATH=/sbin:/usr/sbin")) + +extern const int const_int_0; +extern const int const_int_1; + + +#ifndef BUFSIZ +#define BUFSIZ 4096 +#endif +/* Providing hard guarantee on minimum size (think of BUFSIZ == 128) */ +enum { COMMON_BUFSIZE = (BUFSIZ >= 256*sizeof(void*) ? BUFSIZ+1 : 256*sizeof(void*)) }; +extern char bb_common_bufsiz1[COMMON_BUFSIZE]; +/* This struct is deliberately not defined. */ +/* See docs/keep_data_small.txt */ +struct globals; +/* '*const' ptr makes gcc optimize code much better. + * Magic prevents ptr_to_globals from going into rodata. + * If you want to assign a value, use SET_PTR_TO_GLOBALS(x) */ +extern struct globals *const ptr_to_globals; +/* At least gcc 3.4.6 on mipsel system needs optimization barrier */ +#define barrier() __asm__ __volatile__("":::"memory") +#define SET_PTR_TO_GLOBALS(x) do { \ + (*(struct globals**)&ptr_to_globals) = (x); \ + barrier(); \ +} while (0) + +/* You can change LIBBB_DEFAULT_LOGIN_SHELL, but don't use it, + * use bb_default_login_shell and following defines. + * If you change LIBBB_DEFAULT_LOGIN_SHELL, + * don't forget to change increment constant. */ +#define LIBBB_DEFAULT_LOGIN_SHELL "-/bin/sh" +extern const char bb_default_login_shell[]; +/* "/bin/sh" */ +#define DEFAULT_SHELL (bb_default_login_shell+1) +/* "sh" */ +#define DEFAULT_SHELL_SHORT_NAME (bb_default_login_shell+6) + +#if ENABLE_FEATURE_DEVFS +# define CURRENT_VC "/dev/vc/0" +# define VC_1 "/dev/vc/1" +# define VC_2 "/dev/vc/2" +# define VC_3 "/dev/vc/3" +# define VC_4 "/dev/vc/4" +# define VC_5 "/dev/vc/5" +#if defined(__sh__) || defined(__H8300H__) || defined(__H8300S__) +/* Yes, this sucks, but both SH (including sh64) and H8 have a SCI(F) for their + respective serial ports .. as such, we can't use the common device paths for + these. -- PFM */ +# define SC_0 "/dev/ttsc/0" +# define SC_1 "/dev/ttsc/1" +# define SC_FORMAT "/dev/ttsc/%d" +#else +# define SC_0 "/dev/tts/0" +# define SC_1 "/dev/tts/1" +# define SC_FORMAT "/dev/tts/%d" +#endif +# define VC_FORMAT "/dev/vc/%d" +# define LOOP_FORMAT "/dev/loop/%d" +# define LOOP_NAMESIZE (sizeof("/dev/loop/") + sizeof(int)*3 + 1) +# define LOOP_NAME "/dev/loop/" +# define FB_0 "/dev/fb/0" +#else +# define CURRENT_VC "/dev/tty0" +# define VC_1 "/dev/tty1" +# define VC_2 "/dev/tty2" +# define VC_3 "/dev/tty3" +# define VC_4 "/dev/tty4" +# define VC_5 "/dev/tty5" +#if defined(__sh__) || defined(__H8300H__) || defined(__H8300S__) +# define SC_0 "/dev/ttySC0" +# define SC_1 "/dev/ttySC1" +# define SC_FORMAT "/dev/ttySC%d" +#else +# define SC_0 "/dev/ttyS0" +# define SC_1 "/dev/ttyS1" +# define SC_FORMAT "/dev/ttyS%d" +#endif +# define VC_FORMAT "/dev/tty%d" +# define LOOP_FORMAT "/dev/loop%d" +# define LOOP_NAMESIZE (sizeof("/dev/loop") + sizeof(int)*3 + 1) +# define LOOP_NAME "/dev/loop" +# define FB_0 "/dev/fb0" +#endif + +/* The following devices are the same on devfs and non-devfs systems. */ +#define CURRENT_TTY "/dev/tty" +#define DEV_CONSOLE "/dev/console" + + +#ifndef RB_POWER_OFF +/* Stop system and switch power off if possible. */ +#define RB_POWER_OFF 0x4321fedc +#endif + +/* Make sure we call functions instead of macros. */ +#undef isalnum +#undef isalpha +#undef isascii +#undef isblank +#undef iscntrl +#undef isgraph +#undef islower +#undef isprint +#undef ispunct +#undef isspace +#undef isupper +#undef isxdigit + +/* This one is more efficient - we save ~400 bytes */ +#undef isdigit +#define isdigit(a) ((unsigned)((a) - '0') <= 9) + +#define ARRAY_SIZE(x) ((unsigned)(sizeof(x) / sizeof((x)[0]))) + + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility pop +#endif + + +#endif /* __LIBBUSYBOX_H__ */ diff --git a/include/platform.h b/include/platform.h new file mode 100644 index 0000000..8657ba4 --- /dev/null +++ b/include/platform.h @@ -0,0 +1,366 @@ +/* vi: set sw=4 ts=4: */ +/* + Copyright 2006, Bernhard Reutner-Fischer + + Licensed under the GPL v2 or later, see the file LICENSE in this tarball. +*/ +#ifndef __PLATFORM_H +#define __PLATFORM_H 1 + +/* Convenience macros to test the version of gcc. */ +#undef __GNUC_PREREQ +#if defined __GNUC__ && defined __GNUC_MINOR__ +# define __GNUC_PREREQ(maj, min) \ + ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) +#else +# define __GNUC_PREREQ(maj, min) 0 +#endif + +/* __restrict is known in EGCS 1.2 and above. */ +#if !__GNUC_PREREQ(2,92) +# ifndef __restrict +# define __restrict /* Ignore */ +# endif +#endif + +/* Define macros for some gcc attributes. This permits us to use the + macros freely, and know that they will come into play for the + version of gcc in which they are supported. */ + +#if !__GNUC_PREREQ(2,7) +# ifndef __attribute__ +# define __attribute__(x) +# endif +#endif + +#undef inline +#if defined(__STDC_VERSION__) && __STDC_VERSION__ > 199901L +/* it's a keyword */ +#else +# if __GNUC_PREREQ(2,7) +# define inline __inline__ +# else +# define inline +# endif +#endif + +#ifndef __const +# define __const const +#endif + +#define UNUSED_PARAM __attribute__ ((__unused__)) +#define NORETURN __attribute__ ((__noreturn__)) +#define PACKED __attribute__ ((__packed__)) +#define ALIGNED(m) __attribute__ ((__aligned__(m))) +/* __NO_INLINE__: some gcc's do not honor inlining! :( */ +#if __GNUC_PREREQ(3,0) && !defined(__NO_INLINE__) +# define ALWAYS_INLINE __attribute__ ((always_inline)) inline +/* I've seen a toolchain where I needed __noinline__ instead of noinline */ +# define NOINLINE __attribute__((__noinline__)) +# if !ENABLE_WERROR +# define DEPRECATED __attribute__ ((__deprecated__)) +# define UNUSED_PARAM_RESULT __attribute__ ((warn_unused_result)) +# else +# define DEPRECATED /* n/a */ +# define UNUSED_PARAM_RESULT /* n/a */ +# endif +#else +# define ALWAYS_INLINE inline /* n/a */ +# define NOINLINE /* n/a */ +# define DEPRECATED /* n/a */ +# define UNUSED_PARAM_RESULT /* n/a */ +#endif + +/* -fwhole-program makes all symbols local. The attribute externally_visible + forces a symbol global. */ +#if __GNUC_PREREQ(4,1) +# define EXTERNALLY_VISIBLE __attribute__(( visibility("default") )) +//__attribute__ ((__externally_visible__)) +#else +# define EXTERNALLY_VISIBLE +#endif /* GNUC >= 4.1 */ + +/* We use __extension__ in some places to suppress -pedantic warnings + about GCC extensions. This feature didn't work properly before + gcc 2.8. */ +#if !__GNUC_PREREQ(2,8) +# ifndef __extension__ +# define __extension__ +# endif +#endif + +/* gcc-2.95 had no va_copy but only __va_copy. */ +#if !__GNUC_PREREQ(3,0) +# include <stdarg.h> +# if !defined va_copy && defined __va_copy +# define va_copy(d,s) __va_copy((d),(s)) +# endif +#endif + +/* FAST_FUNC is a qualifier which (possibly) makes function call faster + * and/or smaller by using modified ABI. It is usually only needed + * on non-static, busybox internal functions. Recent versions of gcc + * optimize statics automatically. FAST_FUNC on static is required + * only if you need to match a function pointer's type */ +#if __GNUC_PREREQ(3,0) && defined(i386) /* || defined(__x86_64__)? */ +/* stdcall makes callee to pop arguments from stack, not caller */ +# define FAST_FUNC __attribute__((regparm(3),stdcall)) +/* #elif ... - add your favorite arch today! */ +#else +# define FAST_FUNC +#endif + +/* ---- Endian Detection ------------------------------------ */ + +#if (defined __digital__ && defined __unix__) +# include <sex.h> +# define __BIG_ENDIAN__ (BYTE_ORDER == BIG_ENDIAN) +# define __BYTE_ORDER BYTE_ORDER +#elif !defined __APPLE__ +# include <byteswap.h> +# include <endian.h> +#endif + +#ifdef __BIG_ENDIAN__ +# define BB_BIG_ENDIAN 1 +# define BB_LITTLE_ENDIAN 0 +#elif __BYTE_ORDER == __BIG_ENDIAN +# define BB_BIG_ENDIAN 1 +# define BB_LITTLE_ENDIAN 0 +#else +# define BB_BIG_ENDIAN 0 +# define BB_LITTLE_ENDIAN 1 +#endif + +/* SWAP_LEnn means "convert CPU<->little_endian by swapping bytes" */ +#if BB_BIG_ENDIAN +#define SWAP_BE16(x) (x) +#define SWAP_BE32(x) (x) +#define SWAP_BE64(x) (x) +#define SWAP_LE16(x) bswap_16(x) +#define SWAP_LE32(x) bswap_32(x) +#define SWAP_LE64(x) bswap_64(x) +#else +#define SWAP_BE16(x) bswap_16(x) +#define SWAP_BE32(x) bswap_32(x) +#define SWAP_BE64(x) bswap_64(x) +#define SWAP_LE16(x) (x) +#define SWAP_LE32(x) (x) +#define SWAP_LE64(x) (x) +#endif + +/* ---- Unaligned access ------------------------------------ */ + +/* parameter is supposed to be an uint32_t* ptr */ +#if defined(i386) || defined(__x86_64__) +#define get_unaligned_u32p(u32p) (*(u32p)) +/* #elif ... - add your favorite arch today! */ +#else +/* performs reasonably well (gcc usually inlines memcpy here) */ +#define get_unaligned_u32p(u32p) ({ uint32_t __t; memcpy(&__t, (u32p), 4); __t; }) +#endif + +/* ---- Networking ------------------------------------------ */ + +#ifndef __APPLE__ +# include <arpa/inet.h> +# ifndef __socklen_t_defined +typedef int socklen_t; +# endif +#else +# include <netinet/in.h> +#endif + +/* ---- Compiler dependent settings ------------------------- */ + +#if (defined __digital__ && defined __unix__) || defined __APPLE__ +# undef HAVE_MNTENT_H +# undef HAVE_SYS_STATFS_H +#else +# define HAVE_MNTENT_H 1 +# define HAVE_SYS_STATFS_H 1 +#endif /* ___digital__ && __unix__ */ + +/* linux/loop.h relies on __u64. Make sure we have that as a proper type + * until userspace is widely fixed. */ +#if (defined __INTEL_COMPILER && !defined __GNUC__) || \ + (defined __GNUC__ && defined __STRICT_ANSI__) +__extension__ typedef __signed__ long long __s64; +__extension__ typedef unsigned long long __u64; +#endif + +/*----- Kernel versioning ------------------------------------*/ + +#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c)) + +/* ---- Miscellaneous --------------------------------------- */ + +#if defined(__GNU_LIBRARY__) && __GNU_LIBRARY__ < 5 && \ + !defined(__dietlibc__) && \ + !defined(_NEWLIB_VERSION) && \ + !(defined __digital__ && defined __unix__) +# error "Sorry, this libc version is not supported :(" +#endif + +/* Don't perpetuate e2fsck crap into the headers. Clean up e2fsck instead. */ + +#if defined __GLIBC__ || defined __UCLIBC__ \ + || defined __dietlibc__ || defined _NEWLIB_VERSION +#include <features.h> +#define HAVE_FEATURES_H +#include <stdint.h> +#define HAVE_STDINT_H +#elif !defined __APPLE__ +/* Largest integral types. */ +#if __BIG_ENDIAN__ +typedef long intmax_t; +typedef unsigned long uintmax_t; +#else +__extension__ +typedef long long intmax_t; +__extension__ +typedef unsigned long long uintmax_t; +#endif +#endif + +/* Size-saving "small" ints (arch-dependent) */ +#if defined(i386) || defined(__x86_64__) || defined(__mips__) || defined(__cris__) +/* add other arches which benefit from this... */ +typedef signed char smallint; +typedef unsigned char smalluint; +#else +/* for arches where byte accesses generate larger code: */ +typedef int smallint; +typedef unsigned smalluint; +#endif + +/* ISO C Standard: 7.16 Boolean type and values <stdbool.h> */ +#if (defined __digital__ && defined __unix__) +/* old system without (proper) C99 support */ +#define bool smalluint +#else +/* modern system, so use it */ +#include <stdbool.h> +#endif + +/* Try to defeat gcc's alignment of "char message[]"-like data */ +#if 1 /* if needed: !defined(arch1) && !defined(arch2) */ +#define ALIGN1 __attribute__((aligned(1))) +#define ALIGN2 __attribute__((aligned(2))) +#else +/* Arches which MUST have 2 or 4 byte alignment for everything are here */ +#define ALIGN1 +#define ALIGN2 +#endif + + +/* uclibc does not implement daemon() for no-mmu systems. + * For 0.9.29 and svn, __ARCH_USE_MMU__ indicates no-mmu reliably. + * For earlier versions there is no reliable way to check if we are building + * for a mmu-less system. + */ +#if ENABLE_NOMMU || \ + (defined __UCLIBC__ && __UCLIBC_MAJOR__ >= 0 && __UCLIBC_MINOR__ >= 9 && \ + __UCLIBC_SUBLEVEL__ > 28 && !defined __ARCH_USE_MMU__) +#define BB_MMU 0 +#define USE_FOR_NOMMU(...) __VA_ARGS__ +#define USE_FOR_MMU(...) +#else +#define BB_MMU 1 +#define USE_FOR_NOMMU(...) +#define USE_FOR_MMU(...) __VA_ARGS__ +#endif + +/* Platforms that haven't got dprintf need to implement fdprintf() in + * libbb. This would require a platform.c. It's not going to be cleaned + * out of the tree, so stop saying it should be. */ +#if !defined(__dietlibc__) +/* Needed for: glibc */ +/* Not needed for: dietlibc */ +/* Others: ?? (add as needed) */ +#define fdprintf dprintf +#endif + +#if defined(__dietlibc__) +static ALWAYS_INLINE char* strchrnul(const char *s, char c) +{ + while (*s && *s != c) ++s; + return (char*)s; +} +#endif + +/* Don't use lchown with glibc older than 2.1.x ... uClibc lacks it */ +#if (defined __GLIBC__ && __GLIBC__ <= 2 && __GLIBC_MINOR__ < 1) || \ + defined __UC_LIBC__ +# define lchown chown +#endif + +#if (defined __digital__ && defined __unix__) +#include <standards.h> +#define HAVE_STANDARDS_H +#include <inttypes.h> +#define HAVE_INTTYPES_H +#define PRIu32 "u" + +/* use legacy setpgrp(pid_t,pid_t) for now. move to platform.c */ +#define bb_setpgrp() do { pid_t __me = getpid(); setpgrp(__me,__me); } while (0) + +#if !defined ADJ_OFFSET_SINGLESHOT && defined MOD_CLKA && defined MOD_OFFSET +#define ADJ_OFFSET_SINGLESHOT (MOD_CLKA | MOD_OFFSET) +#endif +#if !defined ADJ_FREQUENCY && defined MOD_FREQUENCY +#define ADJ_FREQUENCY MOD_FREQUENCY +#endif +#if !defined ADJ_TIMECONST && defined MOD_TIMECONST +#define ADJ_TIMECONST MOD_TIMECONST +#endif +#if !defined ADJ_TICK && defined MOD_CLKB +#define ADJ_TICK MOD_CLKB +#endif + +#else +#define bb_setpgrp() setpgrp() +#endif + +#if defined(__linux__) +#include <sys/mount.h> +/* Make sure we have all the new mount flags we actually try to use. */ +#ifndef MS_BIND +#define MS_BIND (1<<12) +#endif +#ifndef MS_MOVE +#define MS_MOVE (1<<13) +#endif +#ifndef MS_RECURSIVE +#define MS_RECURSIVE (1<<14) +#endif +#ifndef MS_SILENT +#define MS_SILENT (1<<15) +#endif + +/* The shared subtree stuff, which went in around 2.6.15. */ +#ifndef MS_UNBINDABLE +#define MS_UNBINDABLE (1<<17) +#endif +#ifndef MS_PRIVATE +#define MS_PRIVATE (1<<18) +#endif +#ifndef MS_SLAVE +#define MS_SLAVE (1<<19) +#endif +#ifndef MS_SHARED +#define MS_SHARED (1<<20) +#endif +#ifndef MS_RELATIME +#define MS_RELATIME (1 << 21) +#endif + +#if !defined(BLKSSZGET) +#define BLKSSZGET _IO(0x12, 104) +#endif +#if !defined(BLKGETSIZE64) +#define BLKGETSIZE64 _IOR(0x12,114,size_t) +#endif +#endif + +#endif /* platform.h */ diff --git a/include/pwd_.h b/include/pwd_.h new file mode 100644 index 0000000..a0cf7c9 --- /dev/null +++ b/include/pwd_.h @@ -0,0 +1,114 @@ +/* vi: set sw=4 ts=4: */ +/* Copyright (C) 1991,92,95,96,97,98,99,2001 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +/* + * POSIX Standard: 9.2.2 User Database Access <pwd.h> + */ + +#ifndef BB_PWD_H +#define BB_PWD_H 1 + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility push(hidden) +#endif + +/* This file is #included after #include <pwd.h> + * We will use libc-defined structures, but will #define function names + * so that function calls are directed to bb_internal_XXX replacements + */ + +#define setpwent bb_internal_setpwent +#define endpwent bb_internal_endpwent +#define getpwent bb_internal_getpwent +#define fgetpwent bb_internal_fgetpwent +#define putpwent bb_internal_putpwent +#define getpwuid bb_internal_getpwuid +#define getpwnam bb_internal_getpwnam +#define getpwent_r bb_internal_getpwent_r +#define getpwuid_r bb_internal_getpwuid_r +#define getpwnam_r bb_internal_getpwnam_r +#define fgetpwent_r bb_internal_fgetpwent_r +//#define getpw bb_internal_getpw + + +/* All function names below should be remapped by #defines above + * in order to not collide with libc names. */ + + +/* Rewind the password-file stream. */ +extern void setpwent(void); + +/* Close the password-file stream. */ +extern void endpwent(void); + +/* Read an entry from the password-file stream, opening it if necessary. */ +extern struct passwd *getpwent(void); + +/* Read an entry from STREAM. */ +extern struct passwd *fgetpwent(FILE *__stream); + +/* Write the given entry onto the given stream. */ +extern int putpwent(const struct passwd *__restrict __p, + FILE *__restrict __f); + +/* Search for an entry with a matching user ID. */ +extern struct passwd *getpwuid(uid_t __uid); + +/* Search for an entry with a matching username. */ +extern struct passwd *getpwnam(const char *__name); + +/* Reentrant versions of some of the functions above. + + PLEASE NOTE: the `getpwent_r' function is not (yet) standardized. + The interface may change in later versions of this library. But + the interface is designed following the principals used for the + other reentrant functions so the chances are good this is what the + POSIX people would choose. */ + +extern int getpwent_r(struct passwd *__restrict __resultbuf, + char *__restrict __buffer, size_t __buflen, + struct passwd **__restrict __result); + +extern int getpwuid_r(uid_t __uid, + struct passwd *__restrict __resultbuf, + char *__restrict __buffer, size_t __buflen, + struct passwd **__restrict __result); + +extern int getpwnam_r(const char *__restrict __name, + struct passwd *__restrict __resultbuf, + char *__restrict __buffer, size_t __buflen, + struct passwd **__restrict __result); + +/* Read an entry from STREAM. This function is not standardized and + probably never will. */ +extern int fgetpwent_r(FILE *__restrict __stream, + struct passwd *__restrict __resultbuf, + char *__restrict __buffer, size_t __buflen, + struct passwd **__restrict __result); + +/* Re-construct the password-file line for the given uid + in the given buffer. This knows the format that the caller + will expect, but this need not be the format of the password file. */ +/* UNUSED extern int getpw(uid_t __uid, char *__buffer); */ + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility pop +#endif + +#endif /* pwd.h */ diff --git a/include/rtc_.h b/include/rtc_.h new file mode 100644 index 0000000..867edb3 --- /dev/null +++ b/include/rtc_.h @@ -0,0 +1,79 @@ +/* + * Common defines/structures/etc... for applets that need to work with the RTC. + * + * Licensed under the GPL-2 or later. + */ + +#ifndef BB_RTC_H +#define BB_RTC_H + +#include "libbb.h" + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility push(hidden) +#endif + +extern int rtc_adjtime_is_utc(void) FAST_FUNC; +extern int rtc_xopen(const char **default_rtc, int flags) FAST_FUNC; +extern time_t rtc_read_time(int fd, int utc) FAST_FUNC; + +/* + * Everything below this point has been copied from linux/rtc.h + * to eliminate the kernel header dependency + */ + +struct linux_rtc_time { + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; +}; + +struct linux_rtc_wkalrm { + unsigned char enabled; /* 0 = alarm disabled, 1 = alarm enabled */ + unsigned char pending; /* 0 = alarm not pending, 1 = alarm pending */ + struct linux_rtc_time time; /* time the alarm is set to */ +}; + +/* + * ioctl calls that are permitted to the /dev/rtc interface, if + * any of the RTC drivers are enabled. + */ + +#define RTC_AIE_ON _IO('p', 0x01) /* Alarm int. enable on */ +#define RTC_AIE_OFF _IO('p', 0x02) /* ... off */ +#define RTC_UIE_ON _IO('p', 0x03) /* Update int. enable on */ +#define RTC_UIE_OFF _IO('p', 0x04) /* ... off */ +#define RTC_PIE_ON _IO('p', 0x05) /* Periodic int. enable on */ +#define RTC_PIE_OFF _IO('p', 0x06) /* ... off */ +#define RTC_WIE_ON _IO('p', 0x0f) /* Watchdog int. enable on */ +#define RTC_WIE_OFF _IO('p', 0x10) /* ... off */ + +#define RTC_ALM_SET _IOW('p', 0x07, struct linux_rtc_time) /* Set alarm time */ +#define RTC_ALM_READ _IOR('p', 0x08, struct linux_rtc_time) /* Read alarm time */ +#define RTC_RD_TIME _IOR('p', 0x09, struct linux_rtc_time) /* Read RTC time */ +#define RTC_SET_TIME _IOW('p', 0x0a, struct linux_rtc_time) /* Set RTC time */ +#define RTC_IRQP_READ _IOR('p', 0x0b, unsigned long) /* Read IRQ rate */ +#define RTC_IRQP_SET _IOW('p', 0x0c, unsigned long) /* Set IRQ rate */ +#define RTC_EPOCH_READ _IOR('p', 0x0d, unsigned long) /* Read epoch */ +#define RTC_EPOCH_SET _IOW('p', 0x0e, unsigned long) /* Set epoch */ + +#define RTC_WKALM_SET _IOW('p', 0x0f, struct linux_rtc_wkalrm)/* Set wakeup alarm*/ +#define RTC_WKALM_RD _IOR('p', 0x10, struct linux_rtc_wkalrm)/* Get wakeup alarm*/ + +/* interrupt flags */ +#define RTC_IRQF 0x80 /* any of the following is active */ +#define RTC_PF 0x40 +#define RTC_AF 0x20 +#define RTC_UF 0x10 + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility pop +#endif + +#endif diff --git a/include/shadow_.h b/include/shadow_.h new file mode 100644 index 0000000..60f3e6b --- /dev/null +++ b/include/shadow_.h @@ -0,0 +1,104 @@ +/* vi: set sw=4 ts=4: */ +/* Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +/* Declaration of types and functions for shadow password suite */ + +#ifndef BB_SHADOW_H +#define BB_SHADOW_H 1 + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility push(hidden) +#endif + +/* This file is #included after #include <shadow.h> + * We will use libc-defined structures, but will #define function names + * so that function calls are directed to bb_internal_XXX replacements + */ + +/* Paths to the user database files */ +#ifndef _PATH_SHADOW +#define _PATH_SHADOW "/etc/shadow" +#endif + +#define setspent bb_internal_setspent +#define endspent bb_internal_endspent +#define getspent bb_internal_getspent +#define getspnam bb_internal_getspnam +#define sgetspent bb_internal_sgetspent +#define fgetspent bb_internal_fgetspent +#define putspent bb_internal_putspent +#define getspent_r bb_internal_getspent_r +#define getspnam_r bb_internal_getspnam_r +#define sgetspent_r bb_internal_sgetspent_r +#define fgetspent_r bb_internal_fgetspent_r +#define lckpwdf bb_internal_lckpwdf +#define ulckpwdf bb_internal_ulckpwdf + + +/* All function names below should be remapped by #defines above + * in order to not collide with libc names. */ + + +/* Open database for reading */ +extern void setspent(void); + +/* Close database */ +extern void endspent(void); + +/* Get next entry from database, perhaps after opening the file */ +extern struct spwd *getspent(void); + +/* Get shadow entry matching NAME */ +extern struct spwd *getspnam(const char *__name); + +/* Read shadow entry from STRING */ +extern struct spwd *sgetspent(const char *__string); + +/* Read next shadow entry from STREAM */ +extern struct spwd *fgetspent(FILE *__stream); + +/* Write line containing shadow password entry to stream */ +extern int putspent(const struct spwd *__p, FILE *__stream); + +/* Reentrant versions of some of the functions above */ +extern int getspent_r(struct spwd *__result_buf, char *__buffer, + size_t __buflen, struct spwd **__result); + +extern int getspnam_r(const char *__name, struct spwd *__result_buf, + char *__buffer, size_t __buflen, + struct spwd **__result); + +extern int sgetspent_r(const char *__string, struct spwd *__result_buf, + char *__buffer, size_t __buflen, + struct spwd **__result); + +extern int fgetspent_r(FILE *__stream, struct spwd *__result_buf, + char *__buffer, size_t __buflen, + struct spwd **__result); +/* Protect password file against multi writers */ +extern int lckpwdf(void); + +/* Unlock password file */ +extern int ulckpwdf(void); + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility pop +#endif + +#endif /* shadow.h */ diff --git a/include/unarchive.h b/include/unarchive.h new file mode 100644 index 0000000..9077130 --- /dev/null +++ b/include/unarchive.h @@ -0,0 +1,157 @@ +/* vi: set sw=4 ts=4: */ +#ifndef __UNARCHIVE_H__ +#define __UNARCHIVE_H__ + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility push(hidden) +#endif + +#define ARCHIVE_PRESERVE_DATE 1 +#define ARCHIVE_CREATE_LEADING_DIRS 2 +#define ARCHIVE_EXTRACT_UNCONDITIONAL 4 +#define ARCHIVE_EXTRACT_QUIET 8 +#define ARCHIVE_EXTRACT_NEWER 16 +#define ARCHIVE_NOPRESERVE_OWN 32 +#define ARCHIVE_NOPRESERVE_PERM 64 + +typedef struct file_header_t { + char *name; + char *link_target; +#if ENABLE_FEATURE_TAR_UNAME_GNAME + char *uname; + char *gname; +#endif + off_t size; + uid_t uid; + gid_t gid; + mode_t mode; + time_t mtime; + dev_t device; +} file_header_t; + +typedef struct archive_handle_t { + /* Define if the header and data component should be processed */ + char FAST_FUNC (*filter)(struct archive_handle_t *); + llist_t *accept; + /* List of files that have been rejected */ + llist_t *reject; + /* List of files that have successfully been worked on */ + llist_t *passed; + + /* Contains the processed header entry */ + file_header_t *file_header; + + /* Process the header component, e.g. tar -t */ + void FAST_FUNC (*action_header)(const file_header_t *); + + /* Process the data component, e.g. extract to filesystem */ + void FAST_FUNC (*action_data)(struct archive_handle_t *); + +#if ENABLE_DPKG || ENABLE_DPKG_DEB + /* "subarchive" is used only by dpkg[-deb] applets */ + /* How to process any sub archive, e.g. get_header_tar_gz */ + char FAST_FUNC (*action_data_subarchive)(struct archive_handle_t *); + /* Contains the handle to a sub archive */ + struct archive_handle_t *sub_archive; +#endif + + /* The raw stream as read from disk or stdin */ + int src_fd; + + /* Count the number of bytes processed */ + off_t offset; + + /* Function that skips data: read_by_char or read_by_skip */ + void FAST_FUNC (*seek)(const struct archive_handle_t *archive_handle, const unsigned amount); + + /* Temporary storage */ + char *buffer; + + /* Flags and misc. stuff */ + unsigned char ah_flags; + + /* "Private" storage for archivers */ +// unsigned char ah_priv_inited; + void *ah_priv[8]; + +} archive_handle_t; + + +/* Info struct unpackers can fill out to inform users of thing like + * timestamps of unpacked files */ +typedef struct unpack_info_t { + time_t mtime; +} unpack_info_t; + +extern archive_handle_t *init_handle(void) FAST_FUNC; + +extern char filter_accept_all(archive_handle_t *archive_handle) FAST_FUNC; +extern char filter_accept_list(archive_handle_t *archive_handle) FAST_FUNC; +extern char filter_accept_list_reassign(archive_handle_t *archive_handle) FAST_FUNC; +extern char filter_accept_reject_list(archive_handle_t *archive_handle) FAST_FUNC; + +extern void unpack_ar_archive(archive_handle_t *ar_archive) FAST_FUNC; + +extern void data_skip(archive_handle_t *archive_handle) FAST_FUNC; +extern void data_extract_all(archive_handle_t *archive_handle) FAST_FUNC; +extern void data_extract_to_stdout(archive_handle_t *archive_handle) FAST_FUNC; +extern void data_extract_to_buffer(archive_handle_t *archive_handle) FAST_FUNC; + +extern void header_skip(const file_header_t *file_header) FAST_FUNC; +extern void header_list(const file_header_t *file_header) FAST_FUNC; +extern void header_verbose_list(const file_header_t *file_header) FAST_FUNC; + +extern char get_header_ar(archive_handle_t *archive_handle) FAST_FUNC; +extern char get_header_cpio(archive_handle_t *archive_handle) FAST_FUNC; +extern char get_header_tar(archive_handle_t *archive_handle) FAST_FUNC; +extern char get_header_tar_gz(archive_handle_t *archive_handle) FAST_FUNC; +extern char get_header_tar_bz2(archive_handle_t *archive_handle) FAST_FUNC; +extern char get_header_tar_lzma(archive_handle_t *archive_handle) FAST_FUNC; + +extern void seek_by_jump(const archive_handle_t *archive_handle, unsigned amount) FAST_FUNC; +extern void seek_by_read(const archive_handle_t *archive_handle, unsigned amount) FAST_FUNC; + +extern void data_align(archive_handle_t *archive_handle, unsigned boundary) FAST_FUNC; +extern const llist_t *find_list_entry(const llist_t *list, const char *filename) FAST_FUNC; +extern const llist_t *find_list_entry2(const llist_t *list, const char *filename) FAST_FUNC; + +/* A bit of bunzip2 internals are exposed for compressed help support: */ +typedef struct bunzip_data bunzip_data; +int start_bunzip(bunzip_data **bdp, int in_fd, const unsigned char *inbuf, int len) FAST_FUNC; +int read_bunzip(bunzip_data *bd, char *outbuf, int len) FAST_FUNC; +void dealloc_bunzip(bunzip_data *bd) FAST_FUNC; + +typedef struct inflate_unzip_result { + off_t bytes_out; + uint32_t crc; +} inflate_unzip_result; + +USE_DESKTOP(long long) int inflate_unzip(inflate_unzip_result *res, off_t compr_size, int src_fd, int dst_fd) FAST_FUNC; +/* lzma unpacker takes .lzma stream from offset 0 */ +USE_DESKTOP(long long) int unpack_lzma_stream(int src_fd, int dst_fd) FAST_FUNC; +/* the rest wants 2 first bytes already skipped by the caller */ +USE_DESKTOP(long long) int unpack_bz2_stream(int src_fd, int dst_fd) FAST_FUNC; +USE_DESKTOP(long long) int unpack_gz_stream(int src_fd, int dst_fd) FAST_FUNC; +USE_DESKTOP(long long) int unpack_gz_stream_with_info(int src_fd, int dst_fd, unpack_info_t *info) FAST_FUNC; +USE_DESKTOP(long long) int unpack_Z_stream(int fd_in, int fd_out) FAST_FUNC; +/* wrapper which checks first two bytes to be "BZ" */ +USE_DESKTOP(long long) int unpack_bz2_stream_prime(int src_fd, int dst_fd) FAST_FUNC; + +int bbunpack(char **argv, + char* (*make_new_name)(char *filename), + USE_DESKTOP(long long) int (*unpacker)(unpack_info_t *info)) FAST_FUNC; + +#if BB_MMU +void open_transformer(int fd, + USE_DESKTOP(long long) int FAST_FUNC (*transformer)(int src_fd, int dst_fd)) FAST_FUNC; +#define open_transformer(fd, transformer, transform_prog) open_transformer(fd, transformer) +#else +void open_transformer(int src_fd, const char *transform_prog) FAST_FUNC; +#define open_transformer(fd, transformer, transform_prog) open_transformer(fd, transform_prog) +#endif + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility pop +#endif + +#endif diff --git a/include/usage.h b/include/usage.h new file mode 100644 index 0000000..63aff31 --- /dev/null +++ b/include/usage.h @@ -0,0 +1,4757 @@ +/* vi: set sw=8 ts=8: */ +/* + * This file suffers from chronically incorrect tabification + * of messages. Before editing this file: + * 1. Switch you editor to 8-space tab mode. + * 2. Do not use \t in messages, use real tab character. + * 3. Start each source line with message as follows: + * |<7 spaces>"text with tabs".... + * or + * |<5 spaces>"\ntext with tabs".... + */ + +#ifndef __BB_USAGE_H__ +#define __BB_USAGE_H__ + + +#define NOUSAGE_STR "\b" + + +#define addgroup_trivial_usage \ + "[-g GID] " USE_FEATURE_ADDUSER_TO_GROUP("[user_name] ") "group_name" +#define addgroup_full_usage "\n\n" \ + "Add a group " USE_FEATURE_ADDUSER_TO_GROUP("or add an user to a group") "\n" \ + "\nOptions:" \ + "\n -g GID Group id" \ + +#define adduser_trivial_usage \ + "[OPTIONS] user_name" +#define adduser_full_usage "\n\n" \ + "Add an user\n" \ + "\nOptions:" \ + "\n -h DIR Home directory" \ + "\n -g GECOS GECOS field" \ + "\n -s SHELL Login shell" \ + "\n -G GROUP Add user to existing group" \ + "\n -S Create a system user" \ + "\n -D Do not assign a password" \ + "\n -H Do not create home directory" \ + +#define adjtimex_trivial_usage \ + "[-q] [-o offset] [-f frequency] [-p timeconstant] [-t tick]" +#define adjtimex_full_usage "\n\n" \ + "Read and optionally set system timebase parameters. See adjtimex(2).\n" \ + "\nOptions:" \ + "\n -q Quiet" \ + "\n -o offset Time offset, microseconds" \ + "\n -f frequency Frequency adjust, integer kernel units (65536 is 1ppm)" \ + "\n (positive values make clock run faster)" \ + "\n -t tick Microseconds per tick, usually 10000" \ + "\n -p timeconstant" \ + +#define ar_trivial_usage \ + "[-o] [-v] [-p] [-t] [-x] ARCHIVE FILES" +#define ar_full_usage "\n\n" \ + "Extract or list FILES from an ar archive\n" \ + "\nOptions:" \ + "\n -o Preserve original dates" \ + "\n -p Extract to stdout" \ + "\n -t List" \ + "\n -x Extract" \ + "\n -v Verbose" \ + +#define arp_trivial_usage \ + "\n" \ + "[-vn] [-H type] [-i if] -a [hostname]\n" \ + "[-v] [-i if] -d hostname [pub]\n" \ + "[-v] [-H type] [-i if] -s hostname hw_addr [temp]\n" \ + "[-v] [-H type] [-i if] -s hostname hw_addr [netmask nm] pub\n" \ + "[-v] [-H type] [-i if] -Ds hostname ifa [netmask nm] pub\n" +#define arp_full_usage "\n\n" \ + "Manipulate ARP cache\n" \ + "\nOptions:" \ + "\n -a Display (all) hosts" \ + "\n -s Set new ARP entry" \ + "\n -d Delete a specified entry" \ + "\n -v Verbose" \ + "\n -n Don't resolve names" \ + "\n -i IF Network interface" \ + "\n -D Read <hwaddr> from given device" \ + "\n -A, -p AF Protocol family" \ + "\n -H HWTYPE Hardware address type" \ + +#define arping_trivial_usage \ + "[-fqbDUA] [-c count] [-w timeout] [-I dev] [-s sender] target" +#define arping_full_usage "\n\n" \ + "Send ARP requests/replies\n" \ + "\nOptions:" \ + "\n -f Quit on first ARP reply" \ + "\n -q Quiet" \ + "\n -b Keep broadcasting, don't go unicast" \ + "\n -D Duplicated address detection mode" \ + "\n -U Unsolicited ARP mode, update your neighbors" \ + "\n -A ARP answer mode, update your neighbors" \ + "\n -c N Stop after sending N ARP requests" \ + "\n -w timeout Time to wait for ARP reply, in seconds" \ + "\n -I dev Interface to use (default eth0)" \ + "\n -s sender Sender IP address" \ + "\n target Target IP address" \ + +#define sh_trivial_usage NOUSAGE_STR +#define sh_full_usage "" +#define ash_trivial_usage NOUSAGE_STR +#define ash_full_usage "" +#define hush_trivial_usage NOUSAGE_STR +#define hush_full_usage "" +#define msh_trivial_usage NOUSAGE_STR +#define msh_full_usage "" + +#define awk_trivial_usage \ + "[OPTION]... [program-text] [FILE...]" +#define awk_full_usage "\n\n" \ + "Options:" \ + "\n -v var=val Set variable" \ + "\n -F sep Use sep as field separator" \ + "\n -f file Read program from file" \ + +#define basename_trivial_usage \ + "FILE [SUFFIX]" +#define basename_full_usage "\n\n" \ + "Strip directory path and suffixes from FILE.\n" \ + "If specified, also remove any trailing SUFFIX." +#define basename_example_usage \ + "$ basename /usr/local/bin/foo\n" \ + "foo\n" \ + "$ basename /usr/local/bin/\n" \ + "bin\n" \ + "$ basename /foo/bar.txt .txt\n" \ + "bar" + +#define fbsplash_trivial_usage \ + "-s IMGFILE [-c] [-d DEV] [-i INIFILE] [-f CMD]" +#define fbsplash_full_usage "\n\n" \ + "Options:\n" \ + "\n -s Image" \ + "\n -c Hide cursor" \ + "\n -d Framebuffer device (default /dev/fb0)" \ + "\n -i Config file (var=value):" \ + "\n BAR_LEFT,BAR_TOP,BAR_WIDTH,BAR_HEIGHT" \ + "\n BAR_R,BAR_G,BAR_B" \ + "\n -f Control pipe (else exit after drawing image)" \ + "\n commands: 'NN' (% for progress bar) or 'exit'" \ + +#define brctl_trivial_usage \ + "COMMAND [BRIDGE [INTERFACE]]" +#define brctl_full_usage "\n\n" \ + "Manage ethernet bridges.\n" \ + "\nCommands:" \ + USE_FEATURE_BRCTL_SHOW( \ + "\n show Show a list of bridges" \ + ) \ + "\n addbr BRIDGE Create BRIDGE" \ + "\n delbr BRIDGE Delete BRIDGE" \ + "\n addif BRIDGE IFACE Add IFACE to BRIDGE" \ + "\n delif BRIDGE IFACE Delete IFACE from BRIDGE" \ + USE_FEATURE_BRCTL_FANCY( \ + "\n setageing BRIDGE TIME Set ageing time" \ + "\n setfd BRIDGE TIME Set bridge forward delay" \ + "\n sethello BRIDGE TIME Set hello time" \ + "\n setmaxage BRIDGE TIME Set max message age" \ + "\n setpathcost BRIDGE COST Set path cost" \ + "\n setportprio BRIDGE PRIO Set port priority" \ + "\n setbridgeprio BRIDGE PRIO Set bridge priority" \ + "\n stp BRIDGE [1|0] STP on/off" \ + ) \ + +#define bunzip2_trivial_usage \ + "[OPTION]... [FILE]" +#define bunzip2_full_usage "\n\n" \ + "Uncompress FILE (or standard input if FILE is '-' or omitted)\n" \ + "\nOptions:" \ + "\n -c Write to standard output" \ + "\n -f Force" \ + +#define bzip2_trivial_usage \ + "[OPTION]... [FILE]..." +#define bzip2_full_usage "\n\n" \ + "Compress FILE(s) with bzip2 algorithm.\n" \ + "When FILE is '-' or unspecified, reads standard input. Implies -c.\n" \ + "\nOptions:" \ + "\n -c Write to standard output" \ + "\n -d Decompress" \ + "\n -f Force" \ + "\n -1..-9 Compression level" \ + +#define busybox_notes_usage \ + "Hello world!\n" + +#define bzcat_trivial_usage \ + "FILE" +#define bzcat_full_usage "\n\n" \ + "Uncompress to stdout" + +#define unlzma_trivial_usage \ + "[OPTION]... [FILE]" +#define unlzma_full_usage "\n\n" \ + "Uncompress FILE (or standard input if FILE is '-' or omitted)\n" \ + "\nOptions:" \ + "\n -c Write to standard output" \ + "\n -f Force" \ + +#define lzmacat_trivial_usage \ + "FILE" +#define lzmacat_full_usage "\n\n" \ + "Uncompress to stdout" + +#define cal_trivial_usage \ + "[-jy] [[month] year]" +#define cal_full_usage "\n\n" \ + "Display a calendar\n" \ + "\nOptions:" \ + "\n -j Use julian dates" \ + "\n -y Display the entire year" \ + +#define cat_trivial_usage \ + "[-u] [FILE]..." +#define cat_full_usage "\n\n" \ + "Concatenate FILE(s) and print them to stdout\n" \ + "\nOptions:" \ + "\n -u Use unbuffered i/o (ignored)" \ + +#define cat_example_usage \ + "$ cat /proc/uptime\n" \ + "110716.72 17.67" + +#define catv_trivial_usage \ + "[-etv] [FILE]..." +#define catv_full_usage "\n\n" \ + "Display nonprinting characters as ^x or M-x\n" \ + "\nOptions:" \ + "\n -e End each line with $" \ + "\n -t Show tabs as ^I" \ + "\n -v Don't use ^x or M-x escapes" \ + +#define chat_trivial_usage \ + "EXPECT [SEND [EXPECT [SEND...]]]" +#define chat_full_usage "\n\n" \ + "Useful for interacting with a modem connected to stdin/stdout.\n" \ + "A script consists of one or more \"expect-send\" pairs of strings,\n" \ + "each pair is a pair of arguments. Example:\n" \ + "chat '' ATZ OK ATD123456 CONNECT '' ogin: pppuser word: ppppass '~'" \ + +#define chattr_trivial_usage \ + "[-R] [-+=AacDdijsStTu] [-v version] files..." +#define chattr_full_usage "\n\n" \ + "Change file attributes on an ext2 fs\n" \ + "\nModifiers:" \ + "\n - Remove attributes" \ + "\n + Add attributes" \ + "\n = Set attributes" \ + "\nAttributes:" \ + "\n A Don't track atime" \ + "\n a Append mode only" \ + "\n c Enable compress" \ + "\n D Write dir contents synchronously" \ + "\n d Do not backup with dump" \ + "\n i Cannot be modified (immutable)" \ + "\n j Write all data to journal first" \ + "\n s Zero disk storage when deleted" \ + "\n S Write file contents synchronously" \ + "\n t Disable tail-merging of partial blocks with other files" \ + "\n u Allow file to be undeleted" \ + "\nOptions:" \ + "\n -R Recursively list subdirectories" \ + "\n -v Set the file's version/generation number" \ + +#define chcon_trivial_usage \ + "[OPTIONS] CONTEXT FILE..." \ + "\n chcon [OPTIONS] [-u USER] [-r ROLE] [-l RANGE] [-t TYPE] FILE..." \ + USE_FEATURE_CHCON_LONG_OPTIONS( \ + "\n chcon [OPTIONS] --reference=RFILE FILE..." \ + ) +#define chcon_full_usage "\n\n" \ + "Change the security context of each FILE to CONTEXT\n" \ + USE_FEATURE_CHCON_LONG_OPTIONS( \ + "\n -v,--verbose Verbose" \ + "\n -c,--changes Report changes made" \ + "\n -h,--no-dereference Affect symlinks instead of their targets" \ + "\n -f,--silent,--quiet Suppress most error messages" \ + "\n --reference=RFILE Use RFILE's group instead of using a CONTEXT value" \ + "\n -u,--user=USER Set user/role/type/range in the target" \ + "\n -r,--role=ROLE security context" \ + "\n -t,--type=TYPE" \ + "\n -l,--range=RANGE" \ + "\n -R,--recursive Recurse subdirectories" \ + ) \ + SKIP_FEATURE_CHCON_LONG_OPTIONS( \ + "\n -v Verbose" \ + "\n -c Report changes made" \ + "\n -h Affect symlinks instead of their targets" \ + "\n -f Suppress most error messages" \ + "\n -u USER Set user/role/type/range in the target security context" \ + "\n -r ROLE" \ + "\n -t TYPE" \ + "\n -l RNG" \ + "\n -R Recurse subdirectories" \ + ) + +#define chmod_trivial_usage \ + "[-R"USE_DESKTOP("cvf")"] MODE[,MODE]... FILE..." +#define chmod_full_usage "\n\n" \ + "Each MODE is one or more of the letters ugoa, one of the\n" \ + "symbols +-= and one or more of the letters rwxst\n" \ + "\nOptions:" \ + "\n -R Recurse directories" \ + USE_DESKTOP( \ + "\n -c List changed files" \ + "\n -v List all files" \ + "\n -f Hide errors" \ + ) +#define chmod_example_usage \ + "$ ls -l /tmp/foo\n" \ + "-rw-rw-r-- 1 root root 0 Apr 12 18:25 /tmp/foo\n" \ + "$ chmod u+x /tmp/foo\n" \ + "$ ls -l /tmp/foo\n" \ + "-rwxrw-r-- 1 root root 0 Apr 12 18:25 /tmp/foo*\n" \ + "$ chmod 444 /tmp/foo\n" \ + "$ ls -l /tmp/foo\n" \ + "-r--r--r-- 1 root root 0 Apr 12 18:25 /tmp/foo\n" + +#define chgrp_trivial_usage \ + "[-RhLHP"USE_DESKTOP("cvf")"]... GROUP FILE..." +#define chgrp_full_usage "\n\n" \ + "Change the group membership of each FILE to GROUP\n" \ + "\nOptions:" \ + "\n -R Recurse directories" \ + "\n -h Affect symlinks instead of symlink targets" \ + "\n -L Traverse all symlinks to directories" \ + "\n -H Traverse symlinks on command line only" \ + "\n -P Do not traverse symlinks (default)" \ + USE_DESKTOP( \ + "\n -c List changed files" \ + "\n -v Verbose" \ + "\n -f Hide errors" \ + ) +#define chgrp_example_usage \ + "$ ls -l /tmp/foo\n" \ + "-r--r--r-- 1 andersen andersen 0 Apr 12 18:25 /tmp/foo\n" \ + "$ chgrp root /tmp/foo\n" \ + "$ ls -l /tmp/foo\n" \ + "-r--r--r-- 1 andersen root 0 Apr 12 18:25 /tmp/foo\n" + +#define chown_trivial_usage \ + "[-RhLHP"USE_DESKTOP("cvf")"]... OWNER[<.|:>[GROUP]] FILE..." +#define chown_full_usage "\n\n" \ + "Change the owner and/or group of each FILE to OWNER and/or GROUP\n" \ + "\nOptions:" \ + "\n -R Recurse directories" \ + "\n -h Affect symlinks instead of symlink targets" \ + "\n -L Traverse all symlinks to directories" \ + "\n -H Traverse symlinks on command line only" \ + "\n -P Do not traverse symlinks (default)" \ + USE_DESKTOP( \ + "\n -c List changed files" \ + "\n -v List all files" \ + "\n -f Hide errors" \ + ) +#define chown_example_usage \ + "$ ls -l /tmp/foo\n" \ + "-r--r--r-- 1 andersen andersen 0 Apr 12 18:25 /tmp/foo\n" \ + "$ chown root /tmp/foo\n" \ + "$ ls -l /tmp/foo\n" \ + "-r--r--r-- 1 root andersen 0 Apr 12 18:25 /tmp/foo\n" \ + "$ chown root.root /tmp/foo\n" \ + "ls -l /tmp/foo\n" \ + "-r--r--r-- 1 root root 0 Apr 12 18:25 /tmp/foo\n" + +#define chpst_trivial_usage \ + "[-vP012] [-u USER[:GRP]] [-U USER[:GRP]] [-e DIR]\n" \ + " [-/ DIR] [-n NICE] [-m BYTES] [-d BYTES] [-o N]\n" \ + " [-p N] [-f BYTES] [-c BYTES] PROG ARGS" +#define chpst_full_usage "\n\n" \ + "Change the process state and run PROG\n" \ + "\nOptions:" \ + "\n -u USER[:GRP] Set uid and gid" \ + "\n -U USER[:GRP] Set $UID and $GID in environment" \ + "\n -e DIR Set environment variables as specified by files" \ + "\n in DIR: file=1st_line_of_file" \ + "\n -/ DIR Chroot to DIR" \ + "\n -n NICE Add NICE to nice value" \ + "\n -m BYTES Same as -d BYTES -s BYTES -l BYTES" \ + "\n -d BYTES Limit data segment" \ + "\n -o N Limit number of open files per process" \ + "\n -p N Limit number of processes per uid" \ + "\n -f BYTES Limit output file sizes" \ + "\n -c BYTES Limit core file size" \ + "\n -v Verbose" \ + "\n -P Create new process group" \ + "\n -0 Close standard input" \ + "\n -1 Close standard output" \ + "\n -2 Close standard error" \ + +#define setuidgid_trivial_usage \ + "account prog args" +#define setuidgid_full_usage "\n\n" \ + "Set uid and gid to account's uid and gid, removing all supplementary\n" \ + "groups and run PROG" +#define envuidgid_trivial_usage \ + "account prog args" +#define envuidgid_full_usage "\n\n" \ + "Set $UID to account's uid and $GID to account's gid and run PROG" +#define envdir_trivial_usage \ + "dir prog args" +#define envdir_full_usage "\n\n" \ + "Set various environment variables as specified by files\n" \ + "in the directory dir and run PROG" +#define softlimit_trivial_usage \ + "[-a BYTES] [-m BYTES] [-d BYTES] [-s BYTES] [-l BYTES]\n" \ + " [-f BYTES] [-c BYTES] [-r BYTES] [-o N] [-p N] [-t N]\n" \ + " PROG ARGS" +#define softlimit_full_usage "\n\n" \ + "Set soft resource limits, then run PROG\n" \ + "\nOptions:" \ + "\n -a BYTES Limit total size of all segments" \ + "\n -m BYTES Same as -d BYTES -s BYTES -l BYTES -a BYTES" \ + "\n -d BYTES Limit data segment" \ + "\n -s BYTES Limit stack segment" \ + "\n -l BYTES Limit locked memory size" \ + "\n -o N Limit number of open files per process" \ + "\n -p N Limit number of processes per uid" \ + "\nOptions controlling file sizes:" \ + "\n -f BYTES Limit output file sizes" \ + "\n -c BYTES Limit core file size" \ + "\nEfficiency opts:" \ + "\n -r BYTES Limit resident set size" \ + "\n -t N Limit CPU time, process receives" \ + "\n a SIGXCPU after N seconds" \ + +#define chroot_trivial_usage \ + "NEWROOT [COMMAND...]" +#define chroot_full_usage "\n\n" \ + "Run COMMAND with root directory set to NEWROOT" +#define chroot_example_usage \ + "$ ls -l /bin/ls\n" \ + "lrwxrwxrwx 1 root root 12 Apr 13 00:46 /bin/ls -> /BusyBox\n" \ + "# mount /dev/hdc1 /mnt -t minix\n" \ + "# chroot /mnt\n" \ + "# ls -l /bin/ls\n" \ + "-rwxr-xr-x 1 root root 40816 Feb 5 07:45 /bin/ls*\n" + +#define chvt_trivial_usage \ + "N" +#define chvt_full_usage "\n\n" \ + "Change the foreground virtual terminal to /dev/ttyN" + +#define cksum_trivial_usage \ + "FILES..." +#define cksum_full_usage "\n\n" \ + "Calculate the CRC32 checksums of FILES" + +#define clear_trivial_usage \ + "" +#define clear_full_usage "\n\n" \ + "Clear screen" + +#define cmp_trivial_usage \ + "[-l] [-s] FILE1 [FILE2" USE_DESKTOP(" [SKIP1 [SKIP2]") "]]" +#define cmp_full_usage "\n\n" \ + "Compares FILE1 vs stdin if FILE2 is not specified\n" \ + "\nOptions:" \ + "\n -l Write the byte numbers (decimal) and values (octal)" \ + "\n for all differing bytes" \ + "\n -s Quiet" \ + +#define comm_trivial_usage \ + "[-123] FILE1 FILE2" +#define comm_full_usage "\n\n" \ + "Compare FILE1 to FILE2, or to stdin if - is specified\n" \ + "\nOptions:" \ + "\n -1 Suppress lines unique to FILE1" \ + "\n -2 Suppress lines unique to FILE2" \ + "\n -3 Suppress lines common to both files" \ + +#define bbconfig_trivial_usage \ + "" +#define bbconfig_full_usage "\n\n" \ + "Print the config file which built busybox" + +#define bbsh_trivial_usage \ + "[FILE]...\n" \ + "or: bbsh -c command [args]..." +#define bbsh_full_usage "\n\n" \ + "The bbsh shell (command interpreter)" + +#define chrt_trivial_usage \ + "[OPTION]... [prio] [pid | command [arg]...]" +#define chrt_full_usage "\n\n" \ + "Manipulate real-time attributes of a process\n" \ + "\nOptions:" \ + "\n -p Operate on pid" \ + "\n -r Set scheduling policy to SCHED_RR" \ + "\n -f Set scheduling policy to SCHED_FIFO" \ + "\n -o Set scheduling policy to SCHED_OTHER" \ + "\n -m Show min and max priorities" \ + +#define chrt_example_usage \ + "$ chrt -r 4 sleep 900; x=$!\n" \ + "$ chrt -f -p 3 $x\n" \ + "You need CAP_SYS_NICE privileges to set scheduling attributes of a process" + +#define cp_trivial_usage \ + "[OPTION]... SOURCE DEST" +#define cp_full_usage "\n\n" \ + "Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY\n" \ + "\nOptions:" \ + "\n -a Same as -dpR" \ + USE_SELINUX( \ + "\n -c Preserve security context" \ + ) \ + "\n -d,-P Preserve links" \ + "\n -H,-L Dereference all symlinks (default)" \ + "\n -p Preserve file attributes if possible" \ + "\n -f Force overwrite" \ + "\n -i Prompt before overwrite" \ + "\n -R,-r Recurse directories" \ + "\n -l,-s Create (sym)links" \ + +#define cpio_trivial_usage \ + "-[dim" USE_FEATURE_CPIO_O("o") "tuv][F cpiofile]" \ + USE_FEATURE_CPIO_O( "[H newc]" ) +#define cpio_full_usage "\n\n" \ + "Extract or list files from a cpio archive" \ + USE_FEATURE_CPIO_O( ", or create a cpio archive" ) \ + "\n" \ + "Main operation mode:" \ + "\n d Make leading directories" \ + "\n i Extract" \ + "\n m Preserve mtime" \ + USE_FEATURE_CPIO_O( \ + "\n o Create" \ + "\n H newc Define format" \ + ) \ + "\n t List" \ + "\n v Verbose" \ + "\n u Unconditional overwrite" \ + "\n F Input from file" \ + +#define crond_trivial_usage \ + "-fbS -l N " USE_FEATURE_CROND_D("-d N ") "-L LOGFILE -c DIR" +#define crond_full_usage "\n\n" \ + " -f Foreground" \ + "\n -b Background (default)" \ + "\n -S Log to syslog (default)" \ + "\n -l Set log level. 0 is the most verbose, default 8" \ + USE_FEATURE_CROND_D( \ + "\n -d Set log level, log to stderr" \ + ) \ + "\n -L Log to file" \ + "\n -c Working dir" \ + +#define crontab_trivial_usage \ + "[-c DIR] [-u USER] [-ler]|[FILE]" +#define crontab_full_usage "\n\n" \ + " -c Crontab directory" \ + "\n -u User" \ + "\n -l List crontab" \ + "\n -e Edit crontab" \ + "\n -r Delete crontab" \ + "\n FILE Replace crontab by FILE ('-': stdin)" \ + +#define cryptpw_trivial_usage \ + "[-a des|md5] [string]" +#define cryptpw_full_usage "\n\n" \ + "Output crypted string.\n" \ + "If string isn't supplied on cmdline, read it from stdin.\n" \ + "\nOptions:" \ + "\n -a Algorithm to use (default: md5)" \ + +#define cttyhack_trivial_usage NOUSAGE_STR +#define cttyhack_full_usage "" + +#define cut_trivial_usage \ + "[OPTION]... [FILE]..." +#define cut_full_usage "\n\n" \ + "Print selected fields from each input FILE to standard output\n" \ + "\nOptions:" \ + "\n -b LIST Output only bytes from LIST" \ + "\n -c LIST Output only characters from LIST" \ + "\n -d CHAR Use CHAR instead of tab as the field delimiter" \ + "\n -s Output only the lines containing delimiter" \ + "\n -f N Print only these fields" \ + "\n -n Ignored" \ + +#define cut_example_usage \ + "$ echo \"Hello world\" | cut -f 1 -d ' '\n" \ + "Hello\n" \ + "$ echo \"Hello world\" | cut -f 2 -d ' '\n" \ + "world\n" + +#define date_trivial_usage \ + "[OPTION]... [+FMT] [TIME]" +#define date_full_usage "\n\n" \ + "Display time (using +FMT), or set time\n" \ + "\nOptions:" \ + "\n -u Work in UTC (don't convert to local time)" \ + "\n -R Output RFC-822 compliant date string" \ + USE_FEATURE_DATE_ISOFMT( \ + "\n -I[SPEC] Output ISO-8601 compliant date string" \ + "\n SPEC='date' (default) for date only," \ + "\n 'hours', 'minutes', or 'seconds' for date and" \ + "\n time to the indicated precision" \ + ) \ + "\n -d TIME Display TIME, not 'now'" \ + "\n -r FILE Display last modification time of FILE" \ + "\n [-s] TIME Set time to TIME" \ + USE_FEATURE_DATE_ISOFMT( \ + "\n -D FMT Use FMT for str->date conversion" \ + ) \ + "\n" \ + "\nRecognized formats for TIME:" \ + "\n hh:mm[:ss]" \ + "\n [YYYY.]MM.DD-hh:mm[:ss]" \ + "\n YYYY-MM-DD hh:mm[:ss]" \ + "\n MMDDhhmm[[YY]YY][.ss]" \ + +#define date_example_usage \ + "$ date\n" \ + "Wed Apr 12 18:52:41 MDT 2000\n" + +#define dc_trivial_usage \ + "expression..." +#define dc_full_usage "\n\n" \ + "Tiny RPN calculator. Operations:\n" \ + "+, add, -, sub, *, mul, /, div, %, mod, **, exp, and, or, not, eor,\n" \ + "p - print top of the stack (without altering the stack),\n" \ + "f - print entire stack, o - pop the value and set output radix\n" \ + "(value must be 10 or 16).\n" \ + "Examples: 'dc 2 2 add' -> 4, 'dc 8 8 * 2 2 + /' -> 16.\n" \ + +#define dc_example_usage \ + "$ dc 2 2 + p\n" \ + "4\n" \ + "$ dc 8 8 \\* 2 2 + / p\n" \ + "16\n" \ + "$ dc 0 1 and p\n" \ + "0\n" \ + "$ dc 0 1 or p\n" \ + "1\n" \ + "$ echo 72 9 div 8 mul p | dc\n" \ + "64\n" + +#define dd_trivial_usage \ + "[if=FILE] [of=FILE] " USE_FEATURE_DD_IBS_OBS("[ibs=N] [obs=N] ") "[bs=N] [count=N] [skip=N]\n" \ + " [seek=N]" USE_FEATURE_DD_IBS_OBS(" [conv=notrunc|noerror|sync|fsync]") +#define dd_full_usage "\n\n" \ + "Copy a file with converting and formatting\n" \ + "\nOptions:" \ + "\n if=FILE Read from FILE instead of stdin" \ + "\n of=FILE Write to FILE instead of stdout" \ + "\n bs=N Read and write N bytes at a time" \ + USE_FEATURE_DD_IBS_OBS( \ + "\n ibs=N Read N bytes at a time" \ + ) \ + USE_FEATURE_DD_IBS_OBS( \ + "\n obs=N Write N bytes at a time" \ + ) \ + "\n count=N Copy only N input blocks" \ + "\n skip=N Skip N input blocks" \ + "\n seek=N Skip N output blocks" \ + USE_FEATURE_DD_IBS_OBS( \ + "\n conv=notrunc Don't truncate output file" \ + "\n conv=noerror Continue after read errors" \ + "\n conv=sync Pad blocks with zeros" \ + "\n conv=fsync Physically write data out before finishing" \ + ) \ + "\n" \ + "\nNumbers may be suffixed by c (x1), w (x2), b (x512), kD (x1000), k (x1024)," \ + "\nMD (x1000000), M (x1048576), GD (x1000000000) or G (x1073741824)" \ + +#define dd_example_usage \ + "$ dd if=/dev/zero of=/dev/ram1 bs=1M count=4\n" \ + "4+0 records in\n" \ + "4+0 records out\n" + +#define deallocvt_trivial_usage \ + "[N]" +#define deallocvt_full_usage "\n\n" \ + "Deallocate unused virtual terminal /dev/ttyN" + +#define delgroup_trivial_usage \ + USE_FEATURE_DEL_USER_FROM_GROUP("[USER] ")"GROUP" +#define delgroup_full_usage "\n\n" \ + "Delete group GROUP from the system" \ + USE_FEATURE_DEL_USER_FROM_GROUP(" or user USER from group GROUP") + +#define deluser_trivial_usage \ + "USER" +#define deluser_full_usage "\n\n" \ + "Delete USER from the system" + +#define depmod_trivial_usage NOUSAGE_STR +#define depmod_full_usage "" + +#define devmem_trivial_usage \ + "ADDRESS [WIDTH [VALUE]]" + +#define devmem_full_usage "\n\n" \ + "Read/write from physical address\n" \ + "\n ADDRESS Address to act upon" \ + "\n WIDTH Width (8/16/...)" \ + "\n VALUE Data to be written" \ + +#define devfsd_trivial_usage \ + "mntpnt [-v]" USE_DEVFSD_FG_NP("[-fg][-np]") +#define devfsd_full_usage "\n\n" \ + "Manage devfs permissions and old device name symlinks\n" \ + "\nOptions:" \ + "\n mntpnt The mount point where devfs is mounted" \ + "\n -v Print the protocol version numbers for devfsd" \ + "\n and the kernel-side protocol version and exit" \ + USE_DEVFSD_FG_NP( \ + "\n -fg Run in foreground" \ + "\n -np Exit after parsing the configuration file" \ + "\n and processing synthetic REGISTER events," \ + "\n do not poll for events" \ + ) + +#define df_trivial_usage \ + "[-Pk" \ + USE_FEATURE_HUMAN_READABLE("mh") \ + USE_FEATURE_DF_FANCY("ai] [-B SIZE") \ + "] [FILESYSTEM...]" +#define df_full_usage "\n\n" \ + "Print filesystem usage statistics\n" \ + "\nOptions:" \ + "\n -P POSIX output format" \ + "\n -k 1024-byte blocks (default)" \ + USE_FEATURE_HUMAN_READABLE( \ + "\n -m 1M-byte blocks" \ + "\n -h Human readable (e.g. 1K 243M 2G)" \ + ) \ + USE_FEATURE_DF_FANCY( \ + "\n -a Show all filesystems" \ + "\n -i Inodes" \ + "\n -B SIZE Blocksize" \ + ) \ + +#define df_example_usage \ + "$ df\n" \ + "Filesystem 1K-blocks Used Available Use% Mounted on\n" \ + "/dev/sda3 8690864 8553540 137324 98% /\n" \ + "/dev/sda1 64216 36364 27852 57% /boot\n" \ + "$ df /dev/sda3\n" \ + "Filesystem 1K-blocks Used Available Use% Mounted on\n" \ + "/dev/sda3 8690864 8553540 137324 98% /\n" \ + "$ POSIXLY_CORRECT=sure df /dev/sda3\n" \ + "Filesystem 512B-blocks Used Available Use% Mounted on\n" \ + "/dev/sda3 17381728 17107080 274648 98% /\n" \ + "$ POSIXLY_CORRECT=yep df -P /dev/sda3\n" \ + "Filesystem 512-blocks Used Available Capacity Mounted on\n" \ + "/dev/sda3 17381728 17107080 274648 98% /\n" + +#define dhcprelay_trivial_usage \ + "[client1,client2,...] [server_device]" +#define dhcprelay_full_usage "\n\n" \ + "Relay dhcp requests from client devices to server device.\n" \ + "Pass clients as CSV" + +#define diff_trivial_usage \ + "[-abdiNqrTstw] [-L LABEL] [-S FILE] [-U LINES] FILE1 FILE2" +#define diff_full_usage "\n\n" \ + "Compare files line by line and output the differences between them.\n" \ + "This implementation supports unified diffs only.\n" \ + "\nOptions:" \ + "\n -a Treat all files as text" \ + "\n -b Ignore changes in the amount of whitespace" \ + "\n -d Try hard to find a smaller set of changes" \ + "\n -i Ignore case differences" \ + "\n -L Use LABEL instead of the filename in the unified header" \ + "\n -N Treat absent files as empty" \ + "\n -q Output only whether files differ" \ + "\n -r Recursively compare subdirectories" \ + "\n -S Start with FILE when comparing directories" \ + "\n -T Make tabs line up by prefixing a tab when necessary" \ + "\n -s Report when two files are the same" \ + "\n -t Expand tabs to spaces in output" \ + "\n -U Output LINES lines of context" \ + "\n -w Ignore all whitespace" \ + +#define dirname_trivial_usage \ + "FILENAME" +#define dirname_full_usage "\n\n" \ + "Strip non-directory suffix from FILENAME" +#define dirname_example_usage \ + "$ dirname /tmp/foo\n" \ + "/tmp\n" \ + "$ dirname /tmp/foo/\n" \ + "/tmp\n" + +#define dmesg_trivial_usage \ + "[-c] [-n LEVEL] [-s SIZE]" +#define dmesg_full_usage "\n\n" \ + "Print or control the kernel ring buffer\n" \ + "\nOptions:" \ + "\n -c Clear ring buffer after printing" \ + "\n -n LEVEL Set console logging level" \ + "\n -s SIZE Buffer size" \ + +#define dnsd_trivial_usage \ + "[-c config] [-t seconds] [-p port] [-i iface-ip] [-d]" +#define dnsd_full_usage "\n\n" \ + "Small static DNS server daemon\n" \ + "\nOptions:" \ + "\n -c Config filename" \ + "\n -t TTL in seconds" \ + "\n -p Listening port" \ + "\n -i Listening ip (default all)" \ + "\n -d Daemonize" \ + +#define dos2unix_trivial_usage \ + "[option] [FILE]" +#define dos2unix_full_usage "\n\n" \ + "Convert FILE from dos to unix format.\n" \ + "When no file is given, use stdin/stdout.\n" \ + "\nOptions:" \ + "\n -u dos2unix" \ + "\n -d unix2dos" \ + +#define dpkg_trivial_usage \ + "[-ilCPru] [-F option] package_name" +#define dpkg_full_usage "\n\n" \ + "Install, remove and manage Debian packages\n" \ + "\nOptions:" \ + "\n -i Install the package" \ + "\n -l List of installed packages" \ + "\n -C Configure an unpackaged package" \ + "\n -F depends Ignore dependency problems" \ + "\n -P Purge all files of a package" \ + "\n -r Remove all but the configuration files for a package" \ + "\n -u Unpack a package, but don't configure it" \ + +#define dpkg_deb_trivial_usage \ + "[-cefxX] FILE [argument]" +#define dpkg_deb_full_usage "\n\n" \ + "Perform actions on Debian packages (.debs)\n" \ + "\nOptions:" \ + "\n -c List contents of filesystem tree" \ + "\n -e Extract control files to [argument] directory" \ + "\n -f Display control field name starting with [argument]" \ + "\n -x Extract packages filesystem tree to directory" \ + "\n -X Verbose extract" \ + +#define dpkg_deb_example_usage \ + "$ dpkg-deb -X ./busybox_0.48-1_i386.deb /tmp\n" + +#define du_trivial_usage \ + "[-aHLdclsx" USE_FEATURE_HUMAN_READABLE("hm") "k] [FILE]..." +#define du_full_usage "\n\n" \ + "Summarize disk space used for each FILE and/or directory.\n" \ + "Disk space is printed in units of " \ + USE_FEATURE_DU_DEFAULT_BLOCKSIZE_1K("1024") \ + SKIP_FEATURE_DU_DEFAULT_BLOCKSIZE_1K("512") \ + " bytes.\n" \ + "\nOptions:" \ + "\n -a Show file sizes too" \ + "\n -H Follow symlinks on command line" \ + "\n -L Follow all symlinks" \ + "\n -d N Limit output to directories (and files with -a) of depth < N" \ + "\n -c Show grand total" \ + "\n -l Count sizes many times if hard linked" \ + "\n -s Display only a total for each argument" \ + "\n -x Skip directories on different filesystems" \ + USE_FEATURE_HUMAN_READABLE( \ + "\n -h Sizes in human readable format (e.g., 1K 243M 2G )" \ + "\n -m Sizes in megabytes" \ + ) \ + "\n -k Sizes in kilobytes" \ + USE_FEATURE_DU_DEFAULT_BLOCKSIZE_1K(" (default)") \ + +#define du_example_usage \ + "$ du\n" \ + "16 ./CVS\n" \ + "12 ./kernel-patches/CVS\n" \ + "80 ./kernel-patches\n" \ + "12 ./tests/CVS\n" \ + "36 ./tests\n" \ + "12 ./scripts/CVS\n" \ + "16 ./scripts\n" \ + "12 ./docs/CVS\n" \ + "104 ./docs\n" \ + "2417 .\n" + +#define dumpkmap_trivial_usage \ + "> keymap" +#define dumpkmap_full_usage "\n\n" \ + "Print a binary keyboard translation table to standard output" +#define dumpkmap_example_usage \ + "$ dumpkmap > keymap\n" + +#define dumpleases_trivial_usage \ + "[-r|-a] [-f LEASEFILE]" +#define dumpleases_full_usage "\n\n" \ + "Display DHCP leases granted by udhcpd\n" \ + "\nOptions:" \ + USE_GETOPT_LONG( \ + "\n -f,--file=FILE Leases file to load" \ + "\n -r,--remaining Interpret lease times as time remaining" \ + "\n -a,--absolute Interpret lease times as expire time" \ + ) \ + SKIP_GETOPT_LONG( \ + "\n -f FILE Leases file to load" \ + "\n -r Interpret lease times as time remaining" \ + "\n -a Interpret lease times as expire time" \ + ) + +#define e2fsck_trivial_usage \ + "[-panyrcdfvstDFSV] [-b superblock] [-B blocksize] " \ + "[-I inode_buffer_blocks] [-P process_inode_size] " \ + "[-l|-L bad_blocks_file] [-C fd] [-j external_journal] " \ + "[-E extended-options] device" +#define e2fsck_full_usage "\n\n" \ + "Check ext2/ext3 file system\n" \ + "\nOptions:" \ + "\n -p Automatic repair (no questions)" \ + "\n -n Make no changes to the filesystem" \ + "\n -y Assume 'yes' to all questions" \ + "\n -c Check for bad blocks and add them to the badblock list" \ + "\n -f Force checking even if filesystem is marked clean" \ + "\n -v Verbose" \ + "\n -b superblock Use alternative superblock" \ + "\n -B blocksize Force blocksize when looking for superblock" \ + "\n -j journal Set location of the external journal" \ + "\n -l file Add to badblocks list" \ + "\n -L file Set badblocks list" \ + +#define echo_trivial_usage \ + USE_FEATURE_FANCY_ECHO("[-neE] ") "[ARG...]" +#define echo_full_usage "\n\n" \ + "Print the specified ARGs to stdout" \ + USE_FEATURE_FANCY_ECHO( "\n" \ + "\nOptions:" \ + "\n -n Suppress trailing newline" \ + "\n -e Interpret backslash-escaped characters (i.e., \\t=tab)" \ + "\n -E Disable interpretation of backslash-escaped characters" \ + ) +#define echo_example_usage \ + "$ echo \"Erik is cool\"\n" \ + "Erik is cool\n" \ + USE_FEATURE_FANCY_ECHO("$ echo -e \"Erik\\nis\\ncool\"\n" \ + "Erik\n" \ + "is\n" \ + "cool\n" \ + "$ echo \"Erik\\nis\\ncool\"\n" \ + "Erik\\nis\\ncool\n") + +#define eject_trivial_usage \ + "[-t] [-T] [DEVICE]" +#define eject_full_usage "\n\n" \ + "Eject specified DEVICE (or default /dev/cdrom)\n" \ + "\nOptions:" \ + USE_FEATURE_EJECT_SCSI( \ + "\n -s SCSI device" \ + ) \ + "\n -t Close tray" \ + "\n -T Open/close tray (toggle)" \ + +#define ed_trivial_usage "" +#define ed_full_usage "" + +#define env_trivial_usage \ + "[-iu] [-] [name=value]... [command]" +#define env_full_usage "\n\n" \ + "Print the current environment or run a program after setting\n" \ + "up the specified environment\n" \ + "\nOptions:" \ + "\n -, -i Start with an empty environment" \ + "\n -u Remove variable from the environment" \ + +#define ether_wake_trivial_usage \ + "[-b] [-i iface] [-p aa:bb:cc:dd[:ee:ff]] MAC" +#define ether_wake_full_usage "\n\n" \ + "Send a magic packet to wake up sleeping machines.\n" \ + "MAC must be a station address (00:11:22:33:44:55) or\n" \ + "a hostname with a known 'ethers' entry.\n" \ + "\nOptions:" \ + "\n -b Send wake-up packet to the broadcast address" \ + "\n -i iface Interface to use (default eth0)" \ + "\n -p pass Append four or six byte password PW to the packet" \ + +#define expand_trivial_usage \ + "[-i] [-t NUM] [FILE|-]" +#define expand_full_usage "\n\n" \ + "Convert tabs to spaces, writing to standard output.\n" \ + "\nOptions:" \ + USE_FEATURE_EXPAND_LONG_OPTIONS( \ + "\n -i,--initial Do not convert tabs after non blanks" \ + "\n -t,--tabs=N Tabstops every N chars" \ + ) \ + SKIP_FEATURE_EXPAND_LONG_OPTIONS( \ + "\n -i Do not convert tabs after non blanks" \ + "\n -t Tabstops every N chars" \ + ) + +#define expr_trivial_usage \ + "EXPRESSION" +#define expr_full_usage "\n\n" \ + "Print the value of EXPRESSION to standard output.\n" \ + "\n" \ + "EXPRESSION may be:\n" \ + " ARG1 | ARG2 ARG1 if it is neither null nor 0, otherwise ARG2\n" \ + " ARG1 & ARG2 ARG1 if neither argument is null or 0, otherwise 0\n" \ + " ARG1 < ARG2 1 if ARG1 is less than ARG2, else 0. Similarly:\n" \ + " ARG1 <= ARG2\n" \ + " ARG1 = ARG2\n" \ + " ARG1 != ARG2\n" \ + " ARG1 >= ARG2\n" \ + " ARG1 > ARG2\n" \ + " ARG1 + ARG2 Sum of ARG1 and ARG2. Similarly:\n" \ + " ARG1 - ARG2\n" \ + " ARG1 * ARG2\n" \ + " ARG1 / ARG2\n" \ + " ARG1 % ARG2\n" \ + " STRING : REGEXP Anchored pattern match of REGEXP in STRING\n" \ + " match STRING REGEXP Same as STRING : REGEXP\n" \ + " substr STRING POS LENGTH Substring of STRING, POS counted from 1\n" \ + " index STRING CHARS Index in STRING where any CHARS is found, or 0\n" \ + " length STRING Length of STRING\n" \ + " quote TOKEN Interpret TOKEN as a string, even if\n" \ + " it is a keyword like 'match' or an\n" \ + " operator like '/'\n" \ + " (EXPRESSION) Value of EXPRESSION\n" \ + "\n" \ + "Beware that many operators need to be escaped or quoted for shells.\n" \ + "Comparisons are arithmetic if both ARGs are numbers, else\n" \ + "lexicographical. Pattern matches return the string matched between\n" \ + "\\( and \\) or null; if \\( and \\) are not used, they return the number\n" \ + "of characters matched or 0." + +#define fakeidentd_trivial_usage \ + "[-fiw] [-b ADDR] [STRING]" +#define fakeidentd_full_usage "\n\n" \ + "Provide fake ident (auth) service\n" \ + "\nOptions:" \ + "\n -f Run in foreground" \ + "\n -i Inetd mode" \ + "\n -w Inetd 'wait' mode" \ + "\n -b ADDR Bind to specified address" \ + "\n STRING Ident answer string (default is 'nobody')" \ + +#define false_trivial_usage \ + "" +#define false_full_usage "\n\n" \ + "Return an exit code of FALSE (1)" + +#define false_example_usage \ + "$ false\n" \ + "$ echo $?\n" \ + "1\n" + +#define fbset_trivial_usage \ + "[options] [mode]" +#define fbset_full_usage "\n\n" \ + "Show and modify frame buffer settings" + +#define fbset_example_usage \ + "$ fbset\n" \ + "mode \"1024x768-76\"\n" \ + " # D: 78.653 MHz, H: 59.949 kHz, V: 75.694 Hz\n" \ + " geometry 1024 768 1024 768 16\n" \ + " timings 12714 128 32 16 4 128 4\n" \ + " accel false\n" \ + " rgba 5/11,6/5,5/0,0/0\n" \ + "endmode\n" + +#define fdflush_trivial_usage \ + "DEVICE" +#define fdflush_full_usage "\n\n" \ + "Force floppy disk drive to detect disk change" + +#define fdformat_trivial_usage \ + "[-n] DEVICE" +#define fdformat_full_usage "\n\n" \ + "Format floppy disk\n" \ + "\nOptions:" \ + "\n -n Don't verify after format" \ + +/* Looks like someone forgot to add this to config system */ +#ifndef ENABLE_FEATURE_FDISK_BLKSIZE +# define ENABLE_FEATURE_FDISK_BLKSIZE 0 +# define USE_FEATURE_FDISK_BLKSIZE(a) +#endif + +#define fdisk_trivial_usage \ + "[-ul" USE_FEATURE_FDISK_BLKSIZE("s") "] " \ + "[-C CYLINDERS] [-H HEADS] [-S SECTORS] [-b SSZ] DISK" +#define fdisk_full_usage "\n\n" \ + "Change partition table\n" \ + "\nOptions:" \ + "\n -u Start and End are in sectors (instead of cylinders)" \ + "\n -l Show partition table for each DISK, then exit" \ + USE_FEATURE_FDISK_BLKSIZE( \ + "\n -s Show partition sizes in kb for each DISK, then exit" \ + ) \ + "\n -b 2048 (for certain MO disks) use 2048-byte sectors" \ + "\n -C CYLINDERS Set number of cylinders/heads/sectors" \ + "\n -H HEADS\n" \ + "\n -S SECTORS" \ + +#define blkid_trivial_usage \ + "" +#define blkid_full_usage "\n\n" \ + "Print UUIDs of all filesystems." + +#define findfs_trivial_usage \ + "LABEL=label or UUID=uuid" +#define findfs_full_usage "\n\n" \ + "Find a filesystem device based on a label or UUID." +#define findfs_example_usage \ + "$ findfs LABEL=MyDevice" + +#define find_trivial_usage \ + "[PATH...] [EXPRESSION]" +#define find_full_usage "\n\n" \ + "Search for files. The default PATH is the current directory,\n" \ + "default EXPRESSION is '-print'\n" \ + "\nEXPRESSION may consist of:" \ + "\n -follow Dereference symlinks" \ + USE_FEATURE_FIND_XDEV( \ + "\n -xdev Don't descend directories on other filesystems") \ + USE_FEATURE_FIND_MAXDEPTH( \ + "\n -maxdepth N Descend at most N levels. -maxdepth 0 applies" \ + "\n tests/actions to command line arguments only") \ + "\n -name PATTERN File name (w/o directory name) matches PATTERN" \ + "\n -iname PATTERN Case insensitive -name" \ + USE_FEATURE_FIND_PATH( \ + "\n -path PATTERN Path matches PATTERN") \ + USE_FEATURE_FIND_REGEX( \ + "\n -regex PATTERN Path matches regex PATTERN") \ + USE_FEATURE_FIND_TYPE( \ + "\n -type X File type is X (X is one of: f,d,l,b,c,...)") \ + USE_FEATURE_FIND_PERM( \ + "\n -perm NNN Permissions match any of (+NNN), all of (-NNN)," \ + "\n or exactly (NNN)") \ + USE_FEATURE_FIND_MTIME( \ + "\n -mtime DAYS Modified time is greater than (+N), less than (-N)," \ + "\n or exactly (N) days") \ + USE_FEATURE_FIND_MMIN( \ + "\n -mmin MINS Modified time is greater than (+N), less than (-N)," \ + "\n or exactly (N) minutes") \ + USE_FEATURE_FIND_NEWER( \ + "\n -newer FILE Modified time is more recent than FILE's") \ + USE_FEATURE_FIND_INUM( \ + "\n -inum N File has inode number N") \ + USE_FEATURE_FIND_USER( \ + "\n -user NAME File is owned by user NAME (numeric user ID allowed)") \ + USE_FEATURE_FIND_GROUP( \ + "\n -group NAME File belongs to group NAME (numeric group ID allowed)") \ + USE_FEATURE_FIND_DEPTH( \ + "\n -depth Process directory name after traversing it") \ + USE_FEATURE_FIND_SIZE( \ + "\n -size N[bck] File size is N (c:bytes,k:kbytes,b:512 bytes(def.))." \ + "\n +/-N: file size is bigger/smaller than N") \ + "\n -print Print (default and assumed)" \ + USE_FEATURE_FIND_PRINT0( \ + "\n -print0 Delimit output with null characters rather than" \ + "\n newlines") \ + USE_FEATURE_FIND_CONTEXT ( \ + "\n -context File has specified security context") \ + USE_FEATURE_FIND_EXEC( \ + "\n -exec CMD ARG ; Execute CMD with all instances of {} replaced by the" \ + "\n matching files") \ + USE_FEATURE_FIND_PRUNE( \ + "\n -prune Stop traversing current subtree") \ + USE_FEATURE_FIND_DELETE( \ + "\n -delete Delete files, turns on -depth option") \ + USE_FEATURE_FIND_PAREN( \ + "\n (EXPR) Group an expression") \ + +#define find_example_usage \ + "$ find / -name passwd\n" \ + "/etc/passwd\n" + +#define fold_trivial_usage \ + "[-bs] [-w WIDTH] [FILE]" +#define fold_full_usage "\n\n" \ + "Wrap input lines in each FILE (standard input by default), writing to\n" \ + "standard output\n" \ + "\nOptions:" \ + "\n -b Count bytes rather than columns" \ + "\n -s Break at spaces" \ + "\n -w Use WIDTH columns instead of 80" \ + +#define free_trivial_usage \ + "" +#define free_full_usage "\n\n" \ + "Display the amount of free and used system memory" +#define free_example_usage \ + "$ free\n" \ + " total used free shared buffers\n" \ + " Mem: 257628 248724 8904 59644 93124\n" \ + " Swap: 128516 8404 120112\n" \ + "Total: 386144 257128 129016\n" \ + +#define freeramdisk_trivial_usage \ + "DEVICE" +#define freeramdisk_full_usage "\n\n" \ + "Free all memory used by the specified ramdisk" +#define freeramdisk_example_usage \ + "$ freeramdisk /dev/ram2\n" + +#define fsck_trivial_usage \ + "[-ANPRTV] [-C fd] [-t fstype] [fs-options] [filesys...]" +#define fsck_full_usage "\n\n" \ + "Check and repair filesystems\n" \ + "\nOptions:" \ + "\n -A Walk /etc/fstab and check all filesystems" \ + "\n -N Don't execute, just show what would be done" \ + "\n -P With -A, check filesystems in parallel" \ + "\n -R With -A, skip the root filesystem" \ + "\n -T Don't show title on startup" \ + "\n -V Verbose" \ + "\n -C n Write status information to specified filedescriptor" \ + "\n -t type List of filesystem types to check" \ + +#define fsck_minix_trivial_usage \ + "[-larvsmf] /dev/name" +#define fsck_minix_full_usage "\n\n" \ + "Check MINIX filesystem\n" \ + "\nOptions:" \ + "\n -l List all filenames" \ + "\n -r Perform interactive repairs" \ + "\n -a Perform automatic repairs" \ + "\n -v Verbose" \ + "\n -s Output superblock information" \ + "\n -m Show \"mode not cleared\" warnings" \ + "\n -f Force file system check" \ + +#define ftpget_trivial_usage \ + "[options] remote-host local-file remote-file" +#define ftpget_full_usage "\n\n" \ + "Retrieve a remote file via FTP\n" \ + "\nOptions:" \ + USE_FEATURE_FTPGETPUT_LONG_OPTIONS( \ + "\n -c,--continue Continue previous transfer" \ + "\n -v,--verbose Verbose" \ + "\n -u,--username Username" \ + "\n -p,--password Password" \ + "\n -P,--port Port number" \ + ) \ + SKIP_FEATURE_FTPGETPUT_LONG_OPTIONS( \ + "\n -c Continue previous transfer" \ + "\n -v Verbose" \ + "\n -u Username" \ + "\n -p Password" \ + "\n -P Port number" \ + ) + +#define ftpput_trivial_usage \ + "[options] remote-host remote-file local-file" +#define ftpput_full_usage "\n\n" \ + "Store a local file on a remote machine via FTP\n" \ + "\nOptions:" \ + USE_FEATURE_FTPGETPUT_LONG_OPTIONS( \ + "\n -v,--verbose Verbose" \ + "\n -u,--username Username" \ + "\n -p,--password Password" \ + "\n -P,--port Port number" \ + ) \ + SKIP_FEATURE_FTPGETPUT_LONG_OPTIONS( \ + "\n -v Verbose" \ + "\n -u Username" \ + "\n -p Password" \ + "\n -P Port number" \ + ) + +#define fuser_trivial_usage \ + "[options] FILE or PORT/PROTO" +#define fuser_full_usage "\n\n" \ + "Find processes which use FILEs or PORTs\n" \ + "\nOptions:" \ + "\n -m Find processes which use same fs as FILEs" \ + "\n -4 Search only IPv4 space" \ + "\n -6 Search only IPv6 space" \ + "\n -s Silent: just exit with 0 if any processes are found" \ + "\n -k Kill found processes (otherwise display PIDs)" \ + "\n -SIGNAL Signal to send (default: TERM)" \ + +#define getenforce_trivial_usage NOUSAGE_STR +#define getenforce_full_usage "" + +#define getopt_trivial_usage \ + "[OPTIONS]..." +#define getopt_full_usage "\n\n" \ + "Parse command options\n" \ + USE_GETOPT_LONG( \ + "\n -a,--alternative Allow long options starting with single -" \ + "\n -l,--longoptions=longopts Long options to be recognized" \ + "\n -n,--name=progname The name under which errors are reported" \ + "\n -o,--options=optstring Short options to be recognized" \ + "\n -q,--quiet Disable error reporting by getopt(3)" \ + "\n -Q,--quiet-output No normal output" \ + "\n -s,--shell=shell Set shell quoting conventions" \ + "\n -T,--test Test for getopt(1) version" \ + "\n -u,--unquoted Don't quote the output" \ + ) \ + SKIP_GETOPT_LONG( \ + "\n -a Allow long options starting with single -" \ + "\n -l longopts Long options to be recognized" \ + "\n -n progname The name under which errors are reported" \ + "\n -o optstring Short options to be recognized" \ + "\n -q Disable error reporting by getopt(3)" \ + "\n -Q No normal output" \ + "\n -s shell Set shell quoting conventions" \ + "\n -T Test for getopt(1) version" \ + "\n -u Don't quote the output" \ + ) +#define getopt_example_usage \ + "$ cat getopt.test\n" \ + "#!/bin/sh\n" \ + "GETOPT=`getopt -o ab:c:: --long a-long,b-long:,c-long:: \\\n" \ + " -n 'example.busybox' -- \"$@\"`\n" \ + "if [ $? != 0 ]; then exit 1; fi\n" \ + "eval set -- \"$GETOPT\"\n" \ + "while true; do\n" \ + " case $1 in\n" \ + " -a|--a-long) echo \"Option a\"; shift;;\n" \ + " -b|--b-long) echo \"Option b, argument '$2'\"; shift 2;;\n" \ + " -c|--c-long)\n" \ + " case \"$2\" in\n" \ + " \"\") echo \"Option c, no argument\"; shift 2;;\n" \ + " *) echo \"Option c, argument '$2'\"; shift 2;;\n" \ + " esac;;\n" \ + " --) shift; break;;\n" \ + " *) echo \"Internal error!\"; exit 1;;\n" \ + " esac\n" \ + "done\n" + +#define getsebool_trivial_usage \ + "-a or getsebool boolean..." +#define getsebool_full_usage "\n\n" \ + " -a Show all SELinux booleans" + +#define getty_trivial_usage \ + "[OPTIONS] BAUD_RATE TTY [TERMTYPE]" +#define getty_full_usage "\n\n" \ + "Open a tty, prompt for a login name, then invoke /bin/login\n" \ + "\nOptions:" \ + "\n -h Enable hardware (RTS/CTS) flow control" \ + "\n -i Do not display /etc/issue before running login" \ + "\n -L Local line, do not do carrier detect" \ + "\n -m Get baud rate from modem's CONNECT status message" \ + "\n -w Wait for a CR or LF before sending /etc/issue" \ + "\n -n Do not prompt the user for a login name" \ + "\n -f issue_file Display issue_file instead of /etc/issue" \ + "\n -l login_app Invoke login_app instead of /bin/login" \ + "\n -t timeout Terminate after timeout if no username is read" \ + "\n -I initstring Init string to send before anything else" \ + "\n -H login_host Log login_host into the utmp file as the hostname" \ + +#define grep_trivial_usage \ + "[-HhrilLnqvso" \ + USE_DESKTOP("w") \ + "eF" \ + USE_FEATURE_GREP_EGREP_ALIAS("E") \ + USE_FEATURE_GREP_CONTEXT("ABC") \ + "] PATTERN [FILEs...]" +#define grep_full_usage "\n\n" \ + "Search for PATTERN in each FILE or standard input\n" \ + "\nOptions:" \ + "\n -H Prefix output lines with filename where match was found" \ + "\n -h Suppress the prefixing filename on output" \ + "\n -r Recurse subdirectories" \ + "\n -i Ignore case distinctions" \ + "\n -l List names of files that match" \ + "\n -L List names of files that do not match" \ + "\n -n Print line number with output lines" \ + "\n -q Quiet. Return 0 if PATTERN is found, 1 otherwise" \ + "\n -v Select non-matching lines" \ + "\n -s Suppress file open/read error messages" \ + "\n -c Only print count of matching lines" \ + "\n -o Show only the part of a line that matches PATTERN" \ + "\n -m MAX Match up to MAX times per file" \ + USE_DESKTOP( \ + "\n -w Match whole words only") \ + "\n -F PATTERN is a set of newline-separated strings" \ + USE_FEATURE_GREP_EGREP_ALIAS( \ + "\n -E PATTERN is an extended regular expression") \ + "\n -e PTRN Pattern to match" \ + "\n -f FILE Read pattern from file" \ + USE_FEATURE_GREP_CONTEXT( \ + "\n -A Print NUM lines of trailing context" \ + "\n -B Print NUM lines of leading context" \ + "\n -C Print NUM lines of output context") \ + +#define grep_example_usage \ + "$ grep root /etc/passwd\n" \ + "root:x:0:0:root:/root:/bin/bash\n" \ + "$ grep ^[rR]oo. /etc/passwd\n" \ + "root:x:0:0:root:/root:/bin/bash\n" + +#define egrep_trivial_usage NOUSAGE_STR +#define egrep_full_usage "" + +#define fgrep_trivial_usage NOUSAGE_STR +#define fgrep_full_usage "" + +#define gunzip_trivial_usage \ + "[OPTION]... [FILE]..." +#define gunzip_full_usage "\n\n" \ + "Uncompress FILEs (or standard input)\n" \ + "\nOptions:" \ + "\n -c Write to standard output" \ + "\n -f Force" \ + "\n -t Test file integrity" \ + +#define gunzip_example_usage \ + "$ ls -la /tmp/BusyBox*\n" \ + "-rw-rw-r-- 1 andersen andersen 557009 Apr 11 10:55 /tmp/BusyBox-0.43.tar.gz\n" \ + "$ gunzip /tmp/BusyBox-0.43.tar.gz\n" \ + "$ ls -la /tmp/BusyBox*\n" \ + "-rw-rw-r-- 1 andersen andersen 1761280 Apr 14 17:47 /tmp/BusyBox-0.43.tar\n" + +#define gzip_trivial_usage \ + "[OPTION]... [FILE]..." +#define gzip_full_usage "\n\n" \ + "Compress FILEs (or standard input)\n" \ + "\nOptions:" \ + "\n -c Write to standard output" \ + "\n -d Decompress" \ + "\n -f Force" \ + +#define gzip_example_usage \ + "$ ls -la /tmp/busybox*\n" \ + "-rw-rw-r-- 1 andersen andersen 1761280 Apr 14 17:47 /tmp/busybox.tar\n" \ + "$ gzip /tmp/busybox.tar\n" \ + "$ ls -la /tmp/busybox*\n" \ + "-rw-rw-r-- 1 andersen andersen 554058 Apr 14 17:49 /tmp/busybox.tar.gz\n" + +#define halt_trivial_usage \ + "[-d delay] [-n] [-f]" USE_FEATURE_WTMP(" [-w]") +#define halt_full_usage "\n\n" \ + "Halt the system\n" \ + "\nOptions:" \ + "\n -d Delay interval for halting" \ + "\n -n No call to sync()" \ + "\n -f Force halt (don't go through init)" \ + USE_FEATURE_WTMP( \ + "\n -w Only write a wtmp record" \ + ) + +#define hdparm_trivial_usage \ + "[options] [device] .." +#define hdparm_full_usage "\n\n" \ + "Options:" \ + "\n -a Get/set fs readahead" \ + "\n -A Set drive read-lookahead flag (0/1)" \ + "\n -b Get/set bus state (0 == off, 1 == on, 2 == tristate)" \ + "\n -B Set Advanced Power Management setting (1-255)" \ + "\n -c Get/set IDE 32-bit IO setting" \ + "\n -C Check IDE power mode status" \ + USE_FEATURE_HDPARM_HDIO_GETSET_DMA( \ + "\n -d Get/set using_dma flag") \ + "\n -D Enable/disable drive defect-mgmt" \ + "\n -f Flush buffer cache for device on exit" \ + "\n -g Display drive geometry" \ + "\n -h Display terse usage information" \ + USE_FEATURE_HDPARM_GET_IDENTITY( \ + "\n -i Display drive identification") \ + USE_FEATURE_HDPARM_GET_IDENTITY( \ + "\n -I Detailed/current information directly from drive") \ + "\n -k Get/set keep_settings_over_reset flag (0/1)" \ + "\n -K Set drive keep_features_over_reset flag (0/1)" \ + "\n -L Set drive doorlock (0/1) (removable harddisks only)" \ + "\n -m Get/set multiple sector count" \ + "\n -n Get/set ignore-write-errors flag (0/1)" \ + "\n -p Set PIO mode on IDE interface chipset (0,1,2,3,4,...)" \ + "\n -P Set drive prefetch count" \ +/* "\n -q Change next setting quietly" - not supported ib bbox */ \ + "\n -Q Get/set DMA tagged-queuing depth (if supported)" \ + "\n -r Get/set readonly flag (DANGEROUS to set)" \ + USE_FEATURE_HDPARM_HDIO_SCAN_HWIF( \ + "\n -R Register an IDE interface (DANGEROUS)") \ + "\n -S Set standby (spindown) timeout" \ + "\n -t Perform device read timings" \ + "\n -T Perform cache read timings" \ + "\n -u Get/set unmaskirq flag (0/1)" \ + USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF( \ + "\n -U Un-register an IDE interface (DANGEROUS)") \ + "\n -v Defaults; same as -mcudkrag for IDE drives" \ + "\n -V Display program version and exit immediately" \ + USE_FEATURE_HDPARM_HDIO_DRIVE_RESET( \ + "\n -w Perform device reset (DANGEROUS)") \ + "\n -W Set drive write-caching flag (0/1) (DANGEROUS)" \ + USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF( \ + "\n -x Tristate device for hotswap (0/1) (DANGEROUS)") \ + "\n -X Set IDE xfer mode (DANGEROUS)" \ + "\n -y Put IDE drive in standby mode" \ + "\n -Y Put IDE drive to sleep" \ + "\n -Z Disable Seagate auto-powersaving mode" \ + "\n -z Re-read partition table" \ + +#define head_trivial_usage \ + "[OPTION]... [FILE]..." +#define head_full_usage "\n\n" \ + "Print first 10 lines of each FILE to standard output.\n" \ + "With more than one FILE, precede each with a header giving the\n" \ + "file name. With no FILE, or when FILE is -, read standard input.\n" \ + "\nOptions:" \ + "\n -n NUM Print first NUM lines instead of first 10" \ + USE_FEATURE_FANCY_HEAD( \ + "\n -c NUM Output the first NUM bytes" \ + "\n -q Never output headers giving file names" \ + "\n -v Always output headers giving file names") \ + +#define head_example_usage \ + "$ head -n 2 /etc/passwd\n" \ + "root:x:0:0:root:/root:/bin/bash\n" \ + "daemon:x:1:1:daemon:/usr/sbin:/bin/sh\n" + +#define hexdump_trivial_usage \ + "[-bcCdefnosvx" USE_FEATURE_HEXDUMP_REVERSE("R") "] FILE..." +#define hexdump_full_usage "\n\n" \ + "Display file(s) or standard input in a user specified format\n" \ + "\nOptions:" \ + "\n -b One-byte octal display" \ + "\n -c One-byte character display" \ + "\n -C Canonical hex+ASCII, 16 bytes per line" \ + "\n -d Two-byte decimal display" \ + "\n -e FORMAT STRING" \ + "\n -f FORMAT FILE" \ + "\n -n LENGTH Interpret only LENGTH bytes of input" \ + "\n -o Two-byte octal display" \ + "\n -s OFFSET Skip OFFSET bytes" \ + "\n -v Display all input data" \ + "\n -x Two-byte hexadecimal display" \ + USE_FEATURE_HEXDUMP_REVERSE( \ + "\n -R Reverse of 'hexdump -Cv'") \ + +#define hd_trivial_usage \ + "FILE..." +#define hd_full_usage "\n\n" \ + "hd is an alias for hexdump -C" + +#define hostid_trivial_usage \ + "" +#define hostid_full_usage "\n\n" \ + "Print out a unique 32-bit identifier for the machine" + +#define hostname_trivial_usage \ + "[OPTION] [hostname | -F FILE]" +#define hostname_full_usage "\n\n" \ + "Get or set hostname or DNS domain name\n" \ + "\nOptions:" \ + "\n -s Short" \ + "\n -i Addresses for the hostname" \ + "\n -d DNS domain name" \ + "\n -f Fully qualified domain name" \ + "\n -F FILE Use the contents of FILE to specify the hostname" \ + +#define hostname_example_usage \ + "$ hostname\n" \ + "sage\n" + +#define httpd_trivial_usage \ + "[-c conffile]" \ + " [-p [ip:]port]" \ + " [-i] [-f] [-v[v]]" \ + USE_FEATURE_HTTPD_SETUID(" [-u user[:grp]]") \ + USE_FEATURE_HTTPD_BASIC_AUTH(" [-r realm]") \ + USE_FEATURE_HTTPD_AUTH_MD5(" [-m pass]") \ + " [-h home]" \ + " [-d/-e string]" +#define httpd_full_usage "\n\n" \ + "Listen for incoming HTTP requests\n" \ + "\nOptions:" \ + "\n -c FILE Configuration file (default httpd.conf)" \ + "\n -p [IP:]PORT Bind to ip:port (default *:80)" \ + "\n -i Inetd mode" \ + "\n -f Do not daemonize" \ + "\n -v[v] Verbose" \ + USE_FEATURE_HTTPD_SETUID( \ + "\n -u USER[:GRP] Set uid/gid after binding to port") \ + USE_FEATURE_HTTPD_BASIC_AUTH( \ + "\n -r REALM Authentication Realm for Basic Authentication") \ + USE_FEATURE_HTTPD_AUTH_MD5( \ + "\n -m PASS Crypt PASS with md5 algorithm") \ + "\n -h HOME Home directory (default .)" \ + "\n -e STRING HTML encode STRING" \ + "\n -d STRING URL decode STRING" \ + +#define hwclock_trivial_usage \ + USE_FEATURE_HWCLOCK_LONG_OPTIONS( \ + "[-r|--show] [-s|--hctosys] [-w|--systohc]" \ + " [-l|--localtime] [-u|--utc]" \ + " [-f FILE]" \ + ) \ + SKIP_FEATURE_HWCLOCK_LONG_OPTIONS( \ + "[-r] [-s] [-w] [-l] [-u] [-f FILE]" \ + ) +#define hwclock_full_usage "\n\n" \ + "Query and set hardware clock (RTC)\n" \ + "\nOptions:" \ + "\n -r Show hardware clock time" \ + "\n -s Set system time from hardware clock" \ + "\n -w Set hardware clock to system time" \ + "\n -u Hardware clock is in UTC" \ + "\n -l Hardware clock is in local time" \ + "\n -f FILE Use specified device (e.g. /dev/rtc2)" \ + +#define id_trivial_usage \ + "[OPTIONS]... [USER]" +#define id_full_usage "\n\n" \ + "Print information about USER or the current user\n" \ + "\nOptions:" \ + USE_SELINUX( \ + "\n -Z Print the security context" \ + ) \ + "\n -u Print user ID" \ + "\n -g Print group ID" \ + "\n -G Print supplementary group IDs" \ + "\n -n Print name instead of a number" \ + "\n -r Print real user ID instead of effective ID" \ + +#define id_example_usage \ + "$ id\n" \ + "uid=1000(andersen) gid=1000(andersen)\n" + +#define ifconfig_trivial_usage \ + USE_FEATURE_IFCONFIG_STATUS("[-a]") " interface [address]" +#define ifconfig_full_usage "\n\n" \ + "Configure a network interface\n" \ + "\nOptions:" \ + "\n" \ + USE_FEATURE_IPV6( \ + " [add ADDRESS[/PREFIXLEN]]\n") \ + USE_FEATURE_IPV6( \ + " [del ADDRESS[/PREFIXLEN]]\n") \ + " [[-]broadcast [ADDRESS]] [[-]pointopoint [ADDRESS]]\n" \ + " [netmask ADDRESS] [dstaddr ADDRESS]\n" \ + USE_FEATURE_IFCONFIG_SLIP( \ + " [outfill NN] [keepalive NN]\n") \ + " " USE_FEATURE_IFCONFIG_HW("[hw ether" USE_FEATURE_HWIB("|infiniband")" ADDRESS] ") "[metric NN] [mtu NN]\n" \ + " [[-]trailers] [[-]arp] [[-]allmulti]\n" \ + " [multicast] [[-]promisc] [txqueuelen NN] [[-]dynamic]\n" \ + USE_FEATURE_IFCONFIG_MEMSTART_IOADDR_IRQ( \ + " [mem_start NN] [io_addr NN] [irq NN]\n") \ + " [up|down] ..." + +#define ifenslave_trivial_usage \ + "[-cdf] master-iface <slave-iface...>" +#define ifenslave_full_usage "\n\n" \ + "Configure network interfaces for parallel routing\n" \ + "\nOptions:" \ + "\n -c, --change-active Change active slave" \ + "\n -d, --detach Remove slave interface from bonding device" \ + "\n -f, --force Force, even if interface is not Ethernet" \ +/* "\n -r, --receive-slave Create a receive-only slave" */ + +#define ifenslave_example_usage \ + "To create a bond device, simply follow these three steps :\n" \ + "- ensure that the required drivers are properly loaded :\n" \ + " # modprobe bonding ; modprobe <3c59x|eepro100|pcnet32|tulip|...>\n" \ + "- assign an IP address to the bond device :\n" \ + " # ifconfig bond0 <addr> netmask <mask> broadcast <bcast>\n" \ + "- attach all the interfaces you need to the bond device :\n" \ + " # ifenslave bond0 eth0 eth1 eth2\n" \ + " If bond0 didn't have a MAC address, it will take eth0's. Then, all\n" \ + " interfaces attached AFTER this assignment will get the same MAC addr.\n\n" \ + " To detach a dead interface without setting the bond device down :\n" \ + " # ifenslave -d bond0 eth1\n\n" \ + " To set the bond device down and automatically release all the slaves :\n" \ + " # ifconfig bond0 down\n\n" \ + " To change active slave :\n" \ + " # ifenslave -c bond0 eth0\n" \ + +#define ifup_trivial_usage \ + "[-ain"USE_FEATURE_IFUPDOWN_MAPPING("m")"vf] ifaces..." +#define ifup_full_usage "\n\n" \ + "Options:" \ + "\n -a De/configure all interfaces automatically" \ + "\n -i FILE Use FILE for interface definitions" \ + "\n -n Print out what would happen, but don't do it" \ + USE_FEATURE_IFUPDOWN_MAPPING( \ + "\n (note: doesn't disable mappings)" \ + "\n -m Don't run any mappings" \ + ) \ + "\n -v Print out what would happen before doing it" \ + "\n -f Force de/configuration" \ + +#define ifdown_trivial_usage \ + "[-ain"USE_FEATURE_IFUPDOWN_MAPPING("m")"vf] ifaces..." +#define ifdown_full_usage "\n\n" \ + "Options:" \ + "\n -a De/configure all interfaces automatically" \ + "\n -i FILE Use FILE for interface definitions" \ + "\n -n Print out what would happen, but don't do it" \ + USE_FEATURE_IFUPDOWN_MAPPING( \ + "\n (note: doesn't disable mappings)" \ + "\n -m Don't run any mappings" \ + ) \ + "\n -v Print out what would happen before doing it" \ + "\n -f Force de/configuration" \ + +#define inetd_trivial_usage \ + "[-fe] [-q N] [-R N] [CONFFILE]" +#define inetd_full_usage "\n\n" \ + "Listen for network connections and launch programs\n" \ + "\nOptions:" \ + "\n -f Run in foreground" \ + "\n -e Log to stderr" \ + "\n -q N Socket listen queue (default: 128)" \ + "\n -R N Pause services after N connects/min" \ + "\n (default: 0 - disabled)" \ + +#define init_trivial_usage \ + "" +#define init_full_usage "\n\n" \ + "Init is the parent of all processes" + +#define init_notes_usage \ +"This version of init is designed to be run only by the kernel.\n" \ +"\n" \ +"BusyBox init doesn't support multiple runlevels. The runlevels field of\n" \ +"the /etc/inittab file is completely ignored by BusyBox init. If you want\n" \ +"runlevels, use sysvinit.\n" \ +"\n" \ +"BusyBox init works just fine without an inittab. If no inittab is found,\n" \ +"it has the following default behavior:\n" \ +"\n" \ +" ::sysinit:/etc/init.d/rcS\n" \ +" ::askfirst:/bin/sh\n" \ +" ::ctrlaltdel:/sbin/reboot\n" \ +" ::shutdown:/sbin/swapoff -a\n" \ +" ::shutdown:/bin/umount -a -r\n" \ +" ::restart:/sbin/init\n" \ +"\n" \ +"if it detects that /dev/console is _not_ a serial console, it will also run:\n" \ +"\n" \ +" tty2::askfirst:/bin/sh\n" \ +" tty3::askfirst:/bin/sh\n" \ +" tty4::askfirst:/bin/sh\n" \ +"\n" \ +"If you choose to use an /etc/inittab file, the inittab entry format is as follows:\n" \ +"\n" \ +" <id>:<runlevels>:<action>:<process>\n" \ +"\n" \ +" <id>:\n" \ +"\n" \ +" WARNING: This field has a non-traditional meaning for BusyBox init!\n" \ +" The id field is used by BusyBox init to specify the controlling tty for\n" \ +" the specified process to run on. The contents of this field are\n" \ +" appended to \"/dev/\" and used as-is. There is no need for this field to\n" \ +" be unique, although if it isn't you may have strange results. If this\n" \ +" field is left blank, the controlling tty is set to the console. Also\n" \ +" note that if BusyBox detects that a serial console is in use, then only\n" \ +" entries whose controlling tty is either the serial console or /dev/null\n" \ +" will be run. BusyBox init does nothing with utmp. We don't need no\n" \ +" stinkin' utmp.\n" \ +"\n" \ +" <runlevels>:\n" \ +"\n" \ +" The runlevels field is completely ignored.\n" \ +"\n" \ +" <action>:\n" \ +"\n" \ +" Valid actions include: sysinit, respawn, askfirst, wait,\n" \ +" once, restart, ctrlaltdel, and shutdown.\n" \ +"\n" \ +" The available actions can be classified into two groups: actions\n" \ +" that are run only once, and actions that are re-run when the specified\n" \ +" process exits.\n" \ +"\n" \ +" Run only-once actions:\n" \ +"\n" \ +" 'sysinit' is the first item run on boot. init waits until all\n" \ +" sysinit actions are completed before continuing. Following the\n" \ +" completion of all sysinit actions, all 'wait' actions are run.\n" \ +" 'wait' actions, like 'sysinit' actions, cause init to wait until\n" \ +" the specified task completes. 'once' actions are asynchronous,\n" \ +" therefore, init does not wait for them to complete. 'restart' is\n" \ +" the action taken to restart the init process. By default this should\n" \ +" simply run /sbin/init, but can be a script which runs pivot_root or it\n" \ +" can do all sorts of other interesting things. The 'ctrlaltdel' init\n" \ +" actions are run when the system detects that someone on the system\n" \ +" console has pressed the CTRL-ALT-DEL key combination. Typically one\n" \ +" wants to run 'reboot' at this point to cause the system to reboot.\n" \ +" Finally the 'shutdown' action specifies the actions to taken when\n" \ +" init is told to reboot. Unmounting filesystems and disabling swap\n" \ +" is a very good here.\n" \ +"\n" \ +" Run repeatedly actions:\n" \ +"\n" \ +" 'respawn' actions are run after the 'once' actions. When a process\n" \ +" started with a 'respawn' action exits, init automatically restarts\n" \ +" it. Unlike sysvinit, BusyBox init does not stop processes from\n" \ +" respawning out of control. The 'askfirst' actions acts just like\n" \ +" respawn, except that before running the specified process it\n" \ +" displays the line \"Please press Enter to activate this console.\"\n" \ +" and then waits for the user to press enter before starting the\n" \ +" specified process.\n" \ +"\n" \ +" Unrecognized actions (like initdefault) will cause init to emit an\n" \ +" error message, and then go along with its business. All actions are\n" \ +" run in the order they appear in /etc/inittab.\n" \ +"\n" \ +" <process>:\n" \ +"\n" \ +" Specifies the process to be executed and its command line.\n" \ +"\n" \ +"Example /etc/inittab file:\n" \ +"\n" \ +" # This is run first except when booting in single-user mode\n" \ +" #\n" \ +" ::sysinit:/etc/init.d/rcS\n" \ +" \n" \ +" # /bin/sh invocations on selected ttys\n" \ +" #\n" \ +" # Start an \"askfirst\" shell on the console (whatever that may be)\n" \ +" ::askfirst:-/bin/sh\n" \ +" # Start an \"askfirst\" shell on /dev/tty2-4\n" \ +" tty2::askfirst:-/bin/sh\n" \ +" tty3::askfirst:-/bin/sh\n" \ +" tty4::askfirst:-/bin/sh\n" \ +" \n" \ +" # /sbin/getty invocations for selected ttys\n" \ +" #\n" \ +" tty4::respawn:/sbin/getty 38400 tty4\n" \ +" tty5::respawn:/sbin/getty 38400 tty5\n" \ +" \n" \ +" \n" \ +" # Example of how to put a getty on a serial line (for a terminal)\n" \ +" #\n" \ +" #::respawn:/sbin/getty -L ttyS0 9600 vt100\n" \ +" #::respawn:/sbin/getty -L ttyS1 9600 vt100\n" \ +" #\n" \ +" # Example how to put a getty on a modem line\n" \ +" #::respawn:/sbin/getty 57600 ttyS2\n" \ +" \n" \ +" # Stuff to do when restarting the init process\n" \ +" ::restart:/sbin/init\n" \ +" \n" \ +" # Stuff to do before rebooting\n" \ +" ::ctrlaltdel:/sbin/reboot\n" \ +" ::shutdown:/bin/umount -a -r\n" \ +" ::shutdown:/sbin/swapoff -a\n" + +#define inotifyd_trivial_usage \ + "/user/space/agent dir/or/file/being/watched[:mask] ..." +#define inotifyd_full_usage "\n\n" \ + "Spawn userspace agent on filesystem changes." \ + "\nWhen a filesystem event matching the mask occurs" \ + "\non specified file/directory an userspace agent is spawned" \ + "\nwith the parameters:" \ + "\n1. actual event(s)" \ + "\n2. file/directory name" \ + "\n3. name of subfile (if any), in case of watching a directory" \ + "\n" \ + "\n a File is accessed" \ + "\n c File is modified" \ + "\n e Metadata changed" \ + "\n w Writtable file is closed" \ + "\n 0 Unwrittable file is closed" \ + "\n r File is opened" \ + "\n m File is moved from X" \ + "\n y File is moved to Y" \ + "\n n Subfile is created" \ + "\n d Subfile is deleted" \ + "\n D Self is deleted" \ + "\n M Self is moved" \ + +#define insmod_trivial_usage \ + USE_FEATURE_2_4_MODULES("[OPTION]... ") "MODULE [symbol=value]..." +#define insmod_full_usage "\n\n" \ + "Load the specified kernel modules into the kernel" \ + USE_FEATURE_2_4_MODULES( "\n" \ + "\nOptions:" \ + "\n -f Force module to load into the wrong kernel version" \ + "\n -k Make module autoclean-able" \ + "\n -v Verbose" \ + "\n -q Quiet" \ + "\n -L Lock to prevent simultaneous loads of a module" \ + USE_FEATURE_INSMOD_LOAD_MAP( \ + "\n -m Output load map to stdout" \ + ) \ + "\n -o NAME Set internal module name to NAME" \ + "\n -x Do not export externs" \ + ) + +/* -v, -b, -c are ignored */ +#define install_trivial_usage \ + "[-cdDsp] [-o USER] [-g GRP] [-m MODE] [source] dest|directory" +#define install_full_usage "\n\n" \ + "Copy files and set attributes\n" \ + "\nOptions:" \ + "\n -c Just copy (default)" \ + "\n -d Create directories" \ + "\n -D Create leading target directories" \ + "\n -s Strip symbol table" \ + "\n -p Preserve date" \ + "\n -o USER Set ownership" \ + "\n -g GRP Set group ownership" \ + "\n -m MODE Set permissions" \ + USE_SELINUX( \ + "\n -Z Set security context" \ + ) + +/* would need to make the " | " optional depending on more than one selected: */ +#define ip_trivial_usage \ + "[OPTIONS] {" \ + USE_FEATURE_IP_ADDRESS("address | ") \ + USE_FEATURE_IP_ROUTE("route | ") \ + USE_FEATURE_IP_LINK("link | ") \ + USE_FEATURE_IP_TUNNEL("tunnel | ") \ + USE_FEATURE_IP_RULE("rule") \ + "} {COMMAND}" +#define ip_full_usage "\n\n" \ + "ip [OPTIONS] OBJECT {COMMAND}\n" \ + "where OBJECT := {" \ + USE_FEATURE_IP_ADDRESS("address | ") \ + USE_FEATURE_IP_ROUTE("route | ") \ + USE_FEATURE_IP_LINK("link | ") \ + USE_FEATURE_IP_TUNNEL("tunnel | ") \ + USE_FEATURE_IP_RULE("rule") \ + "}\n" \ + "OPTIONS := { -f[amily] { inet | inet6 | link } | -o[neline] }" \ + +#define ipaddr_trivial_usage \ + "{ {add|del} IFADDR dev STRING | {show|flush}\n" \ + " [dev STRING] [to PREFIX] }" +#define ipaddr_full_usage "\n\n" \ + "ipaddr {add|delete} IFADDR dev STRING\n" \ + "ipaddr {show|flush} [dev STRING] [scope SCOPE-ID]\n" \ + " [to PREFIX] [label PATTERN]\n" \ + " IFADDR := PREFIX | ADDR peer PREFIX\n" \ + " [broadcast ADDR] [anycast ADDR]\n" \ + " [label STRING] [scope SCOPE-ID]\n" \ + " SCOPE-ID := [host | link | global | NUMBER]" \ + +#define ipcalc_trivial_usage \ + "[OPTION]... ADDRESS[[/]NETMASK] [NETMASK]" +#define ipcalc_full_usage "\n\n" \ + "Calculate IP network settings from a IP address\n" \ + "\nOptions:" \ + USE_FEATURE_IPCALC_LONG_OPTIONS( \ + "\n -b,--broadcast Display calculated broadcast address" \ + "\n -n,--network Display calculated network address" \ + "\n -m,--netmask Display default netmask for IP" \ + USE_FEATURE_IPCALC_FANCY( \ + "\n -p,--prefix Display the prefix for IP/NETMASK" \ + "\n -h,--hostname Display first resolved host name" \ + "\n -s,--silent Don't ever display error messages" \ + ) \ + ) \ + SKIP_FEATURE_IPCALC_LONG_OPTIONS( \ + "\n -b Display calculated broadcast address" \ + "\n -n Display calculated network address" \ + "\n -m Display default netmask for IP" \ + USE_FEATURE_IPCALC_FANCY( \ + "\n -p Display the prefix for IP/NETMASK" \ + "\n -h Display first resolved host name" \ + "\n -s Don't ever display error messages" \ + ) \ + ) + +#define ipcrm_trivial_usage \ + "[-MQS key] [-mqs id]" +#define ipcrm_full_usage "\n\n" \ + "Upper-case options MQS remove an object by shmkey value.\n" \ + "Lower-case options remove an object by shmid value.\n" \ + "\nOptions:" \ + "\n -mM Remove memory segment after last detach" \ + "\n -qQ Remove message queue" \ + "\n -sS Remove semaphore" \ + +#define ipcs_trivial_usage \ + "[[-smq] -i shmid] | [[-asmq] [-tcplu]]" +#define ipcs_full_usage "\n\n" \ + " -i Show specific resource" \ + "\nResource specification:" \ + "\n -m Shared memory segments" \ + "\n -q Message queues" \ + "\n -s Semaphore arrays" \ + "\n -a All (default)" \ + "\nOutput format:" \ + "\n -t Time" \ + "\n -c Creator" \ + "\n -p Pid" \ + "\n -l Limits" \ + "\n -u Summary" \ + +#define iplink_trivial_usage \ + "{ set DEVICE { up | down | arp { on | off } | show [DEVICE] }" +#define iplink_full_usage "\n\n" \ + "iplink set DEVICE { up | down | arp | multicast { on | off } |\n" \ + " dynamic { on | off } |\n" \ + " mtu MTU }\n" \ + "iplink show [DEVICE]" \ + +#define iproute_trivial_usage \ + "{ list | flush | { add | del | change | append |\n" \ + " replace | monitor } ROUTE }" +#define iproute_full_usage "\n\n" \ + "iproute { list | flush } SELECTOR\n" \ + "iproute get ADDRESS [from ADDRESS iif STRING]\n" \ + " [oif STRING] [tos TOS]\n" \ + "iproute { add | del | change | append | replace | monitor } ROUTE\n" \ + " SELECTOR := [root PREFIX] [match PREFIX] [proto RTPROTO]\n" \ + " ROUTE := [TYPE] PREFIX [tos TOS] [proto RTPROTO]\n" \ + " [metric METRIC]" \ + +#define iprule_trivial_usage \ + "{[list | add | del] RULE}" +#define iprule_full_usage "\n\n" \ + "iprule [list | add | del] SELECTOR ACTION\n" \ + " SELECTOR := [from PREFIX] [to PREFIX] [tos TOS] [fwmark FWMARK]\n" \ + " [dev STRING] [pref NUMBER]\n" \ + " ACTION := [table TABLE_ID] [nat ADDRESS]\n" \ + " [prohibit | reject | unreachable]\n" \ + " [realms [SRCREALM/]DSTREALM]\n" \ + " TABLE_ID := [local | main | default | NUMBER]" \ + +#define iptunnel_trivial_usage \ + "{ add | change | del | show } [NAME]\n" \ + " [mode { ipip | gre | sit }]\n" \ + " [remote ADDR] [local ADDR] [ttl TTL]" +#define iptunnel_full_usage "\n\n" \ + "iptunnel { add | change | del | show } [NAME]\n" \ + " [mode { ipip | gre | sit }] [remote ADDR] [local ADDR]\n" \ + " [[i|o]seq] [[i|o]key KEY] [[i|o]csum]\n" \ + " [ttl TTL] [tos TOS] [[no]pmtudisc] [dev PHYS_DEV]" \ + +#define kbd_mode_trivial_usage \ + "[-a|k|s|u] [-C TTY]" +#define kbd_mode_full_usage "\n\n" \ + "Report or set the keyboard mode\n" \ + "\nOptions set mode:" \ + "\n -a Default (ASCII)" \ + "\n -k Medium-raw (keyboard)" \ + "\n -s Raw (scancode)" \ + "\n -u Unicode (utf-8)" \ + "\n -C TTY Affect TTY instead of /dev/tty" \ + +#define kill_trivial_usage \ + "[-l] [-SIG] PID..." +#define kill_full_usage "\n\n" \ + "Send a signal (default is TERM) to given PIDs\n" \ + "\nOptions:" \ + "\n -l List all signal names and numbers" \ +/* "\n -s SIG Yet another way of specifying SIG" */ \ + +#define kill_example_usage \ + "$ ps | grep apache\n" \ + "252 root root S [apache]\n" \ + "263 www-data www-data S [apache]\n" \ + "264 www-data www-data S [apache]\n" \ + "265 www-data www-data S [apache]\n" \ + "266 www-data www-data S [apache]\n" \ + "267 www-data www-data S [apache]\n" \ + "$ kill 252\n" + +#define killall_trivial_usage \ + "[-l] [-q] [-SIG] process-name..." +#define killall_full_usage "\n\n" \ + "Send a signal (default is TERM) to given processes\n" \ + "\nOptions:" \ + "\n -l List all signal names and numbers" \ +/* "\n -s SIG Yet another way of specifying SIG" */ \ + "\n -q Do not complain if no processes were killed" \ + +#define killall_example_usage \ + "$ killall apache\n" + +#define killall5_trivial_usage \ + "[-l] [-SIG]" +#define killall5_full_usage "\n\n" \ + "Send a signal (default is TERM) to all processes outside current session\n" \ + "\nOptions:" \ + "\n -l List all signal names and numbers" \ +/* "\n -s SIG Yet another way of specifying SIG" */ \ + +#define klogd_trivial_usage \ + "[-c N] [-n]" +#define klogd_full_usage "\n\n" \ + "Kernel logger\n" \ + "\nOptions:" \ + "\n -c N Only messages with level < N are printed to console" \ + "\n -n Run in foreground" \ + +#define length_trivial_usage \ + "STRING" +#define length_full_usage "\n\n" \ + "Print STRING's length" + +#define length_example_usage \ + "$ length Hello\n" \ + "5\n" + +#define less_trivial_usage \ + "[-EMNmh~I?] [FILE...]" +#define less_full_usage "\n\n" \ + "View a file or list of files. The position within files can be\n" \ + "changed, and files can be manipulated in various ways.\n" \ + "\nOptions:" \ + "\n -E Quit once the end of a file is reached" \ + "\n -M,-m Display a status line containing the line numbers" \ + "\n and percentage through the file" \ + "\n -N Prefix line numbers to each line" \ + "\n -I Ignore case in all searches" \ + "\n -~ Suppress ~s displayed past the end of the file" \ + +#define linux32_trivial_usage NOUSAGE_STR +#define linux32_full_usage "" +#define linux64_trivial_usage NOUSAGE_STR +#define linux64_full_usage "" + +#define linuxrc_trivial_usage NOUSAGE_STR +#define linuxrc_full_usage "" + +#define setarch_trivial_usage \ + "personality program [args...]" +#define setarch_full_usage "\n\n" \ + "Personality may be:\n" \ + " linux32 Set 32bit uname emulation\n" \ + " linux64 Set 64bit uname emulation" \ + +#define ln_trivial_usage \ + "[OPTION] TARGET... LINK_NAME|DIRECTORY" +#define ln_full_usage "\n\n" \ + "Create a link named LINK_NAME or DIRECTORY to the specified TARGET.\n" \ + "Use '--' to indicate that all following arguments are non-options.\n" \ + "\nOptions:" \ + "\n -s Make symlinks instead of hardlinks" \ + "\n -f Remove existing destination files" \ + "\n -n Don't dereference symlinks - treat like normal file" \ + "\n -b Make a backup of the target (if exists) before link operation" \ + "\n -S suf Use suffix instead of ~ when making backup files" \ + +#define ln_example_usage \ + "$ ln -s BusyBox /tmp/ls\n" \ + "$ ls -l /tmp/ls\n" \ + "lrwxrwxrwx 1 root root 7 Apr 12 18:39 ls -> BusyBox*\n" + +#define load_policy_trivial_usage NOUSAGE_STR +#define load_policy_full_usage "" + +#define loadfont_trivial_usage \ + "< font" +#define loadfont_full_usage "\n\n" \ + "Load a console font from standard input" \ +/* "\n -C TTY Affect TTY instead of /dev/tty" */ \ + +#define loadfont_example_usage \ + "$ loadfont < /etc/i18n/fontname\n" + +#define loadkmap_trivial_usage \ + "< keymap" +#define loadkmap_full_usage "\n\n" \ + "Load a binary keyboard translation table from standard input\n" \ +/* "\n -C TTY Affect TTY instead of /dev/tty" */ \ + +#define loadkmap_example_usage \ + "$ loadkmap < /etc/i18n/lang-keymap\n" + +#define logger_trivial_usage \ + "[OPTION]... [MESSAGE]" +#define logger_full_usage "\n\n" \ + "Write MESSAGE to the system log. If MESSAGE is omitted, log stdin.\n" \ + "\nOptions:" \ + "\n -s Log to stderr as well as the system log" \ + "\n -t TAG Log using the specified tag (defaults to user name)" \ + "\n -p PRIO Priority (numeric or facility.level pair)" \ + +#define logger_example_usage \ + "$ logger \"hello\"\n" + +#define login_trivial_usage \ + "[-p] [-h HOST] [[-f] USER]" +#define login_full_usage "\n\n" \ + "Begin a new session on the system\n" \ + "\nOptions:" \ + "\n -f Do not authenticate (user already authenticated)" \ + "\n -h Name of the remote host" \ + "\n -p Preserve environment" \ + +#define logname_trivial_usage \ + "" +#define logname_full_usage "\n\n" \ + "Print the name of the current user" +#define logname_example_usage \ + "$ logname\n" \ + "root\n" + +#define logread_trivial_usage \ + "[OPTION]..." +#define logread_full_usage "\n\n" \ + "Show messages in syslogd's circular buffer\n" \ + "\nOptions:" \ + "\n -f Output data as log grows" \ + +#define losetup_trivial_usage \ + "[-o OFS] LOOPDEV FILE - associate loop devices\n" \ + " losetup -d LOOPDEV - disassociate\n" \ + " losetup [-f] - show" +#define losetup_full_usage "\n\n" \ + "Options:" \ + "\n -o OFS Start OFS bytes into FILE" \ + "\n -f Show first free loop device" \ + +#define losetup_notes_usage \ + "No arguments will display all current associations.\n" \ + "One argument (losetup /dev/loop1) will display the current association\n" \ + "(if any), or disassociate it (with -d). The display shows the offset\n" \ + "and filename of the file the loop device is currently bound to.\n\n" \ + "Two arguments (losetup /dev/loop1 file.img) create a new association,\n" \ + "with an optional offset (-o 12345). Encryption is not yet supported.\n" \ + "losetup -f will show the first loop free loop device\n\n" + +#define lpd_trivial_usage \ + "SPOOLDIR [HELPER [ARGS...]]" +#define lpd_full_usage "\n\n" \ + "SPOOLDIR must contain (symlinks to) device nodes or directories" \ + "\nwith names matching print queue names. In the first case, jobs are" \ + "\nsent directly to the device. Otherwise each job is stored in queue" \ + "\ndirectory and HELPER program is called. Name of file to print" \ + "\nis passed in $DATAFILE variable." \ + "\nExample:" \ + "\n tcpsvd -E 0 515 softlimit -m 999999 lpd /var/spool ./print" \ + +#define lpq_trivial_usage \ + "[-P queue[@host[:port]]] [-U USERNAME] [-d JOBID...] [-fs]" +#define lpq_full_usage "\n\n" \ + "Options:" \ + "\n -P lp service to connect to (else uses $PRINTER)" \ + "\n -d Delete jobs" \ + "\n -f Force any waiting job to be printed" \ + "\n -s Short display" \ + +#define lpr_trivial_usage \ + "-P queue[@host[:port]] -U USERNAME -J TITLE -Vmh [FILE...]" +/* -C CLASS exists too, not shown. + * CLASS is supposed to be printed on banner page, if one is requested */ +#define lpr_full_usage "\n\n" \ + "Options:" \ + "\n -P lp service to connect to (else uses $PRINTER)"\ + "\n -m Send mail on completion" \ + "\n -h Print banner page too" \ + "\n -V Verbose" \ + +#define ls_trivial_usage \ + "[-1Aa" USE_FEATURE_LS_TIMESTAMPS("c") "Cd" \ + USE_FEATURE_LS_TIMESTAMPS("e") USE_FEATURE_LS_FILETYPES("F") "iln" \ + USE_FEATURE_LS_FILETYPES("p") USE_FEATURE_LS_FOLLOWLINKS("L") \ + USE_FEATURE_LS_RECURSIVE("R") USE_FEATURE_LS_SORTFILES("rS") "s" \ + USE_FEATURE_AUTOWIDTH("T") USE_FEATURE_LS_TIMESTAMPS("tu") \ + USE_FEATURE_LS_SORTFILES("v") USE_FEATURE_AUTOWIDTH("w") "x" \ + USE_FEATURE_LS_SORTFILES("X") USE_FEATURE_HUMAN_READABLE("h") "k" \ + USE_SELINUX("K") "] [filenames...]" +#define ls_full_usage "\n\n" \ + "List directory contents\n" \ + "\nOptions:" \ + "\n -1 List in a single column" \ + "\n -A Don't list . and .." \ + "\n -a Don't hide entries starting with ." \ + "\n -C List by columns" \ + USE_FEATURE_LS_TIMESTAMPS( \ + "\n -c With -l: sort by ctime") \ + USE_FEATURE_LS_COLOR( \ + "\n --color[={always,never,auto}] Control coloring") \ + "\n -d List directory entries instead of contents" \ + USE_FEATURE_LS_TIMESTAMPS( \ + "\n -e List full date and time") \ + USE_FEATURE_LS_FILETYPES( \ + "\n -F Append indicator (one of */=@|) to entries") \ + "\n -i List inode numbers" \ + "\n -l Long listing format" \ + "\n -n List numeric UIDs and GIDs instead of names" \ + USE_FEATURE_LS_FILETYPES( \ + "\n -p Append indicator (one of /=@|) to entries") \ + USE_FEATURE_LS_FOLLOWLINKS( \ + "\n -L List entries pointed to by symlinks") \ + USE_FEATURE_LS_RECURSIVE( \ + "\n -R List subdirectories recursively") \ + USE_FEATURE_LS_SORTFILES( \ + "\n -r Sort in reverse order") \ + USE_FEATURE_LS_SORTFILES( \ + "\n -S Sort by file size") \ + "\n -s List the size of each file, in blocks" \ + USE_FEATURE_AUTOWIDTH( \ + "\n -T NUM Assume tabstop every NUM columns") \ + USE_FEATURE_LS_TIMESTAMPS( \ + "\n -t With -l: sort by modification time") \ + USE_FEATURE_LS_TIMESTAMPS( \ + "\n -u With -l: sort by access time") \ + USE_FEATURE_LS_SORTFILES( \ + "\n -v Sort by version") \ + USE_FEATURE_AUTOWIDTH( \ + "\n -w NUM Assume the terminal is NUM columns wide") \ + "\n -x List by lines" \ + USE_FEATURE_LS_SORTFILES( \ + "\n -X Sort by extension") \ + USE_FEATURE_HUMAN_READABLE( \ + "\n -h List sizes in human readable format (1K 243M 2G)") \ + USE_SELINUX( \ + "\n -k List security context") \ + USE_SELINUX( \ + "\n -K List security context in long format") \ + USE_SELINUX( \ + "\n -Z List security context and permission") \ + +#define lsattr_trivial_usage \ + "[-Radlv] [files...]" +#define lsattr_full_usage "\n\n" \ + "List file attributes on an ext2 fs\n" \ + "\nOptions:" \ + "\n -R Recursively list subdirectories" \ + "\n -a Do not hide entries starting with ." \ + "\n -d List directory entries instead of contents" \ + "\n -l List long flag names" \ + "\n -v List the file's version/generation number" \ + +#define lsmod_trivial_usage \ + "" +#define lsmod_full_usage "\n\n" \ + "List the currently loaded kernel modules" + +#if ENABLE_FEATURE_MAKEDEVS_LEAF +#define makedevs_trivial_usage \ + "NAME TYPE MAJOR MINOR FIRST LAST [s]" +#define makedevs_full_usage "\n\n" \ + "Create a range of block or character special files" \ + "\n" \ + "\nTYPE is:" \ + "\n b Block device" \ + "\n c Character device" \ + "\n f FIFO, MAJOR and MINOR are ignored" \ + "\n" \ + "\nFIRST..LAST specify numbers appended to NAME." \ + "\nIf 's' is the last argument, the base device is created as well." \ + "\n" \ + "\nExamples:" \ + "\n makedevs /dev/ttyS c 4 66 2 63 -> ttyS2-ttyS63" \ + "\n makedevs /dev/hda b 3 0 0 8 s -> hda,hda1-hda8" +#define makedevs_example_usage \ + "# makedevs /dev/ttyS c 4 66 2 63\n" \ + "[creates ttyS2-ttyS63]\n" \ + "# makedevs /dev/hda b 3 0 0 8 s\n" \ + "[creates hda,hda1-hda8]\n" +#endif + +#if ENABLE_FEATURE_MAKEDEVS_TABLE +#define makedevs_trivial_usage \ + "[-d device_table] rootdir" +#define makedevs_full_usage "\n\n" \ + "Create a range of special files as specified in a device table.\n" \ + "Device table entries take the form of:\n" \ + "<type> <mode> <uid> <gid> <major> <minor> <start> <inc> <count>\n" \ + "Where name is the file name, type can be one of:\n" \ + " f Regular file\n" \ + " d Directory\n" \ + " c Character device\n" \ + " b Block device\n" \ + " p Fifo (named pipe)\n" \ + "uid is the user id for the target file, gid is the group id for the\n" \ + "target file. The rest of the entries (major, minor, etc) apply to\n" \ + "to device special files. A '-' may be used for blank entries." +#define makedevs_example_usage \ + "For example:\n" \ + "<name> <type> <mode><uid><gid><major><minor><start><inc><count>\n" \ + "/dev d 755 0 0 - - - - -\n" \ + "/dev/console c 666 0 0 5 1 - - -\n" \ + "/dev/null c 666 0 0 1 3 0 0 -\n" \ + "/dev/zero c 666 0 0 1 5 0 0 -\n" \ + "/dev/hda b 640 0 0 3 0 0 0 -\n" \ + "/dev/hda b 640 0 0 3 1 1 1 15\n\n" \ + "Will Produce:\n" \ + "/dev\n" \ + "/dev/console\n" \ + "/dev/null\n" \ + "/dev/zero\n" \ + "/dev/hda\n" \ + "/dev/hda[0-15]\n" +#endif + +#define makemime_trivial_usage \ + "[OPTION]... [FILE]..." +#define makemime_full_usage "\n\n" \ + "Create MIME-encoded message\n" \ + "\nOptions:" \ + "\n -C Charset" \ + "\n -e Tranfer encoding. Ignored. base64 is assumed" \ + "\n" \ + "\nOther options are silently ignored." \ + +#define man_trivial_usage \ + "[OPTION]... [MANPAGE]..." +#define man_full_usage "\n\n" \ + "Format and display manual page\n" \ + "\nOptions:" \ + "\n -a Display all pages" \ + "\n -w Show page locations" \ + +#define matchpathcon_trivial_usage \ + "[-n] [-N] [-f file_contexts_file] [-p prefix] [-V]" +#define matchpathcon_full_usage "\n\n" \ + " -n Do not display path" \ + "\n -N Do not use translations" \ + "\n -f Use alternate file_context file" \ + "\n -p Use prefix to speed translations" \ + "\n -V Verify file context on disk matches defaults" \ + +#define md5sum_trivial_usage \ + "[OPTION] [FILEs...]" \ + USE_FEATURE_MD5_SHA1_SUM_CHECK("\n or: md5sum [OPTION] -c [FILE]") +#define md5sum_full_usage "\n\n" \ + "Print" USE_FEATURE_MD5_SHA1_SUM_CHECK(" or check") " MD5 checksums" \ + USE_FEATURE_MD5_SHA1_SUM_CHECK( "\n" \ + "\nOptions:" \ + "\n -c Check MD5 sums against given list" \ + "\n -s Don't output anything, status code shows success" \ + "\n -w Warn about improperly formatted MD5 checksum lines") \ + +#define md5sum_example_usage \ + "$ md5sum < busybox\n" \ + "6fd11e98b98a58f64ff3398d7b324003\n" \ + "$ md5sum busybox\n" \ + "6fd11e98b98a58f64ff3398d7b324003 busybox\n" \ + "$ md5sum -c -\n" \ + "6fd11e98b98a58f64ff3398d7b324003 busybox\n" \ + "busybox: OK\n" \ + "^D\n" + +#define mdev_trivial_usage \ + "[-s]" +#define mdev_full_usage "\n\n" \ + " -s Scan /sys and populate /dev during system boot\n" \ + "\n" \ + "Called with no options (via hotplug) it uses environment variables\n" \ + "to determine which device to add/remove." + +#define mdev_notes_usage "" \ + USE_FEATURE_MDEV_CONFIG( \ + "The mdev config file contains lines that look like:\n" \ + " hd[a-z][0-9]* 0:3 660\n\n" \ + "That's device name (with regex match), uid:gid, and permissions.\n\n" \ + USE_FEATURE_MDEV_EXEC( \ + "Optionally, that can be followed (on the same line) by a special character\n" \ + "and a command line to run after creating/before deleting the corresponding\n" \ + "device(s). The environment variable $MDEV indicates the active device node\n" \ + "(which is useful if it's a regex match). For example:\n\n" \ + " hdc root:cdrom 660 *ln -s $MDEV cdrom\n\n" \ + "The special characters are @ (run after creating), $ (run before deleting),\n" \ + "and * (run both after creating and before deleting). The commands run in\n" \ + "the /dev directory, and use system() which calls /bin/sh.\n\n" \ + ) \ + "Config file parsing stops on the first matching line. If no config\n" \ + "entry is matched, devices are created with default 0:0 660. (Make\n" \ + "the last line match .* to override this.)\n\n" \ + ) + +#define mesg_trivial_usage \ + "[y|n]" +#define mesg_full_usage "\n\n" \ + "Control write access to your terminal\n" \ + " y Allow write access to your terminal\n" \ + " n Disallow write access to your terminal" + +#define microcom_trivial_usage \ + "[-d DELAY] [-t TIMEOUT] [-s SPEED] [-X] TTY" +#define microcom_full_usage "\n\n" \ + "Copy bytes for stdin to TTY and from TTY to stdout\n" \ + "\nOptions:" \ + "\n -d Wait up to DELAY ms for TTY output before sending every" \ + "\n next byte to it" \ + "\n -t Exit if both stdin and TTY are silent for TIMEOUT ms" \ + "\n -s Set serial line to SPEED" \ + "\n -X Disable special meaning of NUL and Ctrl-X from stdin" \ + +#define mkdir_trivial_usage \ + "[OPTION] DIRECTORY..." +#define mkdir_full_usage "\n\n" \ + "Create DIRECTORY\n" \ + "\nOptions:" \ + "\n -m Set permission mode (as in chmod), not rwxrwxrwx - umask" \ + "\n -p No error if existing, make parent directories as needed" \ + USE_SELINUX( \ + "\n -Z Set security context" \ + ) + +#define mkdir_example_usage \ + "$ mkdir /tmp/foo\n" \ + "$ mkdir /tmp/foo\n" \ + "/tmp/foo: File exists\n" \ + "$ mkdir /tmp/foo/bar/baz\n" \ + "/tmp/foo/bar/baz: No such file or directory\n" \ + "$ mkdir -p /tmp/foo/bar/baz\n" + +#define mke2fs_trivial_usage \ + "[-c|-l filename] [-b block-size] [-f fragment-size] [-g blocks-per-group] " \ + "[-i bytes-per-inode] [-j] [-J journal-options] [-N number-of-inodes] [-n] " \ + "[-m reserved-blocks-percentage] [-o creator-os] [-O feature[,...]] [-q] " \ + "[r fs-revision-level] [-E extended-options] [-v] [-F] [-L volume-label] " \ + "[-M last-mounted-directory] [-S] [-T filesystem-type] " \ + "device [blocks-count]" +#define mke2fs_full_usage "\n\n" \ + " -b size Block size in bytes" \ + "\n -c Check for bad blocks before creating" \ + "\n -E opts Set extended options" \ + "\n -f size Fragment size in bytes" \ + "\n -F Force (ignore sanity checks)" \ + "\n -g num Number of blocks in a block group" \ + "\n -i ratio The bytes/inode ratio" \ + "\n -j Create a journal (ext3)" \ + "\n -J opts Set journal options (size/device)" \ + "\n -l file Read bad blocks list from file" \ + "\n -L lbl Set the volume label" \ + "\n -m percent Percent of fs blocks to reserve for admin" \ + "\n -M dir Set last mounted directory" \ + "\n -n Do not actually create anything" \ + "\n -N num Number of inodes to create" \ + "\n -o os Set the 'creator os' field" \ + "\n -O features Dir_index/filetype/has_journal/journal_dev/sparse_super" \ + "\n -q Quiet" \ + "\n -r rev Set filesystem revision" \ + "\n -S Write superblock and group descriptors only" \ + "\n -T fs-type Set usage type (news/largefile/largefile4)" \ + "\n -v Verbose" \ + +#define mkfifo_trivial_usage \ + "[OPTIONS] name" +#define mkfifo_full_usage "\n\n" \ + "Create named pipe (identical to 'mknod name p')\n" \ + "\nOptions:" \ + "\n -m MODE Mode (default a=rw)" \ + USE_SELINUX( \ + "\n -Z Set security context" \ + ) + +#define mkfs_minix_trivial_usage \ + "[-c | -l filename] [-nXX] [-iXX] /dev/name [blocks]" +#define mkfs_minix_full_usage "\n\n" \ + "Make a MINIX filesystem\n" \ + "\nOptions:" \ + "\n -c Check device for bad blocks" \ + "\n -n [14|30] Maximum length of filenames" \ + "\n -i INODES Number of inodes for the filesystem" \ + "\n -l FILENAME Read bad blocks list from FILENAME" \ + "\n -v Make version 2 filesystem" \ + +#define mknod_trivial_usage \ + "[OPTIONS] NAME TYPE MAJOR MINOR" +#define mknod_full_usage "\n\n" \ + "Create a special file (block, character, or pipe)\n" \ + "\nOptions:" \ + "\n -m Create the special file using the specified mode (default a=rw)" \ + "\nTYPEs include:" \ + "\n b: Make a block device" \ + "\n c or u: Make a character device" \ + "\n p: Make a named pipe (MAJOR and MINOR are ignored)" \ + USE_SELINUX( \ + "\n -Z Set security context" \ + ) + +#define mknod_example_usage \ + "$ mknod /dev/fd0 b 2 0\n" \ + "$ mknod -m 644 /tmp/pipe p\n" + +#define mkswap_trivial_usage \ + "DEVICE" +#define mkswap_full_usage "\n\n" \ + "Prepare block device to be used as swap partition" +#if 0 + "[-c] [-v0|-v1] DEVICE [BLOCKS]" + "\nOptions:" + "\n -c Check for readability" + "\n -v0 Make swap version 0 (max 128M)" + "\n -v1 Make swap version 1 (default for kernels > 2.1.117)" + "\n BLOCKS Number of blocks to use (default is entire partition)" +#endif + +#define mktemp_trivial_usage \ + "[-dt] [-p DIR] [TEMPLATE]" +#define mktemp_full_usage "\n\n" \ + "Create a temporary file with name based on TEMPLATE and print its name.\n" \ + "TEMPLATE must end with XXXXXX (e.g. [/dir/]nameXXXXXX).\n" \ + "\nOptions:" \ + "\n -d Make a directory instead of a file" \ +/* "\n -q Fail silently if an error occurs" - we ignore it */ \ + "\n -t Generate a path rooted in temporary directory" \ + "\n -p DIR Use DIR as a temporary directory (implies -t)" \ + "\n" \ + "\nFor -t or -p, directory is chosen as follows:" \ + "\n$TMPDIR if set, else -p DIR, else /tmp" \ + +#define mktemp_example_usage \ + "$ mktemp /tmp/temp.XXXXXX\n" \ + "/tmp/temp.mWiLjM\n" \ + "$ ls -la /tmp/temp.mWiLjM\n" \ + "-rw------- 1 andersen andersen 0 Apr 25 17:10 /tmp/temp.mWiLjM\n" + +#define modprobe_trivial_usage \ + "[-knqrsv] MODULE [symbol=value...]" +#define modprobe_full_usage "\n\n" \ + "Options:" \ + USE_FEATURE_2_4_MODULES( \ + "\n -k Make module autoclean-able" \ + ) \ + "\n -n Dry run" \ + "\n -q Quiet" \ + "\n -r Remove module (stacks) or do autoclean" \ + "\n -s Report via syslog instead of stderr" \ + "\n -v Verbose" \ + USE_FEATURE_MODPROBE_BLACKLIST( \ + "\n -b Apply blacklist to module names too" \ + ) + +#define modprobe_notes_usage \ +"modprobe can (un)load a stack of modules, passing each module options (when\n" \ +"loading). modprobe uses a configuration file to determine what option(s) to\n" \ +"pass each module it loads.\n" \ +"\n" \ +"The configuration file is searched (in order) amongst:\n" \ +"\n" \ +" /etc/modprobe.conf (2.6 only)\n" \ +" /etc/modules.conf\n" \ +" /etc/conf.modules (deprecated)\n" \ +"\n" \ +"They all have the same syntax (see below). If none is present, it is\n" \ +"_not_ an error; each loaded module is then expected to load without\n" \ +"options. Once a file is found, the others are tested for.\n" \ +"\n" \ +"/etc/modules.conf entry format:\n" \ +"\n" \ +" alias <alias_name> <mod_name>\n" \ +" Makes it possible to modprobe alias_name, when there is no such module.\n" \ +" It makes sense if your mod_name is long, or you want a more representative\n" \ +" name for that module (eg. 'scsi' in place of 'aha7xxx').\n" \ +" This makes it also possible to use a different set of options (below) for\n" \ +" the module and the alias.\n" \ +" A module can be aliased more than once.\n" \ +"\n" \ +" options <mod_name|alias_name> <symbol=value...>\n" \ +" When loading module mod_name (or the module aliased by alias_name), pass\n" \ +" the \"symbol=value\" pairs as option to that module.\n" \ +"\n" \ +"Sample /etc/modules.conf file:\n" \ +"\n" \ +" options tulip irq=3\n" \ +" alias tulip tulip2\n" \ +" options tulip2 irq=4 io=0x308\n" \ +"\n" \ +"Other functionality offered by 'classic' modprobe is not available in\n" \ +"this implementation.\n" \ +"\n" \ +"If module options are present both in the config file, and on the command line,\n" \ +"then the options from the command line will be passed to the module _after_\n" \ +"the options from the config file. That way, you can have defaults in the config\n" \ +"file, and override them for a specific usage from the command line.\n" +#define modprobe_example_usage \ + "(with the above /etc/modules.conf):\n\n" \ + "$ modprobe tulip\n" \ + " will load the module 'tulip' with default option 'irq=3'\n\n" \ + "$ modprobe tulip irq=5\n" \ + " will load the module 'tulip' with option 'irq=5', thus overriding the default\n\n" \ + "$ modprobe tulip2\n" \ + " will load the module 'tulip' with default options 'irq=4 io=0x308',\n" \ + " which are the default for alias 'tulip2'\n\n" \ + "$ modprobe tulip2 irq=8\n" \ + " will load the module 'tulip' with default options 'irq=4 io=0x308 irq=8',\n" \ + " which are the default for alias 'tulip2' overridden by the option 'irq=8'\n\n" \ + " from the command line\n\n" \ + "$ modprobe tulip2 irq=2 io=0x210\n" \ + " will load the module 'tulip' with default options 'irq=4 io=0x308 irq=4 io=0x210',\n" \ + " which are the default for alias 'tulip2' overridden by the options 'irq=2 io=0x210'\n\n" \ + " from the command line\n" + +#define more_trivial_usage \ + "[FILE...]" +#define more_full_usage "\n\n" \ + "View FILE or standard input one screenful at a time" + +#define more_example_usage \ + "$ dmesg | more\n" + +#define mount_trivial_usage \ + "[flags] DEVICE NODE [-o options,more-options]" +#define mount_full_usage "\n\n" \ + "Mount a filesystem. Filesystem autodetection requires /proc be mounted.\n" \ + "\nOptions:" \ + "\n -a Mount all filesystems in fstab" \ + USE_FEATURE_MOUNT_FAKE( \ + "\n -f "USE_FEATURE_MTAB_SUPPORT("Update /etc/mtab, but ")"don't mount" \ + ) \ + USE_FEATURE_MTAB_SUPPORT( \ + "\n -n Don't update /etc/mtab" \ + ) \ + "\n -r Read-only mount" \ + "\n -t fs-type Filesystem type" \ + "\n -w Read-write mount (default)" \ + "\n" \ + "-o option:\n" \ + USE_FEATURE_MOUNT_LOOP( \ + " loop Ignored (loop devices are autodetected)\n" \ + ) \ + USE_FEATURE_MOUNT_FLAGS( \ + " [a]sync Writes are asynchronous / synchronous\n" \ + " [no]atime Disable / enable updates to inode access times\n" \ + " [no]diratime Disable / enable atime updates to directories\n" \ + " [no]relatime Disable / enable atime updates relative to modification time\n" \ + " [no]dev Allow use of special device files / disallow them\n" \ + " [no]exec Allow use of executable files / disallow them\n" \ + " [no]suid Allow set-user-id-root programs / disallow them\n" \ + " [r]shared Convert [recursively] to a shared subtree\n" \ + " [r]slave Convert [recursively] to a slave subtree\n" \ + " [r]private Convert [recursively] to a private subtree\n" \ + " [un]bindable Make mount point [un]able to be bind mounted\n" \ + " bind Bind a directory to an additional location\n" \ + " move Relocate an existing mount point\n" \ + ) \ + " remount Remount a mounted filesystem, changing its flags\n" \ + " ro/rw Mount for read-only / read-write\n" \ + "\n" \ + "There are EVEN MORE flags that are specific to each filesystem\n" \ + "You'll have to see the written documentation for those filesystems" \ + +#define mount_example_usage \ + "$ mount\n" \ + "/dev/hda3 on / type minix (rw)\n" \ + "proc on /proc type proc (rw)\n" \ + "devpts on /dev/pts type devpts (rw)\n" \ + "$ mount /dev/fd0 /mnt -t msdos -o ro\n" \ + "$ mount /tmp/diskimage /opt -t ext2 -o loop\n" \ + "$ mount cd_image.iso mydir\n" +#define mount_notes_usage \ + "Returns 0 for success, number of failed mounts for -a, or errno for one mount." + +#define mountpoint_trivial_usage \ + "[-q] <[-d] DIR | -x DEVICE>" +#define mountpoint_full_usage "\n\n" \ + "mountpoint checks if the directory is a mountpoint\n" \ + "\nOptions:" \ + "\n -q Quiet" \ + "\n -d Print major/minor device number of the filesystem" \ + "\n -x Print major/minor device number of the blockdevice" \ + +#define mountpoint_example_usage \ + "$ mountpoint /proc\n" \ + "/proc is not a mountpoint\n" \ + "$ mountpoint /sys\n" \ + "/sys is a mountpoint\n" + +#define mt_trivial_usage \ + "[-f device] opcode value" +#define mt_full_usage "\n\n" \ + "Control magnetic tape drive operation\n" \ + "\n" \ + "Available Opcodes:\n" \ + "\n" \ + "bsf bsfm bsr bss datacompression drvbuffer eof eom erase\n" \ + "fsf fsfm fsr fss load lock mkpart nop offline ras1 ras2\n" \ + "ras3 reset retension rewind rewoffline seek setblk setdensity\n" \ + "setpart tell unload unlock weof wset" \ + +#define mv_trivial_usage \ + "[OPTION]... SOURCE DEST\n" \ + "or: mv [OPTION]... SOURCE... DIRECTORY" +#define mv_full_usage "\n\n" \ + "Rename SOURCE to DEST, or move SOURCE(s) to DIRECTORY\n" \ + "\nOptions:" \ + "\n -f Don't prompt before overwriting" \ + "\n -i Interactive, prompt before overwrite" \ + +#define mv_example_usage \ + "$ mv /tmp/foo /bin/bar\n" + +#define nameif_trivial_usage \ + "[-s] [-c FILE] [{IFNAME MACADDR}]" +#define nameif_full_usage "\n\n" \ + "Rename network interface while it in the down state\n" \ + "\nOptions:" \ + "\n -c FILE Use configuration file (default is /etc/mactab)" \ + "\n -s Use syslog (LOCAL0 facility)" \ + "\n IFNAME MACADDR new_interface_name interface_mac_address" \ + +#define nameif_example_usage \ + "$ nameif -s dmz0 00:A0:C9:8C:F6:3F\n" \ + " or\n" \ + "$ nameif -c /etc/my_mactab_file\n" \ + +#if !ENABLE_DESKTOP + +#if ENABLE_NC_SERVER || ENABLE_NC_EXTRA +#define NC_OPTIONS_STR "\n\nOptions:" +#else +#define NC_OPTIONS_STR +#endif + +#define nc_trivial_usage \ + USE_NC_EXTRA("[-iN] [-wN] ")USE_NC_SERVER("[-l] [-p PORT] ") \ + "["USE_NC_EXTRA("-f FILENAME|")"IPADDR PORTNUM]"USE_NC_EXTRA(" [-e COMMAND]") +#define nc_full_usage "\n\n" \ + "Open a pipe to IP:port" USE_NC_EXTRA(" or file") \ + NC_OPTIONS_STR \ + USE_NC_EXTRA( \ + "\n -e Exec rest of command line after connect" \ + "\n -i SECS Delay interval for lines sent" \ + "\n -w SECS Timeout for connect" \ + "\n -f FILE Use file (ala /dev/ttyS0) instead of network" \ + ) \ + USE_NC_SERVER( \ + "\n -l Listen mode, for inbound connects" \ + USE_NC_EXTRA( \ + "\n (use -l twice with -e for persistent server)") \ + "\n -p PORT Local port number" \ + ) + +#define nc_notes_usage "" \ + USE_NC_EXTRA( \ + "To use netcat as a terminal emulator on a serial port:\n\n" \ + "$ stty 115200 -F /dev/ttyS0\n" \ + "$ stty raw -echo -ctlecho && nc -f /dev/ttyS0\n" \ + ) + +#define nc_example_usage \ + "$ nc foobar.somedomain.com 25\n" \ + "220 foobar ESMTP Exim 3.12 #1 Sat, 15 Apr 2000 00:03:02 -0600\n" \ + "help\n" \ + "214-Commands supported:\n" \ + "214- HELO EHLO MAIL RCPT DATA AUTH\n" \ + "214 NOOP QUIT RSET HELP\n" \ + "quit\n" \ + "221 foobar closing connection\n" + +#else /* DESKTOP nc - much more compatible with nc 1.10 */ + +#define nc_trivial_usage \ + "[-options] hostname port - connect" \ + USE_NC_SERVER("\n" \ + "nc [-options] -l -p port [hostname] [port] - listen") +#define nc_full_usage "\n\n" \ + "Options:" \ + "\n -e prog [args] Program to exec after connect (must be last)" \ + USE_NC_SERVER( \ + "\n -l Listen mode, for inbound connects" \ + ) \ + "\n -n Don't do DNS resolution" \ + "\n -s addr Local address" \ + "\n -p port Local port" \ + "\n -u UDP mode" \ + "\n -v Verbose (cumulative: -vv)" \ + "\n -w secs Timeout for connects and final net reads" \ + USE_NC_EXTRA( \ + "\n -i sec Delay interval for lines sent" /* ", ports scanned" */ \ + "\n -o file Hex dump of traffic" \ + "\n -z Zero-I/O mode (scanning)" \ + ) \ +/* "\n -r Randomize local and remote ports" */ +/* "\n -g gateway Source-routing hop point[s], up to 8" */ +/* "\n -G num Source-routing pointer: 4, 8, 12, ..." */ +/* "\nport numbers can be individual or ranges: lo-hi [inclusive]" */ + +#endif + +#define netstat_trivial_usage \ + "[-laentuwxr"USE_FEATURE_NETSTAT_WIDE("W")USE_FEATURE_NETSTAT_PRG("p")"]" +#define netstat_full_usage "\n\n" \ + "Display networking information\n" \ + "\nOptions:" \ + "\n -l Display listening server sockets" \ + "\n -a Display all sockets (default: connected)" \ + "\n -e Display other/more information" \ + "\n -n Don't resolve names" \ + "\n -t Tcp sockets" \ + "\n -u Udp sockets" \ + "\n -w Raw sockets" \ + "\n -x Unix sockets" \ + "\n -r Display routing table" \ + USE_FEATURE_NETSTAT_WIDE( \ + "\n -W Display with no column truncation" \ + ) \ + USE_FEATURE_NETSTAT_PRG( \ + "\n -p Display PID/Program name for sockets" \ + ) + +#define nice_trivial_usage \ + "[-n ADJUST] [COMMAND [ARG]...]" +#define nice_full_usage "\n\n" \ + "Run a program with modified scheduling priority\n" \ + "\nOptions:" \ + "\n -n ADJUST Adjust the scheduling priority by ADJUST" \ + +#define nmeter_trivial_usage \ + "format_string" +#define nmeter_full_usage "\n\n" \ + "Monitor system in real time\n\n" \ + "Format specifiers:\n" \ + "%Nc or %[cN] Monitor CPU. N - bar size, default 10\n" \ + " (displays: S:system U:user N:niced D:iowait I:irq i:softirq)\n" \ + "%[niface] Monitor network interface 'iface'\n" \ + "%m Monitor allocated memory\n" \ + "%[mf] Monitor free memory\n" \ + "%[mt] Monitor total memory\n" \ + "%s Monitor allocated swap\n" \ + "%f Monitor number of used file descriptors\n" \ + "%Ni Monitor total/specific IRQ rate\n" \ + "%x Monitor context switch rate\n" \ + "%p Monitor forks\n" \ + "%[pn] Monitor # of processes\n" \ + "%b Monitor block io\n" \ + "%Nt Show time (with N decimal points)\n" \ + "%Nd Milliseconds between updates (default=1000)\n" \ + "%r Print <cr> instead of <lf> at EOL" \ + +#define nmeter_example_usage \ + "nmeter '%250d%t %20c int %i bio %b mem %m forks%p'" + +#define nohup_trivial_usage \ + "COMMAND [ARGS]" +#define nohup_full_usage "\n\n" \ + "Run a command immune to hangups, with output to a non-tty" +#define nohup_example_usage \ + "$ nohup make &" + +#define nslookup_trivial_usage \ + "[HOST] [SERVER]" +#define nslookup_full_usage "\n\n" \ + "Query the nameserver for the IP address of the given HOST\n" \ + "optionally using a specified DNS server" +#define nslookup_example_usage \ + "$ nslookup localhost\n" \ + "Server: default\n" \ + "Address: default\n" \ + "\n" \ + "Name: debian\n" \ + "Address: 127.0.0.1\n" + +#define od_trivial_usage \ + "[-aBbcDdeFfHhIiLlOovXx] " USE_DESKTOP("[-t TYPE] ") "[FILE]" +#define od_full_usage "\n\n" \ + "Write an unambiguous representation, octal bytes by default, of FILE\n" \ + "to standard output. With no FILE or when FILE is -, read standard input." + +#define openvt_trivial_usage \ + "[-c NUM] [-sw] [COMMAND [ARGS]]" +#define openvt_full_usage "\n\n" \ + "Start COMMAND on a new virtual terminal\n" \ + "\nOptions:" \ + "\n -c Use specified VT" \ + "\n -s Switch to the VT" \ +/* "\n -l Run COMMAND as login shell (by prepending '-')" */ \ + "\n -w Wait for COMMAND to exit" \ + +#define openvt_example_usage \ + "openvt 2 /bin/ash\n" + +#define parse_trivial_usage \ + "[-n maxtokens] [-m mintokens] [-d delims] [-f flags] file ..." +#define parse_full_usage "\n\n" \ + "[-n maxtokens] [-m mintokens] [-d delims] [-f flags] file ..." + +#define passwd_trivial_usage \ + "[OPTION] [name]" +#define passwd_full_usage "\n\n" \ + "Change user's password. If no name is specified,\n" \ + "changes the password for the current user.\n" \ + "\nOptions:" \ + "\n -a Algorithm to use for password (choices: des, md5)" /* ", sha1)" */ \ + "\n -d Delete password for the account" \ + "\n -l Lock (disable) account" \ + "\n -u Unlock (re-enable) account" \ + +#define chpasswd_trivial_usage \ + USE_GETOPT_LONG("[--md5|--encrypted]") SKIP_GETOPT_LONG("[-m|-e]") +#define chpasswd_full_usage "\n\n" \ + "Read user:password information from stdin " \ + "and update /etc/passwd accordingly.\n" \ + "\nOptions:" \ + USE_GETOPT_LONG( \ + "\n -e,--encrypted Supplied passwords are in encrypted form" \ + "\n -m,--md5 Use MD5 encryption instead of DES" \ + ) \ + SKIP_GETOPT_LONG( \ + "\n -e Supplied passwords are in encrypted form" \ + "\n -m Use MD5 encryption instead of DES" \ + ) + +#define patch_trivial_usage \ + "[-p NUM] [-i DIFF] [-R]" +#define patch_full_usage "\n\n" \ + " -p NUM Strip NUM leading components from file names" \ + "\n -i DIFF Read DIFF instead of stdin" \ + "\n -R Reverse patch" \ + +#define patch_example_usage \ + "$ patch -p1 < example.diff\n" \ + "$ patch -p0 -i example.diff" + +#define pgrep_trivial_usage \ + "[-flnovx] pattern" +#define pgrep_full_usage "\n\n" \ + "Display process(es) selected by regex pattern\n" \ + "\nOptions:" \ + "\n -l Show command name too" \ + "\n -f Match against entire command line" \ + "\n -n Show the newest process only" \ + "\n -o Show the oldest process only" \ + "\n -v Negate the matching" \ + "\n -x Match whole name (not substring)" \ + +#if (ENABLE_FEATURE_PIDOF_SINGLE || ENABLE_FEATURE_PIDOF_OMIT) +#define pidof_trivial_usage \ + "[OPTION] [NAME...]" +#define USAGE_PIDOF "\n\nOptions:" +#else +#define pidof_trivial_usage \ + "[NAME...]" +#define USAGE_PIDOF /* none */ +#endif +#define pidof_full_usage "\n\n" \ + "List PIDs of all processes with names that match NAMEs" \ + USAGE_PIDOF \ + USE_FEATURE_PIDOF_SINGLE( \ + "\n -s Show only one PID") \ + USE_FEATURE_PIDOF_OMIT( \ + "\n -o PID Omit given pid" \ + "\n Use %PPID to omit pid of pidof's parent") \ + +#define pidof_example_usage \ + "$ pidof init\n" \ + "1\n" \ + USE_FEATURE_PIDOF_OMIT( \ + "$ pidof /bin/sh\n20351 5973 5950\n") \ + USE_FEATURE_PIDOF_OMIT( \ + "$ pidof /bin/sh -o %PPID\n20351 5950") + +#if !ENABLE_FEATURE_FANCY_PING +#define ping_trivial_usage \ + "host" +#define ping_full_usage "\n\n" \ + "Send ICMP ECHO_REQUEST packets to network hosts" +#define ping6_trivial_usage \ + "host" +#define ping6_full_usage "\n\n" \ + "Send ICMP ECHO_REQUEST packets to network hosts" +#else +#define ping_trivial_usage \ + "[OPTION]... host" +#define ping_full_usage "\n\n" \ + "Send ICMP ECHO_REQUEST packets to network hosts\n" \ + "\nOptions:" \ + "\n -4, -6 Force IPv4 or IPv6 hostname resolution" \ + "\n -c CNT Send only CNT pings" \ + "\n -s SIZE Send SIZE data bytes in packets (default=56)" \ + "\n -I iface/IP Use interface or IP address as source" \ + "\n -W timeout Seconds to wait for the first response (default:10)" \ + "\n (after all -c CNT packets are sent)" \ + "\n -w deadline Seconds until ping exits (default:infinite)" \ + "\n (can exit earlier with -c CNT)" \ + "\n -q Quiet, only displays output at start" \ + "\n and when finished" \ + +#define ping6_trivial_usage \ + "[OPTION]... host" +#define ping6_full_usage "\n\n" \ + "Send ICMP ECHO_REQUEST packets to network hosts\n" \ + "\nOptions:" \ + "\n -c CNT Send only CNT pings" \ + "\n -s SIZE Send SIZE data bytes in packets (default=56)" \ + "\n -I iface/IP Use interface or IP address as source" \ + "\n -q Quiet, only displays output at start" \ + "\n and when finished" \ + +#endif +#define ping_example_usage \ + "$ ping localhost\n" \ + "PING slag (127.0.0.1): 56 data bytes\n" \ + "64 bytes from 127.0.0.1: icmp_seq=0 ttl=255 time=20.1 ms\n" \ + "\n" \ + "--- debian ping statistics ---\n" \ + "1 packets transmitted, 1 packets received, 0% packet loss\n" \ + "round-trip min/avg/max = 20.1/20.1/20.1 ms\n" +#define ping6_example_usage \ + "$ ping6 ip6-localhost\n" \ + "PING ip6-localhost (::1): 56 data bytes\n" \ + "64 bytes from ::1: icmp6_seq=0 ttl=64 time=20.1 ms\n" \ + "\n" \ + "--- ip6-localhost ping statistics ---\n" \ + "1 packets transmitted, 1 packets received, 0% packet loss\n" \ + "round-trip min/avg/max = 20.1/20.1/20.1 ms\n" + +#define pipe_progress_trivial_usage NOUSAGE_STR +#define pipe_progress_full_usage "" + +#define pivot_root_trivial_usage \ + "NEW_ROOT PUT_OLD" +#define pivot_root_full_usage "\n\n" \ + "Move the current root file system to PUT_OLD and make NEW_ROOT\n" \ + "the new root file system" + +#define pkill_trivial_usage \ + "[-l] | [-fnovx] [-signal] pattern" +#define pkill_full_usage "\n\n" \ + "Send a signal to process(es) selected by regex pattern\n" \ + "\nOptions:" \ + "\n -l List all signals" \ + "\n -f Match against entire command line" \ + "\n -n Signal the newest process only" \ + "\n -o Signal the oldest process only" \ + "\n -v Negate the matching" \ + "\n -x Match whole name (not substring)" \ + +#define popmaildir_trivial_usage \ + "[OPTIONS] Maildir [connection-helper ...]" +#define popmaildir_full_usage "\n\n" \ + "Fetch content of remote mailbox to local maildir\n" \ + "\nOptions:" \ + "\n -b Binary mode. Ignored" \ + "\n -d Debug. Ignored" \ + "\n -m Show used memory. Ignored" \ + "\n -V Show version. Ignored" \ + "\n -c Use tcpclient. Ignored" \ + "\n -a Use APOP protocol. Implied. If server supports APOP -> use it" \ + "\n -s Skip authorization" \ + "\n -T Get messages with TOP instead with RETR" \ + "\n -k Keep retrieved messages on the server" \ + "\n -t timeout Set network timeout" \ + USE_FEATURE_POPMAILDIR_DELIVERY( \ + "\n -F \"program arg1 arg2 ...\" Filter by program. May be multiple" \ + "\n -M \"program arg1 arg2 ...\" Deliver by program" \ + ) \ + "\n -R size Remove old messages on the server >= size (in bytes). Ignored" \ + "\n -Z N1-N2 Remove messages from N1 to N2 (dangerous). Ignored" \ + "\n -L size Do not retrieve new messages >= size (in bytes). Ignored" \ + "\n -H lines Type specified number of lines of a message. Ignored" +#define popmaildir_example_usage \ + "$ popmaildir -k ~/Maildir -- nc pop.drvv.ru 110 [<password_file]\n" \ + "$ popmaildir ~/Maildir -- openssl s_client -quiet -connect pop.gmail.com:995 [<password_file]\n" + +#define poweroff_trivial_usage \ + "[-d delay] [-n] [-f]" +#define poweroff_full_usage "\n\n" \ + "Halt and shut off power\n" \ + "\nOptions:" \ + "\n -d Delay interval for halting" \ + "\n -n No call to sync()" \ + "\n -f Force power off (don't go through init)" \ + +#define printenv_trivial_usage \ + "[VARIABLES...]" +#define printenv_full_usage "\n\n" \ + "Print all or part of environment.\n" \ + "If no environment VARIABLE specified, print them all." + +#define printf_trivial_usage \ + "FORMAT [ARGUMENT...]" +#define printf_full_usage "\n\n" \ + "Format and print ARGUMENT(s) according to FORMAT,\n" \ + "where FORMAT controls the output exactly as in C printf" +#define printf_example_usage \ + "$ printf \"Val=%d\\n\" 5\n" \ + "Val=5\n" + + +#if ENABLE_DESKTOP + +#define ps_trivial_usage \ + "" +#define ps_full_usage "\n\n" \ + "Report process status\n" \ + "\nOptions:" \ + "\n -o col1,col2=header Select columns for display" \ + +#else /* !ENABLE_DESKTOP */ + +#if !ENABLE_SELINUX && !ENABLE_FEATURE_PS_WIDE +#define USAGE_PS "\nThis version of ps accepts no options" +#else +#define USAGE_PS "\nOptions:" +#endif + +#define ps_trivial_usage \ + "" +#define ps_full_usage "\n\n" \ + "Report process status\n" \ + USAGE_PS \ + USE_SELINUX( \ + "\n -Z Show SE Linux context" \ + ) \ + USE_FEATURE_PS_WIDE( \ + "\n w Wide output" \ + ) + +#endif /* ENABLE_DESKTOP */ + +#define ps_example_usage \ + "$ ps\n" \ + " PID Uid Gid State Command\n" \ + " 1 root root S init\n" \ + " 2 root root S [kflushd]\n" \ + " 3 root root S [kupdate]\n" \ + " 4 root root S [kpiod]\n" \ + " 5 root root S [kswapd]\n" \ + " 742 andersen andersen S [bash]\n" \ + " 743 andersen andersen S -bash\n" \ + " 745 root root S [getty]\n" \ + " 2990 andersen andersen R ps\n" \ + +#define pscan_trivial_usage \ + "[-cb] [-p MIN_PORT] [-P MAX_PORT] [-t TIMEOUT] [-T MIN_RTT] HOST" +#define pscan_full_usage "\n\n" \ + "Scan a host, print all open ports\n" \ + "\nOptions:" \ + "\n -c Show closed ports too" \ + "\n -b Show blocked ports too" \ + "\n -p Scan from this port (default 1)" \ + "\n -P Scan up to this port (default 1024)" \ + "\n -t Timeout (default 5000 ms)" \ + "\n -T Minimum rtt (default 5 ms, increase for congested hosts)" \ + +#define pwd_trivial_usage \ + "" +#define pwd_full_usage "\n\n" \ + "Print the full filename of the current working directory" +#define pwd_example_usage \ + "$ pwd\n" \ + "/root\n" + +#define raidautorun_trivial_usage \ + "DEVICE" +#define raidautorun_full_usage "\n\n" \ + "Tell the kernel to automatically search and start RAID arrays" +#define raidautorun_example_usage \ + "$ raidautorun /dev/md0" + +#define rdate_trivial_usage \ + "[-sp] HOST" +#define rdate_full_usage "\n\n" \ + "Get and possibly set the system date and time from a remote HOST\n" \ + "\nOptions:" \ + "\n -s Set the system date and time (default)" \ + "\n -p Print the date and time" \ + +#define rdev_trivial_usage \ + "" +#define rdev_full_usage "\n\n" \ + "Print the device node associated with the filesystem mounted at '/'" +#define rdev_example_usage \ + "$ rdev\n" \ + "/dev/mtdblock9 /\n" + +#define readahead_trivial_usage \ + "[FILE]..." +#define readahead_full_usage "\n\n" \ + "Preload FILE(s) in RAM cache so that subsequent reads for those" \ + "files do not block on disk I/O" + +#define readlink_trivial_usage \ + USE_FEATURE_READLINK_FOLLOW("[-f] ") "FILE" +#define readlink_full_usage "\n\n" \ + "Display the value of a symlink" \ + USE_FEATURE_READLINK_FOLLOW( "\n" \ + "\nOptions:" \ + "\n -f Canonicalize by following all symlinks") \ + +#define readprofile_trivial_usage \ + "[OPTIONS]..." +#define readprofile_full_usage "\n\n" \ + "Options:" \ + "\n -m mapfile (Default: /boot/System.map)" \ + "\n -p profile (Default: /proc/profile)" \ + "\n -M mult Set the profiling multiplier to mult" \ + "\n -i Print only info about the sampling step" \ + "\n -v Verbose" \ + "\n -a Print all symbols, even if count is 0" \ + "\n -b Print individual histogram-bin counts" \ + "\n -s Print individual counters within functions" \ + "\n -r Reset all the counters (root only)" \ + "\n -n Disable byte order auto-detection" \ + +#define realpath_trivial_usage \ + "pathname..." +#define realpath_full_usage "\n\n" \ + "Return the absolute pathnames of given argument" + +#define reboot_trivial_usage \ + "[-d delay] [-n] [-f]" +#define reboot_full_usage "\n\n" \ + "Reboot the system\n" \ + "\nOptions:" \ + "\n -d Delay interval for rebooting" \ + "\n -n No call to sync()" \ + "\n -f Force reboot (don't go through init)" \ + +#define reformime_trivial_usage \ + "[OPTION]... [FILE]..." +#define reformime_full_usage "\n\n" \ + "Parse MIME-encoded message\n" \ + "\nOptions:" \ + "\n -x prefix Extract content of MIME sections to files" \ + "\n -X prog [args] Filter content of MIME sections through prog." \ + "\n Must be the last option" \ + "\n" \ + "\nOther options are silently ignored." \ + +#define renice_trivial_usage \ + "{{-n INCREMENT} | PRIORITY} [[-p | -g | -u] ID...]" +#define renice_full_usage "\n\n" \ + "Change priority of running processes\n" \ + "\nOptions:" \ + "\n -n Adjust current nice value (smaller is faster)" \ + "\n -p Process id(s) (default)" \ + "\n -g Process group id(s)" \ + "\n -u Process user name(s) and/or id(s)" \ + +#define reset_trivial_usage \ + "" +#define reset_full_usage "\n\n" \ + "Reset the screen" + +#define resize_trivial_usage \ + "" +#define resize_full_usage "\n\n" \ + "Resize the screen" + +#define restorecon_trivial_usage \ + "[-iFnrRv] [-e excludedir]... [-o filename] [-f filename | pathname]" +#define restorecon_full_usage "\n\n" \ + "Reset security contexts of files in pathname\n" \ + "\n -i Ignore files that do not exist" \ + "\n -f file File with list of files to process. Use - for stdin" \ + "\n -e directory Directory to exclude" \ + "\n -R,-r Recurse directories" \ + "\n -n Don't change any file labels" \ + "\n -o file Save list of files with incorrect context" \ + "\n -v Verbose" \ + "\n -vv Show changed labels" \ + "\n -F Force reset of context to match file_context" \ + "\n for customizable files, or the user section," \ + "\n if it has changed" \ + +#define rm_trivial_usage \ + "[OPTION]... FILE..." +#define rm_full_usage "\n\n" \ + "Remove (unlink) the FILE(s). Use '--' to\n" \ + "indicate that all following arguments are non-options.\n" \ + "\nOptions:" \ + "\n -i Always prompt before removing" \ + "\n -f Never prompt" \ + "\n -r,-R Remove directories recursively" \ + +#define rm_example_usage \ + "$ rm -rf /tmp/foo\n" + +#define rmdir_trivial_usage \ + "[OPTION]... DIRECTORY..." +#define rmdir_full_usage "\n\n" \ + "Remove the DIRECTORY, if it is empty.\n" \ + "\nOptions:" \ + USE_FEATURE_RMDIR_LONG_OPTIONS( \ + "\n -p|--parents Include parents" \ + "\n -ignore-fail-on-non-empty" \ + ) \ + SKIP_FEATURE_RMDIR_LONG_OPTIONS( \ + "\n -p Include parents" \ + ) + +#define rmdir_example_usage \ + "# rmdir /tmp/foo\n" + +#define rmmod_trivial_usage \ + "[OPTION]... [MODULE]..." +#define rmmod_full_usage "\n\n" \ + "Unload the specified kernel modules from the kernel\n" \ + "\nOptions:" \ + "\n -w Wait until the module is no longer used" \ + "\n -f Force unloading" \ + "\n -a Remove all unused modules (recursively)" \ + +#define rmmod_example_usage \ + "$ rmmod tulip\n" + +#define route_trivial_usage \ + "[{add|del|delete}]" +#define route_full_usage "\n\n" \ + "Edit kernel routing tables\n" \ + "\nOptions:" \ + "\n -n Don't resolve names" \ + "\n -e Display other/more information" \ + "\n -A inet" USE_FEATURE_IPV6("{6}") " Select address family" \ + +#define rpm_trivial_usage \ + "-i -q[ildc]p package.rpm" +#define rpm_full_usage "\n\n" \ + "Manipulate RPM packages\n" \ + "\nOptions:" \ + "\n -i Install package" \ + "\n -q Query package" \ + "\n -p Query uninstalled package" \ + "\n -i Show information" \ + "\n -l List contents" \ + "\n -d List documents" \ + "\n -c List config files" \ + +#define rpm2cpio_trivial_usage \ + "package.rpm" +#define rpm2cpio_full_usage "\n\n" \ + "Output a cpio archive of the rpm file" + +#define rtcwake_trivial_usage \ + "[-a | -l | -u] [-d DEV] [-m MODE] [-s SECS | -t TIME]" +#define rtcwake_full_usage "\n\n" \ + "Enter a system sleep state until specified wakeup time\n" \ + USE_GETOPT_LONG( \ + "\n -a,--auto Read clock mode from adjtime" \ + "\n -l,--local Clock is set to local time" \ + "\n -u,--utc Clock is set to UTC time" \ + "\n -d,--device=DEV Specify the RTC device" \ + "\n -m,--mode=MODE Set the sleep state (default: standby)" \ + "\n -s,--seconds=SEC Set the timeout in SEC seconds from now" \ + "\n -t,--time=TIME Set the timeout to TIME seconds from epoch" \ + ) \ + SKIP_GETOPT_LONG( \ + "\n -a Read clock mode from adjtime" \ + "\n -l Clock is set to local time" \ + "\n -u Clock is set to UTC time" \ + "\n -d DEV Specify the RTC device" \ + "\n -m MODE Set the sleep state (default: standby)" \ + "\n -s SEC Set the timeout in SEC seconds from now" \ + "\n -t TIME Set the timeout to TIME seconds from epoch" \ + ) + +#define runcon_trivial_usage \ + "[-c] [-u USER] [-r ROLE] [-t TYPE] [-l RANGE] COMMAND [args]\n" \ + " runcon CONTEXT COMMAND [args]" +#define runcon_full_usage "\n\n" \ + "Run a program in a different security context\n" \ + "\n CONTEXT Complete security context\n" \ + USE_FEATURE_RUNCON_LONG_OPTIONS( \ + "\n -c,--compute Compute process transition context before modifying" \ + "\n -t,--type=TYPE Type (for same role as parent)" \ + "\n -u,--user=USER User identity" \ + "\n -r,--role=ROLE Role" \ + "\n -l,--range=RNG Levelrange" \ + ) \ + SKIP_FEATURE_RUNCON_LONG_OPTIONS( \ + "\n -c Compute process transition context before modifying" \ + "\n -t TYPE Type (for same role as parent)" \ + "\n -u USER User identity" \ + "\n -r ROLE Role" \ + "\n -l RNG Levelrange" \ + ) + +#define run_parts_trivial_usage \ + "[-t] "USE_FEATURE_RUN_PARTS_FANCY("[-l] ")"[-a ARG] [-u MASK] DIRECTORY" +#define run_parts_full_usage "\n\n" \ + "Run a bunch of scripts in a directory\n" \ + "\nOptions:" \ + "\n -t Print what would be run, but don't actually run anything" \ + "\n -a ARG Pass ARG as argument for every program" \ + "\n -u MASK Set the umask to MASK before running every program" \ + USE_FEATURE_RUN_PARTS_FANCY( \ + "\n -l Print names of all matching files even if they are not executable" \ + ) + +#define run_parts_example_usage \ + "$ run-parts -a start /etc/init.d\n" \ + "$ run-parts -a stop=now /etc/init.d\n\n" \ + "Let's assume you have a script foo/dosomething:\n" \ + "#!/bin/sh\n" \ + "for i in $*; do eval $i; done; unset i\n" \ + "case \"$1\" in\n" \ + "start*) echo starting something;;\n" \ + "stop*) set -x; shutdown -h $stop;;\n" \ + "esac\n\n" \ + "Running this yields:\n" \ + "$run-parts -a stop=+4m foo/\n" \ + "+ shutdown -h +4m" + +#define runlevel_trivial_usage \ + "[utmp]" +#define runlevel_full_usage "\n\n" \ + "Find the current and previous system runlevel.\n\n" \ + "If no utmp file exists or if no runlevel record can be found,\n" \ + "print \"unknown\"" +#define runlevel_example_usage \ + "$ runlevel /var/run/utmp\n" \ + "N 2" + +#define runsv_trivial_usage \ + "dir" +#define runsv_full_usage "\n\n" \ + "Start and monitor a service and optionally an appendant log service" + +#define runsvdir_trivial_usage \ + "[-P] [-s SCRIPT] dir" +#define runsvdir_full_usage "\n\n" \ + "Start a runsv process for each subdirectory. If it exits, restart it.\n" \ + "\n -P Put each runsv in a new session" \ + "\n -s SCRIPT Run SCRIPT <signo> after signal is processed" \ + +#define rx_trivial_usage \ + "FILE" +#define rx_full_usage "\n\n" \ + "Receive a file using the xmodem protocol" +#define rx_example_usage \ + "$ rx /tmp/foo\n" + +#define script_trivial_usage \ + "[-afq] [-c COMMAND] [OUTFILE]" +#define script_full_usage "\n\n" \ + "Options:" \ + "\n -a Append output" \ + "\n -c Run COMMAND, not shell" \ + "\n -f Flush output after each write" \ + "\n -q Quiet" \ + +#define sed_trivial_usage \ + "[-efinr] pattern [files...]" +#define sed_full_usage "\n\n" \ + "Options:" \ + "\n -e script Add the script to the commands to be executed" \ + "\n -f scriptfile Add scriptfile contents to the" \ + "\n commands to be executed" \ + "\n -i Edit files in-place" \ + "\n -n Suppress automatic printing of pattern space" \ + "\n -r Use extended regular expression syntax" \ + "\n" \ + "\nIf no -e or -f is given, the first non-option argument is taken as the sed" \ + "\nscript to interpret. All remaining arguments are names of input files; if no" \ + "\ninput files are specified, then the standard input is read. Source files" \ + "\nwill not be modified unless -i option is given." \ + +#define sed_example_usage \ + "$ echo \"foo\" | sed -e 's/f[a-zA-Z]o/bar/g'\n" \ + "bar\n" + +#define selinuxenabled_trivial_usage NOUSAGE_STR +#define selinuxenabled_full_usage "" + +#define sendmail_trivial_usage \ + "[OPTIONS] [rcpt]..." +#define sendmail_full_usage "\n\n" \ + "Send an email\n" \ + "\nOptions:" \ + "\n -w timeout Network timeout" \ + "\n -H [user:pass@]server[:port] Server" \ + "\n -S Use openssl connection helper for secure servers" \ + "\n -N type Request delivery notification. Type is ignored" \ + "\n -f sender Sender" \ + "\n -F fullname Sender full name. Overrides $NAME" \ + USE_FEATURE_SENDMAIL_MAILX( \ + "\n -s subject Subject" \ + "\n -j charset Assume charset for body and subject (" CONFIG_FEATURE_MIME_CHARSET ")" \ + "\n -a file File to attach. May be multiple" \ + "\n -H \"prog args...\" Use external connection helper. E.g. openssl for secure servers" \ + "\n -S server[:port] Server" \ + ) \ + USE_FEATURE_SENDMAIL_MAILXX( \ + "\n -c rcpt Cc: recipient. May be multiple" \ + "\n -e rcpt Errors-To: recipient" \ + ) + "\n -t Read recipients and subject from body" \ + "\n" \ + "\nOther options are silently ignored; -oi is implied" \ + +#define seq_trivial_usage \ + "[first [increment]] last" +#define seq_full_usage "\n\n" \ + "Print numbers from FIRST to LAST, in steps of INCREMENT.\n" \ + "FIRST, INCREMENT default to 1\n" \ + "\nArguments:" \ + "\n LAST" \ + "\n FIRST LAST" \ + "\n FIRST INCREMENT LAST" \ + +#define sestatus_trivial_usage \ + "[-vb]" +#define sestatus_full_usage "\n\n" \ + " -v Verbose" \ + "\n -b Display current state of booleans" \ + +#define setconsole_trivial_usage \ + "[-r" USE_FEATURE_SETCONSOLE_LONG_OPTIONS("|--reset") "] [DEVICE]" +#define setconsole_full_usage "\n\n" \ + "Redirect system console output to DEVICE (default: /dev/tty)\n" \ + "\nOptions:" \ + "\n -r Reset output to /dev/console" \ + +#define setenforce_trivial_usage \ + "[Enforcing | Permissive | 1 | 0]" +#define setenforce_full_usage "" + +#define setfiles_trivial_usage \ + "[-dnpqsvW] [-e dir]... [-o file] [-r alt_root_path]" \ + USE_FEATURE_SETFILES_CHECK_OPTION( \ + " [-c policyfile] spec_file" \ + ) \ + " pathname" +#define setfiles_full_usage "\n\n" \ + "Reset file contexts under pathname according to spec_file\n" \ + USE_FEATURE_SETFILES_CHECK_OPTION( \ + "\n -c file Check the validity of the contexts against the specified binary policy" \ + ) \ + "\n -d Show which specification matched each file" \ + "\n -l Log changes in file labels to syslog" \ + "\n -n Don't change any file labels" \ + "\n -q Suppress warnings" \ + "\n -r dir Use an altenate root path" \ + "\n -e dir Exclude directory" \ + "\n -F Force reset of context to match file_context for customizable files" \ + "\n -o file Save list of files with incorrect context" \ + "\n -s Take a list of files from standard input (instead of command line)" \ + "\n -v Show changes in file labels, if type or role are changing" \ + "\n -vv Show changes in file labels, if type, role, or user are changing" \ + "\n -W Display warnings about entries that had no matching files" \ + +#define setfont_trivial_usage \ + "FONT [-m MAPFILE] [-C TTY]" +#define setfont_full_usage "\n\n" \ + "Load a console font\n" \ + "\nOptions:" \ + "\n -m MAPFILE Load console screen map" \ + "\n -C TTY Affect TTY instead of /dev/tty" \ + +#define setfont_example_usage \ + "$ setfont -m koi8-r /etc/i18n/fontname\n" + +#define setkeycodes_trivial_usage \ + "SCANCODE KEYCODE..." +#define setkeycodes_full_usage "\n\n" \ + "Set entries into the kernel's scancode-to-keycode map,\n" \ + "allowing unusual keyboards to generate usable keycodes.\n\n" \ + "SCANCODE may be either xx or e0xx (hexadecimal),\n" \ + "and KEYCODE is given in decimal" \ + +#define setkeycodes_example_usage \ + "$ setkeycodes e030 127\n" + +#define setlogcons_trivial_usage \ + "N" +#define setlogcons_full_usage "\n\n" \ + "Redirect the kernel output to console N (0 for current)" + +#define setsebool_trivial_usage \ + "boolean value" + +#define setsebool_full_usage "\n\n" \ + "Change boolean setting" + +#define setsid_trivial_usage \ + "PROG [ARG...]" +#define setsid_full_usage "\n\n" \ + "Run PROG in a new session. PROG will have no controlling terminal\n" \ + "and will not be affected by keyboard signals (Ctrl-C etc).\n" \ + "See setsid(2) for details." \ + +#define lash_trivial_usage \ + "[FILE]...\n" \ + "or: sh -c command [args]..." +#define lash_full_usage "\n\n" \ + "lash is deprecated, please use hush" + +#define last_trivial_usage \ + ""USE_FEATURE_LAST_FANCY("[-HW] [-f file]") +#define last_full_usage "\n\n" \ + "Show listing of the last users that logged into the system" \ + USE_FEATURE_LAST_FANCY( "\n" \ + "\nOptions:" \ +/* "\n -H Show header line" */ \ + "\n -W Display with no host column truncation" \ + "\n -f file Read from file instead of /var/log/wtmp" \ + ) + +#define sha1sum_trivial_usage \ + "[OPTION] [FILEs...]" \ + USE_FEATURE_MD5_SHA1_SUM_CHECK("\n or: sha1sum [OPTION] -c [FILE]") +#define sha1sum_full_usage "\n\n" \ + "Print" USE_FEATURE_MD5_SHA1_SUM_CHECK(" or check") " SHA1 checksums." \ + USE_FEATURE_MD5_SHA1_SUM_CHECK( "\n" \ + "\nOptions:" \ + "\n -c Check SHA1 sums against given list" \ + "\n -s Don't output anything, status code shows success" \ + "\n -w Warn about improperly formatted SHA1 checksum lines" \ + ) + +#define showkey_trivial_usage \ + "[-a | -k | -s]" +#define showkey_full_usage "\n\n" \ + "Show keys pressed\n" \ + "\nOptions:" \ + "\n -a Display decimal/octal/hex values of the keys" \ + "\n -k Display interpreted keycodes (default)" \ + "\n -s Display raw scan-codes" \ + +#define slattach_trivial_usage \ + "[-cehmLF] [-s speed] [-p protocol] DEVICEs" +#define slattach_full_usage "\n\n" \ + "Attach network interface(s) to serial line(s)\n" \ + "\nOptions:" \ + "\n -p Set protocol (slip, cslip, slip6, clisp6 or adaptive)" \ + "\n -s Set line speed" \ + "\n -e Exit after initializing device" \ + "\n -h Exit when the carrier is lost" \ + "\n -c Execute a command when the line is hung up" \ + "\n -m Do NOT initialize the line in raw 8 bits mode" \ + "\n -L Enable 3-wire operation" \ + "\n -F Disable RTS/CTS flow control" \ + +#define sleep_trivial_usage \ + USE_FEATURE_FANCY_SLEEP("[") "N" USE_FEATURE_FANCY_SLEEP("]...") +#define sleep_full_usage "\n\n" \ + SKIP_FEATURE_FANCY_SLEEP("Pause for N seconds") \ + USE_FEATURE_FANCY_SLEEP( \ + "Pause for a time equal to the total of the args given, where each arg can\n" \ + "have an optional suffix of (s)econds, (m)inutes, (h)ours, or (d)ays") +#define sleep_example_usage \ + "$ sleep 2\n" \ + "[2 second delay results]\n" \ + USE_FEATURE_FANCY_SLEEP( \ + "$ sleep 1d 3h 22m 8s\n" \ + "[98528 second delay results]\n") + +#define sort_trivial_usage \ + "[-nru" \ + USE_FEATURE_SORT_BIG("gMcszbdfimSTokt] [-o FILE] [-k start[.offset][opts][,end[.offset][opts]] [-t CHAR") \ + "] [FILE]..." +#define sort_full_usage "\n\n" \ + "Sort lines of text\n" \ + "\nOptions:" \ + USE_FEATURE_SORT_BIG( \ + "\n -b Ignore leading blanks" \ + "\n -c Check whether input is sorted" \ + "\n -d Dictionary order (blank or alphanumeric only)" \ + "\n -f Ignore case" \ + "\n -g General numerical sort" \ + "\n -i Ignore unprintable characters" \ + "\n -k Sort key" \ + "\n -M Sort month" \ + ) \ + "\n -n Sort numbers" \ + USE_FEATURE_SORT_BIG( \ + "\n -o Output to file" \ + "\n -k Sort by key" \ + "\n -t CHAR Key separator" \ + ) \ + "\n -r Reverse sort order" \ + USE_FEATURE_SORT_BIG( \ + "\n -s Stable (don't sort ties alphabetically)" \ + ) \ + "\n -u Suppress duplicate lines" \ + USE_FEATURE_SORT_BIG( \ + "\n -z Lines are terminated by NUL, not newline" \ + "\n -mST Ignored for GNU compatibility") \ + +#define sort_example_usage \ + "$ echo -e \"e\\nf\\nb\\nd\\nc\\na\" | sort\n" \ + "a\n" \ + "b\n" \ + "c\n" \ + "d\n" \ + "e\n" \ + "f\n" \ + USE_FEATURE_SORT_BIG( \ + "$ echo -e \"c 3\\nb 2\\nd 2\" | $SORT -k 2,2n -k 1,1r\n" \ + "d 2\n" \ + "b 2\n" \ + "c 3\n" \ + ) \ + "" + +#define split_trivial_usage \ + "[OPTION] [INPUT [PREFIX]]" +#define split_full_usage "\n\n" \ + "Options:" \ + "\n -b n[k|m] Split by bytes" \ + "\n -l n Split by lines" \ + "\n -a n Use n letters as suffix" \ + +#define split_example_usage \ + "$ split TODO foo\n" \ + "$ cat TODO | split -a 2 -l 2 TODO_\n" + +#define start_stop_daemon_trivial_usage \ + "[OPTIONS] [-S|-K] ... [-- arguments...]" +#define start_stop_daemon_full_usage "\n\n" \ + "Search for matching processes, and then\n" \ + "-K: stop all matching processes.\n" \ + "-S: start a process unless a matching process is found.\n" \ + USE_FEATURE_START_STOP_DAEMON_LONG_OPTIONS( \ + "\nProcess matching:" \ + "\n -u,--user USERNAME|UID Match only this user's processes" \ + "\n -n,--name NAME Match processes with NAME" \ + "\n in comm field in /proc/PID/stat" \ + "\n -x,--exec EXECUTABLE Match processes with this command" \ + "\n in /proc/PID/cmdline" \ + "\n -p,--pidfile FILE Match a process with PID from the file" \ + "\n All specified conditions must match" \ + "\n-S only:" \ + "\n -x,--exec EXECUTABLE Program to run" \ + "\n -a,--startas NAME Zeroth argument" \ + "\n -b,--background Background" \ + USE_FEATURE_START_STOP_DAEMON_FANCY( \ + "\n -N,--nicelevel N Change nice level" \ + ) \ + "\n -c,--chuid USER[:[GRP]] Change to user/group" \ + "\n -m,--make-pidfile Write PID to the pidfile specified by -p" \ + "\n-K only:" \ + "\n -s,--signal SIG Signal to send" \ + "\n -t,--test Match only, exit with 0 if a process is found" \ + "\nOther:" \ + USE_FEATURE_START_STOP_DAEMON_FANCY( \ + "\n -o,--oknodo Exit with status 0 if nothing is done" \ + "\n -v,--verbose Verbose" \ + ) \ + "\n -q,--quiet Quiet" \ + ) \ + SKIP_FEATURE_START_STOP_DAEMON_LONG_OPTIONS( \ + "\nProcess matching:" \ + "\n -u USERNAME|UID Match only this user's processes" \ + "\n -n NAME Match processes with NAME" \ + "\n in comm field in /proc/PID/stat" \ + "\n -x EXECUTABLE Match processes with this command" \ + "\n command in /proc/PID/cmdline" \ + "\n -p FILE Match a process with PID from the file" \ + "\n All specified conditions must match" \ + "\n-S only:" \ + "\n -x EXECUTABLE Program to run" \ + "\n -a NAME Zeroth argument" \ + "\n -b Background" \ + USE_FEATURE_START_STOP_DAEMON_FANCY( \ + "\n -N N Change nice level" \ + ) \ + "\n -c USER[:[GRP]] Change to user/group" \ + "\n -m Write PID to the pidfile specified by -p" \ + "\n-K only:" \ + "\n -s SIG Signal to send" \ + "\n -t Match only, exit with 0 if a process is found" \ + "\nOther:" \ + USE_FEATURE_START_STOP_DAEMON_FANCY( \ + "\n -o Exit with status 0 if nothing is done" \ + "\n -v Verbose" \ + ) \ + "\n -q Quiet" \ + ) \ + +#define stat_trivial_usage \ + "[OPTION] FILE..." +#define stat_full_usage "\n\n" \ + "Display file (default) or filesystem status\n" \ + "\nOptions:" \ + USE_FEATURE_STAT_FORMAT( \ + "\n -c fmt Use the specified format" \ + ) \ + "\n -f Display filesystem status" \ + "\n -L Dereference links" \ + "\n -t Display info in terse form" \ + USE_SELINUX( \ + "\n -Z Print security context" \ + ) \ + USE_FEATURE_STAT_FORMAT( \ + "\n\nValid format sequences for files:\n" \ + " %a Access rights in octal\n" \ + " %A Access rights in human readable form\n" \ + " %b Number of blocks allocated (see %B)\n" \ + " %B The size in bytes of each block reported by %b\n" \ + " %d Device number in decimal\n" \ + " %D Device number in hex\n" \ + " %f Raw mode in hex\n" \ + " %F File type\n" \ + " %g Group ID of owner\n" \ + " %G Group name of owner\n" \ + " %h Number of hard links\n" \ + " %i Inode number\n" \ + " %n File name\n" \ + " %N Quoted file name with dereference if symlink\n" \ + " %o I/O block size\n" \ + " %s Total size, in bytes\n" \ + " %t Major device type in hex\n" \ + " %T Minor device type in hex\n" \ + " %u User ID of owner\n" \ + " %U User name of owner\n" \ + " %x Time of last access\n" \ + " %X Time of last access as seconds since Epoch\n" \ + " %y Time of last modification\n" \ + " %Y Time of last modification as seconds since Epoch\n" \ + " %z Time of last change\n" \ + " %Z Time of last change as seconds since Epoch\n" \ + "\nValid format sequences for file systems:\n" \ + " %a Free blocks available to non-superuser\n" \ + " %b Total data blocks in file system\n" \ + " %c Total file nodes in file system\n" \ + " %d Free file nodes in file system\n" \ + " %f Free blocks in file system\n" \ + USE_SELINUX( \ + " %C Security context in SELinux\n" \ + ) \ + " %i File System ID in hex\n" \ + " %l Maximum length of filenames\n" \ + " %n File name\n" \ + " %s Block size (for faster transfer)\n" \ + " %S Fundamental block size (for block counts)\n" \ + " %t Type in hex\n" \ + " %T Type in human readable form" \ + ) \ + +#define strings_trivial_usage \ + "[-afo] [-n length] [file...]" +#define strings_full_usage "\n\n" \ + "Display printable strings in a binary file\n" \ + "\nOptions:" \ + "\n -a Scan whole file (default)" \ + "\n -f Precede strings with filenames" \ + "\n -n N At least N characters form a string (default 4)" \ + "\n -o Precede strings with decimal offsets" \ + +#define stty_trivial_usage \ + "[-a|g] [-F DEVICE] [SETTING]..." +#define stty_full_usage "\n\n" \ + "Without arguments, prints baud rate, line discipline,\n" \ + "and deviations from stty sane\n" \ + "\nOptions:" \ + "\n -F DEVICE Open device instead of stdin" \ + "\n -a Print all current settings in human-readable form" \ + "\n -g Print in stty-readable form" \ + "\n [SETTING] See manpage" \ + +#define su_trivial_usage \ + "[OPTION]... [-] [username]" +#define su_full_usage "\n\n" \ + "Change user id or become root\n" \ + "\nOptions:" \ + "\n -p, -m Preserve environment" \ + "\n -c Command to pass to 'sh -c'" \ + "\n -s Shell to use instead of default shell" \ + +#define sulogin_trivial_usage \ + "[OPTION]... [tty-device]" +#define sulogin_full_usage "\n\n" \ + "Single user login\n" \ + "\nOptions:" \ + "\n -t Timeout" \ + +#define sum_trivial_usage \ + "[rs] [files...]" +#define sum_full_usage "\n\n" \ + "Checksum and count the blocks in a file\n" \ + "\nOptions:" \ + "\n -r Use BSD sum algorithm (1K blocks)" \ + "\n -s Use System V sum algorithm (512byte blocks)" \ + +#define sv_trivial_usage \ + "[-v] [-w sec] command service..." +#define sv_full_usage "\n\n" \ + "Control services monitored by runsv supervisor.\n" \ + "Commands (only first character is enough):\n" \ + "\n" \ + "status: query service status\n" \ + "up: if service isn't running, start it. If service stops, restart it\n" \ + "once: like 'up', but if service stops, don't restart it\n" \ + "down: send TERM and CONT signals. If ./run exits, start ./finish\n" \ + " if it exists. After it stops, do not restart service\n" \ + "exit: send TERM and CONT signals to service and log service. If they exit,\n" \ + " runsv exits too\n" \ + "pause, cont, hup, alarm, interrupt, quit, 1, 2, term, kill: send\n" \ + "STOP, CONT, HUP, ALRM, INT, QUIT, USR1, USR2, TERM, KILL signal to service" \ + +#define svlogd_trivial_usage \ + "[-ttv] [-r c] [-R abc] [-l len] [-b buflen] dir..." +#define svlogd_full_usage "\n\n" \ + "Continuously read log data from standard input, optionally " \ + "filter log messages, and write the data to one or more automatically " \ + "rotated logs" \ + +#define swapoff_trivial_usage \ + "[-a] [DEVICE]" +#define swapoff_full_usage "\n\n" \ + "Stop swapping on DEVICE\n" \ + "\nOptions:" \ + "\n -a Stop swapping on all swap devices" \ + +#define swapon_trivial_usage \ + "[-a]" USE_FEATURE_SWAPON_PRI(" [-p pri]") " [DEVICE]" +#define swapon_full_usage "\n\n" \ + "Start swapping on DEVICE\n" \ + "\nOptions:" \ + "\n -a Start swapping on all swap devices" \ + USE_FEATURE_SWAPON_PRI( \ + "\n -p pri Set swap device priority" \ + ) \ + +#define switch_root_trivial_usage \ + "[-c /dev/console] NEW_ROOT NEW_INIT [ARGUMENTS_TO_INIT]" +#define switch_root_full_usage "\n\n" \ + "Use from PID 1 under initramfs to free initramfs, chroot to NEW_ROOT,\n" \ + "and exec NEW_INIT\n" \ + "\nOptions:" \ + "\n -c Redirect console to device on new root" \ + +#define sync_trivial_usage \ + "" +#define sync_full_usage "\n\n" \ + "Write all buffered filesystem blocks to disk" + +#define sysctl_trivial_usage \ + "[OPTIONS]... [VALUE]..." +#define sysctl_full_usage "\n\n" \ + "Configure kernel parameters at runtime\n" \ + "\nOptions:" \ + "\n -n Disable printing of key names" \ + "\n -e Don't warn about unknown keys" \ + "\n -w Change sysctl setting" \ + "\n -p FILE Load sysctl settings from FILE (default /etc/sysctl.conf)" \ + "\n -a Display all values" \ + "\n -A Display all values in table form" \ + +#define sysctl_example_usage \ + "sysctl [-n] [-e] variable...\n" \ + "sysctl [-n] [-e] -w variable=value...\n" \ + "sysctl [-n] [-e] -a\n" \ + "sysctl [-n] [-e] -p file (default /etc/sysctl.conf)\n" \ + "sysctl [-n] [-e] -A\n" + +#define syslogd_trivial_usage \ + "[OPTION]..." +#define syslogd_full_usage "\n\n" \ + "System logging utility.\n" \ + "Note that this version of syslogd ignores /etc/syslog.conf.\n" \ + "\nOptions:" \ + "\n -n Run in foreground" \ + "\n -O FILE Log to given file (default=/var/log/messages)" \ + "\n -l n Set local log level" \ + "\n -S Smaller logging output" \ + USE_FEATURE_ROTATE_LOGFILE( \ + "\n -s SIZE Max size (KB) before rotate (default=200KB, 0=off)" \ + "\n -b NUM Number of rotated logs to keep (default=1, max=99, 0=purge)") \ + USE_FEATURE_REMOTE_LOG( \ + "\n -R HOST[:PORT] Log to IP or hostname on PORT (default PORT=514/UDP)" \ + "\n -L Log locally and via network (default is network only if -R)") \ + USE_FEATURE_SYSLOGD_DUP( \ + "\n -D Drop duplicates") \ + USE_FEATURE_IPC_SYSLOG( \ + "\n -C[size(KiB)] Log to shared mem buffer (read it using logread)") \ + /* NB: -Csize shouldn't have space (because size is optional) */ +/* "\n -m MIN Minutes between MARK lines (default=20, 0=off)" */ + +#define syslogd_example_usage \ + "$ syslogd -R masterlog:514\n" \ + "$ syslogd -R 192.168.1.1:601\n" + +#define tac_trivial_usage \ + "[FILE]..." +#define tac_full_usage "\n\n" \ + "Concatenate FILE(s) and print them in reverse" + +#define tail_trivial_usage \ + "[OPTION]... [FILE]..." +#define tail_full_usage "\n\n" \ + "Print last 10 lines of each FILE to standard output.\n" \ + "With more than one FILE, precede each with a header giving the\n" \ + "file name. With no FILE, or when FILE is -, read standard input.\n" \ + "\nOptions:" \ + USE_FEATURE_FANCY_TAIL( \ + "\n -c N[kbm] Output the last N bytes") \ + "\n -n N[kbm] Print last N lines instead of last 10" \ + "\n -f Output data as the file grows" \ + USE_FEATURE_FANCY_TAIL( \ + "\n -q Never output headers giving file names" \ + "\n -s SEC Wait SEC seconds between reads with -f" \ + "\n -v Always output headers giving file names" \ + "\n" \ + "\nIf the first character of N (bytes or lines) is a '+', output begins with" \ + "\nthe Nth item from the start of each file, otherwise, print the last N items" \ + "\nin the file. N bytes may be suffixed by k (x1024), b (x512), or m (1024^2)." ) \ + +#define tail_example_usage \ + "$ tail -n 1 /etc/resolv.conf\n" \ + "nameserver 10.0.0.1\n" + +#define tar_trivial_usage \ + "-[" USE_FEATURE_TAR_CREATE("c") USE_FEATURE_SEAMLESS_GZ("z") \ + USE_FEATURE_SEAMLESS_BZ2("j") USE_FEATURE_SEAMLESS_LZMA("a") \ + USE_FEATURE_SEAMLESS_Z("Z") "xtvO] " \ + USE_FEATURE_TAR_FROM("[-X FILE] ") \ + "[-f TARFILE] [-C DIR] [FILE(s)]..." +#define tar_full_usage "\n\n" \ + "Create, extract, or list files from a tar file\n" \ + "\nOptions:" \ + USE_FEATURE_TAR_CREATE( \ + "\n c Create") \ + "\n x Extract" \ + "\n t List" \ + "\nArchive format selection:" \ + USE_FEATURE_SEAMLESS_GZ( \ + "\n z Filter the archive through gzip" \ + ) \ + USE_FEATURE_SEAMLESS_BZ2( \ + "\n j Filter the archive through bzip2" \ + ) \ + USE_FEATURE_SEAMLESS_LZMA( \ + "\n a Filter the archive through lzma" \ + ) \ + USE_FEATURE_SEAMLESS_Z( \ + "\n Z Filter the archive through compress" \ + ) \ + "\nFile selection:" \ + "\n f Name of TARFILE or \"-\" for stdin" \ + "\n O Extract to stdout" \ + USE_FEATURE_TAR_FROM( \ + "\n exclude File to exclude" \ + "\n X File with names to exclude" \ + ) \ + "\n C Change to directory DIR before operation" \ + "\n v Verbose" \ + +#define tar_example_usage \ + "$ zcat /tmp/tarball.tar.gz | tar -xf -\n" \ + "$ tar -cf /tmp/tarball.tar /usr/local\n" + +#define taskset_trivial_usage \ + "[-p] [mask] [pid | command [arg]...]" +#define taskset_full_usage "\n\n" \ + "Set or get CPU affinity\n" \ + "\nOptions:" \ + "\n -p Operate on an existing PID" \ + +#define taskset_example_usage \ + "$ taskset 0x7 ./dgemm_test&\n" \ + "$ taskset -p 0x1 $!\n" \ + "pid 4790's current affinity mask: 7\n" \ + "pid 4790's new affinity mask: 1\n" \ + "$ taskset 0x7 /bin/sh -c './taskset -p 0x1 $$'\n" \ + "pid 6671's current affinity mask: 1\n" \ + "pid 6671's new affinity mask: 1\n" \ + "$ taskset -p 1\n" \ + "pid 1's current affinity mask: 3\n" + +#define tee_trivial_usage \ + "[OPTION]... [FILE]..." +#define tee_full_usage "\n\n" \ + "Copy standard input to each FILE, and also to standard output\n" \ + "\nOptions:" \ + "\n -a Append to the given FILEs, do not overwrite" \ + "\n -i Ignore interrupt signals (SIGINT)" \ + +#define tee_example_usage \ + "$ echo \"Hello\" | tee /tmp/foo\n" \ + "$ cat /tmp/foo\n" \ + "Hello\n" + +#if ENABLE_FEATURE_TELNET_AUTOLOGIN +#define telnet_trivial_usage \ + "[-a] [-l USER] HOST [PORT]" +#define telnet_full_usage "\n\n" \ + "Connect to telnet server\n" \ + "\nOptions:" \ + "\n -a Automatic login with $USER variable" \ + "\n -l USER Automatic login as USER" \ + +#else +#define telnet_trivial_usage \ + "HOST [PORT]" +#define telnet_full_usage "\n\n" \ + "Connect to telnet server" +#endif + +#define telnetd_trivial_usage \ + "[OPTION]" +#define telnetd_full_usage "\n\n" \ + "Handle incoming telnet connections" \ + SKIP_FEATURE_TELNETD_STANDALONE(" via inetd") "\n" \ + "\nOptions:" \ + "\n -l LOGIN Exec LOGIN on connect" \ + "\n -f issue_file Display issue_file instead of /etc/issue" \ + "\n -K Close connection as soon as login exits" \ + "\n (normally wait until all programs close slave pty)" \ + USE_FEATURE_TELNETD_STANDALONE( \ + "\n -p PORT Port to listen on" \ + "\n -b ADDR Address to bind to" \ + "\n -F Run in foreground" \ + "\n -i Run as inetd subservice" \ + ) + +/* "test --help" does not print help (POSIX compat), only "[ --help" does. + * We display "<applet> EXPRESSION ]" here (not "<applet> EXPRESSION") */ +#define test_trivial_usage \ + "EXPRESSION ]" +#define test_full_usage "\n\n" \ + "Check file types, compare values etc. Return a 0/1 exit code\n" \ + "depending on logical value of EXPRESSION" +#define test_example_usage \ + "$ test 1 -eq 2\n" \ + "$ echo $?\n" \ + "1\n" \ + "$ test 1 -eq 1\n" \ + "$ echo $?\n" \ + "0\n" \ + "$ [ -d /etc ]\n" \ + "$ echo $?\n" \ + "0\n" \ + "$ [ -d /junk ]\n" \ + "$ echo $?\n" \ + "1\n" + +#define tc_trivial_usage \ + /*"[OPTIONS] "*/"OBJECT CMD [dev STRING]" +#define tc_full_usage "\n\n" \ + "OBJECT: {qdisc|class|filter}\n" \ + "CMD: {add|del|change|replace|show}\n" \ + "\n" \ + "qdisc [ handle QHANDLE ] [ root |"USE_FEATURE_TC_INGRESS(" ingress |")" parent CLASSID ]\n" \ + /* "\t[ estimator INTERVAL TIME_CONSTANT ]\n" */ \ + "\t[ [ QDISC_KIND ] [ help | OPTIONS ] ]\n" \ + "\tQDISC_KIND := { [p|b]fifo | tbf | prio | cbq | red | etc. }\n" \ + "qdisc show [ dev STRING ]"USE_FEATURE_TC_INGRESS(" [ingress]")"\n" \ + "class [ classid CLASSID ] [ root | parent CLASSID ]\n" \ + "\t[ [ QDISC_KIND ] [ help | OPTIONS ] ]\n" \ + "class show [ dev STRING ] [ root | parent CLASSID ]\n" \ + "filter [ pref PRIO ] [ protocol PROTO ]\n" \ + /* "\t[ estimator INTERVAL TIME_CONSTANT ]\n" */ \ + "\t[ root | classid CLASSID ] [ handle FILTERID ]\n" \ + "\t[ [ FILTER_TYPE ] [ help | OPTIONS ] ]\n" \ + "filter show [ dev STRING ] [ root | parent CLASSID ]" + +#define tcpsvd_trivial_usage \ + "[-hEv] [-c n] [-C n:msg] [-b n] [-u user] [-l name] ip port prog..." +/* with not-implemented options: */ +/* "[-hpEvv] [-c n] [-C n:msg] [-b n] [-u user] [-l name] [-i dir|-x cdb] [-t sec] ip port prog..." */ +#define tcpsvd_full_usage "\n\n" \ + "Create TCP socket, bind it to ip:port and listen\n" \ + "for incoming connection. Run PROG for each connection.\n" \ + "\nip IP to listen on. '0' = all" \ + "\nport Port to listen on" \ + "\nprog [arg] Program to run" \ + "\n-l name Local hostname (else looks up local hostname in DNS)" \ + "\n-u user[:group] Change to user/group after bind" \ + "\n-c n Handle up to n connections simultaneously" \ + "\n-b n Allow a backlog of approximately n TCP SYNs" \ + "\n-C n[:msg] Allow only up to n connections from the same IP" \ + "\n New connections from this IP address are closed" \ + "\n immediately. 'msg' is written to the peer before close" \ + "\n-h Look up peer's hostname" \ + "\n-E Do not set up environment variables" \ + "\n-v Verbose" \ + +#define udpsvd_trivial_usage \ + "[-hEv] [-c n] [-u user] [-l name] ip port prog" +#define udpsvd_full_usage "\n\n" \ + "Create UDP socket, bind it to ip:port and wait\n" \ + "for incoming packets. Run PROG for each packet,\n" \ + "redirecting all further packets with same peer ip:port to it\n" \ + "\nip IP to listen on. '0' = all" \ + "\nport Port to listen on" \ + "\nprog [arg] Program to run" \ + "\n-l name Local hostname (else looks up local hostname in DNS)" \ + "\n-u user[:group] Change to user/group after bind" \ + "\n-c n Handle up to n connections simultaneously" \ + "\n-h Look up peer's hostname" \ + "\n-E Do not set up environment variables" \ + "\n-v Verbose" \ + +#define tftp_trivial_usage \ + "[OPTION]... HOST [PORT]" +#define tftp_full_usage "\n\n" \ + "Transfer a file from/to tftp server\n" \ + "\nOptions:" \ + "\n -l FILE Local FILE" \ + "\n -r FILE Remote FILE" \ + USE_FEATURE_TFTP_GET( \ + "\n -g Get file" \ + ) \ + USE_FEATURE_TFTP_PUT( \ + "\n -p Put file" \ + ) \ + USE_FEATURE_TFTP_BLOCKSIZE( \ + "\n -b SIZE Transfer blocks of SIZE octets" \ + ) + +#define tftpd_trivial_usage \ + "[-cr] [-u USER] [DIR]" +#define tftpd_full_usage "\n\n" \ + "Transfer a file on tftp client's request.\n" \ + "\n" \ + "tftpd should be used as an inetd service.\n" \ + "tftpd's line for inetd.conf:\n" \ + " 69 dgram udp nowait root tftpd tftpd /files/to/serve\n" \ + "It also can be ran from udpsvd:\n" \ + " udpsvd -vE 0.0.0.0 69 tftpd /files/to/serve\n" \ + "\nOptions:" \ + "\n -r Prohibit upload" \ + "\n -c Allow file creation via upload" \ + "\n -u Access files as USER" \ + +#define time_trivial_usage \ + "[OPTION]... COMMAND [ARGS...]" +#define time_full_usage "\n\n" \ + "Run the program COMMAND with arguments ARGS. When COMMAND finishes,\n" \ + "COMMAND's resource usage information is displayed.\n" \ + "\nOptions:" \ + "\n -v Verbose" \ + +#define top_trivial_usage \ + "[-b] [-nCOUNT] [-dSECONDS]" +#define top_full_usage "\n\n" \ + "Provide a view of process activity in real time.\n" \ + "Read the status of all processes from /proc each SECONDS\n" \ + "and show the status for however many processes will fit on the screen." \ + +#define touch_trivial_usage \ + "[-c] FILE [FILE...]" +#define touch_full_usage "\n\n" \ + "Update the last-modified date on the given FILE[s]\n" \ + "\nOptions:" \ + "\n -c Do not create any files" \ + +#define touch_example_usage \ + "$ ls -l /tmp/foo\n" \ + "/bin/ls: /tmp/foo: No such file or directory\n" \ + "$ touch /tmp/foo\n" \ + "$ ls -l /tmp/foo\n" \ + "-rw-rw-r-- 1 andersen andersen 0 Apr 15 01:11 /tmp/foo\n" + +#define tr_trivial_usage \ + "[-cds] STRING1 [STRING2]" +#define tr_full_usage "\n\n" \ + "Translate, squeeze, and/or delete characters from\n" \ + "standard input, writing to standard output\n" \ + "\nOptions:" \ + "\n -c Take complement of STRING1" \ + "\n -d Delete input characters coded STRING1" \ + "\n -s Squeeze multiple output characters of STRING2 into one character" \ + +#define tr_example_usage \ + "$ echo \"gdkkn vnqkc\" | tr [a-y] [b-z]\n" \ + "hello world\n" + +#define traceroute_trivial_usage \ + "[-FIldnrv] [-f 1st_ttl] [-m max_ttl] [-p port#] [-q nqueries]\n" \ + " [-s src_addr] [-t tos] [-w wait] [-g gateway] [-i iface]\n" \ + " [-z pausemsecs] HOST [data size]" +#define traceroute_full_usage "\n\n" \ + "Trace the route to HOST\n" \ + "\nOptions:" \ + "\n -F Set the don't fragment bit" \ + "\n -I Use ICMP ECHO instead of UDP datagrams" \ + "\n -l Display the ttl value of the returned packet" \ + "\n -d Set SO_DEBUG options to socket" \ + "\n -n Print hop addresses numerically rather than symbolically" \ + "\n -r Bypass the normal routing tables and send directly to a host" \ + "\n -v Verbose" \ + "\n -m max_ttl Max time-to-live (max number of hops)" \ + "\n -p port# Base UDP port number used in probes" \ + "\n (default is 33434)" \ + "\n -q nqueries Number of probes per 'ttl' (default 3)" \ + "\n -s src_addr IP address to use as the source address" \ + "\n -t tos Type-of-service in probe packets (default 0)" \ + "\n -w wait Time in seconds to wait for a response" \ + "\n (default 3 sec)" \ + "\n -g Loose source route gateway (8 max)" \ + +#define true_trivial_usage \ + "" +#define true_full_usage "\n\n" \ + "Return an exit code of TRUE (0)" +#define true_example_usage \ + "$ true\n" \ + "$ echo $?\n" \ + "0\n" + +#define tty_trivial_usage \ + "" +#define tty_full_usage "\n\n" \ + "Print file name of standard input's terminal" \ + USE_INCLUDE_SUSv2( "\n" \ + "\nOptions:" \ + "\n -s Print nothing, only return exit status" \ + ) +#define tty_example_usage \ + "$ tty\n" \ + "/dev/tty2\n" + +#define ttysize_trivial_usage \ + "[w] [h]" +#define ttysize_full_usage "\n\n" \ + "Print dimension(s) of standard input's terminal, on error return 80x25" + +#define tune2fs_trivial_usage \ + "[-c max-mounts-count] [-e errors-behavior] [-g group] " \ + "[-i interval[d|m|w]] [-j] [-J journal-options] [-l] [-s sparse-flag] " \ + "[-m reserved-blocks-percent] [-o [^]mount-options[,...]] " \ + "[-r reserved-blocks-count] [-u user] [-C mount-count] " \ + "[-L volume-label] [-M last-mounted-dir] [-O [^]feature[,...]] " \ + "[-T last-check-time] [-U UUID] device" +#define tune2fs_full_usage "\n\n" \ + "Adjust filesystem options on ext[23] filesystems" + +#define udhcpc_trivial_usage \ + "[-Cfbnqtvo] [-c CID] [-V VCLS] [-H HOSTNAME] [-i INTERFACE]\n" \ + " [-p pidfile] [-r IP] [-s script] [-O dhcp-option]..." USE_FEATURE_UDHCP_PORT(" [-P N]") +#define udhcpc_full_usage "\n\n" \ + USE_GETOPT_LONG( \ + " -V,--vendorclass=CLASSID Vendor class identifier" \ + "\n -i,--interface=INTERFACE Interface to use (default eth0)" \ + "\n -H,-h,--hostname=HOSTNAME Client hostname" \ + "\n -c,--clientid=CLIENTID Client identifier" \ + "\n -C,--clientid-none Suppress default client identifier" \ + "\n -p,--pidfile=file Create pidfile" \ + "\n -r,--request=IP IP address to request" \ + "\n -s,--script=file Run file at DHCP events (default "CONFIG_UDHCPC_DEFAULT_SCRIPT")" \ + "\n -t,--retries=N Send up to N request packets" \ + "\n -T,--timeout=N Try to get a lease for N seconds (default 3)" \ + "\n -A,--tryagain=N Wait N seconds (default 20) after failure" \ + "\n -O,--request-option=OPT Request DHCP option OPT (cumulative)" \ + "\n -o,--no-default-options Do not request any options (unless -O is also given)" \ + "\n -f,--foreground Run in foreground" \ + USE_FOR_MMU( \ + "\n -b,--background Background if lease is not immediately obtained" \ + ) \ + "\n -S,--syslog Log to syslog too" \ + "\n -n,--now Exit with failure if lease is not immediately obtained" \ + "\n -q,--quit Quit after obtaining lease" \ + "\n -R,--release Release IP on quit" \ + USE_FEATURE_UDHCP_PORT( \ + "\n -P,--client-port N Use port N instead of default 68" \ + ) \ + USE_FEATURE_UDHCPC_ARPING( \ + "\n -a,--arping Use arping to validate offered address" \ + ) \ + ) \ + SKIP_GETOPT_LONG( \ + " -V CLASSID Vendor class identifier" \ + "\n -i INTERFACE Interface to use (default: eth0)" \ + "\n -H,-h HOSTNAME Client hostname" \ + "\n -c CLIENTID Client identifier" \ + "\n -C Suppress default client identifier" \ + "\n -p file Create pidfile" \ + "\n -r IP IP address to request" \ + "\n -s file Run file at DHCP events (default "CONFIG_UDHCPC_DEFAULT_SCRIPT")" \ + "\n -t N Send up to N request packets" \ + "\n -T N Try to get a lease for N seconds (default 3)" \ + "\n -A N Wait N seconds (default 20) after failure" \ + "\n -O OPT Request DHCP option OPT (cumulative)" \ + "\n -o Do not request any options (unless -O is also given)" \ + "\n -f Run in foreground" \ + USE_FOR_MMU( \ + "\n -b Background if lease is not immediately obtained" \ + ) \ + "\n -S Log to syslog too" \ + "\n -n Exit with failure if lease is not immediately obtained" \ + "\n -q Quit after obtaining lease" \ + "\n -R Release IP on quit" \ + USE_FEATURE_UDHCP_PORT( \ + "\n -P N Use port N instead of default 68" \ + ) \ + USE_FEATURE_UDHCPC_ARPING( \ + "\n -a Use arping to validate offered address" \ + ) \ + ) + +#define udhcpd_trivial_usage \ + "[-fS]" USE_FEATURE_UDHCP_PORT(" [-P N]") " [configfile]" \ + +#define udhcpd_full_usage "\n\n" \ + "DHCP server\n" \ + "\n -f Run in foreground" \ + "\n -S Log to syslog too" \ + USE_FEATURE_UDHCP_PORT( \ + "\n -P N Use port N instead of default 67" \ + ) + +#define umount_trivial_usage \ + "[flags] FILESYSTEM|DIRECTORY" +#define umount_full_usage "\n\n" \ + "Unmount file systems\n" \ + "\nOptions:" \ + USE_FEATURE_UMOUNT_ALL( \ + "\n -a Unmount all file systems" USE_FEATURE_MTAB_SUPPORT(" in /etc/mtab") \ + ) \ + USE_FEATURE_MTAB_SUPPORT( \ + "\n -n Don't erase /etc/mtab entries" \ + ) \ + "\n -r Try to remount devices as read-only if mount is busy" \ + "\n -l Lazy umount (detach filesystem)" \ + "\n -f Force umount (i.e., unreachable NFS server)" \ + USE_FEATURE_MOUNT_LOOP( \ + "\n -d Free loop device if it has been used" \ + ) + +#define umount_example_usage \ + "$ umount /dev/hdc1\n" + +#define uname_trivial_usage \ + "[-amnrspv]" +#define uname_full_usage "\n\n" \ + "Print system information.\n" \ + "\nOptions:" \ + "\n -a Print all" \ + "\n -m The machine (hardware) type" \ + "\n -n Hostname" \ + "\n -r OS release" \ + "\n -s OS name (default)" \ + "\n -p Processor type" \ + "\n -v OS version" \ + +#define uname_example_usage \ + "$ uname -a\n" \ + "Linux debian 2.4.23 #2 Tue Dec 23 17:09:10 MST 2003 i686 GNU/Linux\n" + +#define uncompress_trivial_usage \ + "[-c] [-f] [name...]" +#define uncompress_full_usage "\n\n" \ + "Uncompress .Z file[s]\n" \ + "\nOptions:" \ + "\n -c Extract to stdout" \ + "\n -f Overwrite an existing file" \ + +#define unexpand_trivial_usage \ + "[-f][-a][-t NUM] [FILE|-]" +#define unexpand_full_usage "\n\n" \ + "Convert spaces to tabs, writing to standard output.\n" \ + "\nOptions:" \ + USE_FEATURE_UNEXPAND_LONG_OPTIONS( \ + "\n -a,--all Convert all blanks" \ + "\n -f,--first-only Convert only leading blanks" \ + "\n -t,--tabs=N Tabstops every N chars" \ + ) \ + SKIP_FEATURE_UNEXPAND_LONG_OPTIONS( \ + "\n -a Convert all blanks" \ + "\n -f Convert only leading blanks" \ + "\n -t N Tabstops every N chars" \ + ) + +#define uniq_trivial_usage \ + "[-fscduw]... [INPUT [OUTPUT]]" +#define uniq_full_usage "\n\n" \ + "Discard duplicate lines\n" \ + "\nOptions:" \ + "\n -c Prefix lines by the number of occurrences" \ + "\n -d Only print duplicate lines" \ + "\n -u Only print unique lines" \ + "\n -f N Skip first N fields" \ + "\n -s N Skip first N chars (after any skipped fields)" \ + "\n -w N Compare N characters in line" \ + +#define uniq_example_usage \ + "$ echo -e \"a\\na\\nb\\nc\\nc\\na\" | sort | uniq\n" \ + "a\n" \ + "b\n" \ + "c\n" + +#define unix2dos_trivial_usage \ + "[option] [FILE]" +#define unix2dos_full_usage "\n\n" \ + "Convert FILE from unix to dos format.\n" \ + "When no file is given, use stdin/stdout.\n" \ + "\nOptions:" \ + "\n -u dos2unix" \ + "\n -d unix2dos" \ + +#define unzip_trivial_usage \ + "[-opts[modifiers]] file[.zip] [list] [-x xlist] [-d exdir]" +#define unzip_full_usage "\n\n" \ + "Extract files from ZIP archives\n" \ + "\nOptions:" \ + "\n -l List archive contents (with -q for short form)" \ + "\n -n Never overwrite existing files (default)" \ + "\n -o Overwrite files without prompting" \ + "\n -p Send output to stdout" \ + "\n -q Quiet" \ + "\n -x Exclude these files" \ + "\n -d Extract files into this directory" \ + +#define uptime_trivial_usage \ + "" +#define uptime_full_usage "\n\n" \ + "Display the time since the last boot" + +#define uptime_example_usage \ + "$ uptime\n" \ + " 1:55pm up 2:30, load average: 0.09, 0.04, 0.00\n" + +#define usleep_trivial_usage \ + "N" +#define usleep_full_usage "\n\n" \ + "Pause for N microseconds" + +#define usleep_example_usage \ + "$ usleep 1000000\n" \ + "[pauses for 1 second]\n" + +#define uudecode_trivial_usage \ + "[-o outfile] [infile]" +#define uudecode_full_usage "\n\n" \ + "Uudecode a file\n" \ + "Finds outfile name in uuencoded source unless -o is given" + +#define uudecode_example_usage \ + "$ uudecode -o busybox busybox.uu\n" \ + "$ ls -l busybox\n" \ + "-rwxr-xr-x 1 ams ams 245264 Jun 7 21:35 busybox\n" + +#define uuencode_trivial_usage \ + "[-m] [infile] stored_filename" +#define uuencode_full_usage "\n\n" \ + "Uuencode a file to stdout\n" \ + "\nOptions:" \ + "\n -m Use base64 encoding per RFC1521" \ + +#define uuencode_example_usage \ + "$ uuencode busybox busybox\n" \ + "begin 755 busybox\n" \ + "<encoded file snipped>\n" \ + "$ uudecode busybox busybox > busybox.uu\n" \ + "$\n" + +#define vconfig_trivial_usage \ + "COMMAND [OPTIONS]..." +#define vconfig_full_usage "\n\n" \ + "Create and remove virtual ethernet devices\n" \ + "\nOptions:" \ + "\n add [interface-name] [vlan_id]" \ + "\n rem [vlan-name]" \ + "\n set_flag [interface-name] [flag-num] [0 | 1]" \ + "\n set_egress_map [vlan-name] [skb_priority] [vlan_qos]" \ + "\n set_ingress_map [vlan-name] [skb_priority] [vlan_qos]" \ + "\n set_name_type [name-type]" \ + +#define vi_trivial_usage \ + "[OPTION] [FILE]..." +#define vi_full_usage "\n\n" \ + "Edit FILE\n" \ + "\nOptions:" \ + USE_FEATURE_VI_COLON( \ + "\n -c Initial command to run ($EXINIT also available)") \ + USE_FEATURE_VI_READONLY( \ + "\n -R Read-only - do not write to the file") \ + "\n -H Short help regarding available features" \ + +#define vlock_trivial_usage \ + "[OPTIONS]" +#define vlock_full_usage "\n\n" \ + "Lock a virtual terminal. A password is required to unlock.\n" \ + "\nOptions:" \ + "\n -a Lock all VTs" \ + +#define watch_trivial_usage \ + "[-n seconds] [-t] COMMAND..." +#define watch_full_usage "\n\n" \ + "Execute a program periodically\n" \ + "\nOptions:" \ + "\n -n Loop period in seconds (default 2)" \ + "\n -t Don't print header" \ + +#define watch_example_usage \ + "$ watch date\n" \ + "Mon Dec 17 10:31:40 GMT 2000\n" \ + "Mon Dec 17 10:31:42 GMT 2000\n" \ + "Mon Dec 17 10:31:44 GMT 2000" + +#define watchdog_trivial_usage \ + "[-t N[ms]] [-T N[ms]] [-F] DEV" +#define watchdog_full_usage "\n\n" \ + "Periodically write to watchdog device DEV\n" \ + "\nOptions:" \ + "\n -T N Reboot after N seconds if not reset (default 60)" \ + "\n -t N Reset every N seconds (default 30)" \ + "\n -F Run in foreground" \ + "\n" \ + "\nUse 500ms to specify period in milliseconds" \ + +#define wc_trivial_usage \ + "[OPTION]... [FILE]..." +#define wc_full_usage "\n\n" \ + "Print line, word, and byte counts for each FILE, and a total line if\n" \ + "more than one FILE is specified. With no FILE, read standard input.\n" \ + "\nOptions:" \ + "\n -c Print the byte counts" \ + "\n -l Print the newline counts" \ + "\n -L Print the length of the longest line" \ + "\n -w Print the word counts" \ + +#define wc_example_usage \ + "$ wc /etc/passwd\n" \ + " 31 46 1365 /etc/passwd\n" + +#define wget_trivial_usage \ + USE_FEATURE_WGET_LONG_OPTIONS( \ + "[-c|--continue] [-s|--spider] [-q|--quiet] [-O|--output-document file]\n" \ + " [--header 'header: value'] [-Y|--proxy on/off] [-P DIR]\n" \ + " [-U|--user-agent agent] url" \ + ) \ + SKIP_FEATURE_WGET_LONG_OPTIONS( \ + "[-csq] [-O file] [-Y on/off] [-P DIR] [-U agent] url" \ + ) +#define wget_full_usage "\n\n" \ + "Retrieve files via HTTP or FTP\n" \ + "\nOptions:" \ + "\n -s Spider mode - only check file existence" \ + "\n -c Continue retrieval of aborted transfer" \ + "\n -q Quiet" \ + "\n -P Set directory prefix to DIR" \ + "\n -O Save to filename ('-' for stdout)" \ + "\n -U Adjust 'User-Agent' field" \ + "\n -Y Use proxy ('on' or 'off')" \ + +#define which_trivial_usage \ + "[COMMAND...]" +#define which_full_usage "\n\n" \ + "Locate a COMMAND" +#define which_example_usage \ + "$ which login\n" \ + "/bin/login\n" + +#define who_trivial_usage \ + "[-a]" +#define who_full_usage "\n\n" \ + "Show who is logged on\n" \ + "\nOptions:" \ + "\n -a show all" \ + +#define whoami_trivial_usage \ + "" +#define whoami_full_usage "\n\n" \ + "Print the user name associated with the current effective user id" + +#define xargs_trivial_usage \ + "[OPTIONS] [COMMAND] [ARGS...]" +#define xargs_full_usage "\n\n" \ + "Execute COMMAND on every item given by standard input\n" \ + "\nOptions:" \ + USE_FEATURE_XARGS_SUPPORT_CONFIRMATION( \ + "\n -p Ask user whether to run each command") \ + "\n -r Do not run command if input is empty" \ + USE_FEATURE_XARGS_SUPPORT_ZERO_TERM( \ + "\n -0 Input is separated by NUL characters") \ + "\n -t Print the command on stderr before execution" \ + "\n -e[STR] STR stops input processing" \ + "\n -n N Pass no more than N args to COMMAND" \ + "\n -s N Pass command line of no more than N bytes" \ + USE_FEATURE_XARGS_SUPPORT_TERMOPT( \ + "\n -x Exit if size is exceeded") \ + +#define xargs_example_usage \ + "$ ls | xargs gzip\n" \ + "$ find . -name '*.c' -print | xargs rm\n" + +#define yes_trivial_usage \ + "[OPTION]... [STRING]..." +#define yes_full_usage "\n\n" \ + "Repeatedly output a line with all specified STRING(s), or 'y'" + +#define zcat_trivial_usage \ + "FILE" +#define zcat_full_usage "\n\n" \ + "Uncompress to stdout" + +#define zcip_trivial_usage \ + "[OPTIONS] ifname script" +#define zcip_full_usage "\n\n" \ + "Manage a ZeroConf IPv4 link-local address\n" \ + "\nOptions:" \ + "\n -f Run in foreground" \ + "\n -q Quit after obtaining address" \ + "\n -r 169.254.x.x Request this address first" \ + "\n -v Verbose" \ + "\n" \ + "\nWith no -q, runs continuously monitoring for ARP conflicts," \ + "\nexits only on I/O errors (link down etc)" \ + +#endif /* __BB_USAGE_H__ */ diff --git a/include/volume_id.h b/include/volume_id.h new file mode 100644 index 0000000..bba32c0 --- /dev/null +++ b/include/volume_id.h @@ -0,0 +1,23 @@ +/* + * volume_id - reads filesystem label and uuid + * + * Copyright (C) 2005 Kay Sievers <kay.sievers@vrfy.org> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +char *get_devname_from_label(const char *spec); +char *get_devname_from_uuid(const char *spec); +void display_uuid_cache(void); diff --git a/include/xatonum.h b/include/xatonum.h new file mode 100644 index 0000000..86a3472 --- /dev/null +++ b/include/xatonum.h @@ -0,0 +1,176 @@ +/* vi: set sw=4 ts=4: */ +/* + * ascii-to-numbers implementations for busybox + * + * Copyright (C) 2003 Manuel Novoa III <mjn3@codepoet.org> + * + * Licensed under GPLv2, see file LICENSE in this tarball for details. + */ + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility push(hidden) +#endif + +/* Provides extern declarations of functions */ +#define DECLARE_STR_CONV(type, T, UT) \ +\ +unsigned type xstrto##UT##_range_sfx(const char *str, int b, unsigned type l, unsigned type u, const struct suffix_mult *sfx) FAST_FUNC; \ +unsigned type xstrto##UT##_range(const char *str, int b, unsigned type l, unsigned type u) FAST_FUNC; \ +unsigned type xstrto##UT##_sfx(const char *str, int b, const struct suffix_mult *sfx) FAST_FUNC; \ +unsigned type xstrto##UT(const char *str, int b) FAST_FUNC; \ +unsigned type xato##UT##_range_sfx(const char *str, unsigned type l, unsigned type u, const struct suffix_mult *sfx) FAST_FUNC; \ +unsigned type xato##UT##_range(const char *str, unsigned type l, unsigned type u) FAST_FUNC; \ +unsigned type xato##UT##_sfx(const char *str, const struct suffix_mult *sfx) FAST_FUNC; \ +unsigned type xato##UT(const char *str) FAST_FUNC; \ +type xstrto##T##_range_sfx(const char *str, int b, type l, type u, const struct suffix_mult *sfx) FAST_FUNC; \ +type xstrto##T##_range(const char *str, int b, type l, type u) FAST_FUNC; \ +type xato##T##_range_sfx(const char *str, type l, type u, const struct suffix_mult *sfx) FAST_FUNC; \ +type xato##T##_range(const char *str, type l, type u) FAST_FUNC; \ +type xato##T##_sfx(const char *str, const struct suffix_mult *sfx) FAST_FUNC; \ +type xato##T(const char *str) FAST_FUNC; \ + +/* Unsigned long long functions always exist */ +DECLARE_STR_CONV(long long, ll, ull) + + +/* Provides inline definitions of functions */ +/* (useful for mapping them to the type of the same width) */ +#define DEFINE_EQUIV_STR_CONV(narrow, N, W, UN, UW) \ +\ +static ALWAYS_INLINE \ +unsigned narrow xstrto##UN##_range_sfx(const char *str, int b, unsigned narrow l, unsigned narrow u, const struct suffix_mult *sfx) \ +{ return xstrto##UW##_range_sfx(str, b, l, u, sfx); } \ +static ALWAYS_INLINE \ +unsigned narrow xstrto##UN##_range(const char *str, int b, unsigned narrow l, unsigned narrow u) \ +{ return xstrto##UW##_range(str, b, l, u); } \ +static ALWAYS_INLINE \ +unsigned narrow xstrto##UN##_sfx(const char *str, int b, const struct suffix_mult *sfx) \ +{ return xstrto##UW##_sfx(str, b, sfx); } \ +static ALWAYS_INLINE \ +unsigned narrow xstrto##UN(const char *str, int b) \ +{ return xstrto##UW(str, b); } \ +static ALWAYS_INLINE \ +unsigned narrow xato##UN##_range_sfx(const char *str, unsigned narrow l, unsigned narrow u, const struct suffix_mult *sfx) \ +{ return xato##UW##_range_sfx(str, l, u, sfx); } \ +static ALWAYS_INLINE \ +unsigned narrow xato##UN##_range(const char *str, unsigned narrow l, unsigned narrow u) \ +{ return xato##UW##_range(str, l, u); } \ +static ALWAYS_INLINE \ +unsigned narrow xato##UN##_sfx(const char *str, const struct suffix_mult *sfx) \ +{ return xato##UW##_sfx(str, sfx); } \ +static ALWAYS_INLINE \ +unsigned narrow xato##UN(const char *str) \ +{ return xato##UW(str); } \ +static ALWAYS_INLINE \ +narrow xstrto##N##_range_sfx(const char *str, int b, narrow l, narrow u, const struct suffix_mult *sfx) \ +{ return xstrto##W##_range_sfx(str, b, l, u, sfx); } \ +static ALWAYS_INLINE \ +narrow xstrto##N##_range(const char *str, int b, narrow l, narrow u) \ +{ return xstrto##W##_range(str, b, l, u); } \ +static ALWAYS_INLINE \ +narrow xato##N##_range_sfx(const char *str, narrow l, narrow u, const struct suffix_mult *sfx) \ +{ return xato##W##_range_sfx(str, l, u, sfx); } \ +static ALWAYS_INLINE \ +narrow xato##N##_range(const char *str, narrow l, narrow u) \ +{ return xato##W##_range(str, l, u); } \ +static ALWAYS_INLINE \ +narrow xato##N##_sfx(const char *str, const struct suffix_mult *sfx) \ +{ return xato##W##_sfx(str, sfx); } \ +static ALWAYS_INLINE \ +narrow xato##N(const char *str) \ +{ return xato##W(str); } \ + +/* If long == long long, then just map them one-to-one */ +#if ULONG_MAX == ULLONG_MAX +DEFINE_EQUIV_STR_CONV(long, l, ll, ul, ull) +#else +/* Else provide extern defs */ +DECLARE_STR_CONV(long, l, ul) +#endif + +/* Same for int -> [long] long */ +#if UINT_MAX == ULLONG_MAX +DEFINE_EQUIV_STR_CONV(int, i, ll, u, ull) +#elif UINT_MAX == ULONG_MAX +DEFINE_EQUIV_STR_CONV(int, i, l, u, ul) +#else +DECLARE_STR_CONV(int, i, u) +#endif + +/* Specialized */ + +int BUG_xatou32_unimplemented(void); +static ALWAYS_INLINE uint32_t xatou32(const char *numstr) +{ + if (UINT_MAX == 0xffffffff) + return xatou(numstr); + if (ULONG_MAX == 0xffffffff) + return xatoul(numstr); + return BUG_xatou32_unimplemented(); +} + +/* Non-aborting kind of convertors: bb_strto[u][l]l */ + +/* On exit: errno = 0 only if there was non-empty, '\0' terminated value + * errno = EINVAL if value was not '\0' terminated, but otherwise ok + * Return value is still valid, caller should just check whether end[0] + * is a valid terminating char for particular case. OTOH, if caller + * requires '\0' terminated input, [s]he can just check errno == 0. + * errno = ERANGE if value had alphanumeric terminating char ("1234abcg"). + * errno = ERANGE if value is out of range, missing, etc. + * errno = ERANGE if value had minus sign for strtouXX (even "-0" is not ok ) + * return value is all-ones in this case. + */ + +unsigned long long bb_strtoull(const char *arg, char **endp, int base) FAST_FUNC; +long long bb_strtoll(const char *arg, char **endp, int base) FAST_FUNC; + +#if ULONG_MAX == ULLONG_MAX +static ALWAYS_INLINE +unsigned long bb_strtoul(const char *arg, char **endp, int base) +{ return bb_strtoull(arg, endp, base); } +static ALWAYS_INLINE +long bb_strtol(const char *arg, char **endp, int base) +{ return bb_strtoll(arg, endp, base); } +#else +unsigned long bb_strtoul(const char *arg, char **endp, int base) FAST_FUNC; +long bb_strtol(const char *arg, char **endp, int base) FAST_FUNC; +#endif + +#if UINT_MAX == ULLONG_MAX +static ALWAYS_INLINE +unsigned bb_strtou(const char *arg, char **endp, int base) +{ return bb_strtoull(arg, endp, base); } +static ALWAYS_INLINE +int bb_strtoi(const char *arg, char **endp, int base) +{ return bb_strtoll(arg, endp, base); } +#elif UINT_MAX == ULONG_MAX +static ALWAYS_INLINE +unsigned bb_strtou(const char *arg, char **endp, int base) +{ return bb_strtoul(arg, endp, base); } +static ALWAYS_INLINE +int bb_strtoi(const char *arg, char **endp, int base) +{ return bb_strtol(arg, endp, base); } +#else +unsigned bb_strtou(const char *arg, char **endp, int base) FAST_FUNC; +int bb_strtoi(const char *arg, char **endp, int base) FAST_FUNC; +#endif + +int BUG_bb_strtou32_unimplemented(void); +static ALWAYS_INLINE +uint32_t bb_strtou32(const char *arg, char **endp, int base) +{ + if (sizeof(uint32_t) == sizeof(unsigned)) + return bb_strtou(arg, endp, base); + if (sizeof(uint32_t) == sizeof(unsigned long)) + return bb_strtoul(arg, endp, base); + return BUG_bb_strtou32_unimplemented(); +} + +/* Floating point */ + +double bb_strtod(const char *arg, char **endp) FAST_FUNC; + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility pop +#endif diff --git a/include/xregex.h b/include/xregex.h new file mode 100644 index 0000000..90cf124 --- /dev/null +++ b/include/xregex.h @@ -0,0 +1,27 @@ +/* vi: set sw=4 ts=4: */ +/* + * Busybox xregcomp utility routine. This isn't in libbb.h because the + * C library we're linking against may not support regex.h. + * + * Based in part on code from sash, Copyright (c) 1999 by David I. Bell + * Permission has been granted to redistribute this code under the GPL. + * + * Licensed under GPLv2 or later, see file License in this tarball for details. + */ +#ifndef __BB_REGEX__ +#define __BB_REGEX__ + +#include <regex.h> + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility push(hidden) +#endif + +char* regcomp_or_errmsg(regex_t *preg, const char *regex, int cflags) FAST_FUNC; +void xregcomp(regex_t *preg, const char *regex, int cflags) FAST_FUNC; + +#if __GNUC_PREREQ(4,1) +# pragma GCC visibility pop +#endif + +#endif |