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>

7 files changed, 914 insertions, 0 deletions

diff --git a/debianutils/Config.in b/debianutils/Config.in
new file mode 100644
index 0000000..8deb38f
--- /dev/null
+++ b/debianutils/Config.in
@@ -0,0 +1,84 @@
+#
+# For a description of the syntax of this configuration file,
+# see scripts/kbuild/config-language.txt.
+#
+
+menu "Debian Utilities"
+
+config MKTEMP
+	bool "mktemp"
+	default n
+	help
+	  mktemp is used to create unique temporary files
+
+config PIPE_PROGRESS
+	bool "pipe_progress"
+	default n
+	help
+	  Display a dot to indicate pipe activity.
+
+config RUN_PARTS
+	bool "run-parts"
+	default n
+	help
+	  run-parts is a utility designed to run all the scripts in a directory.
+
+	  It is useful to set up a directory like cron.daily, where you need to
+	  execute all the scripts in that directory.
+
+	  In this implementation of run-parts some features (such as report
+	  mode) are not implemented.
+
+	  Unless you know that run-parts is used in some of your scripts
+	  you can safely say N here.
+
+config FEATURE_RUN_PARTS_LONG_OPTIONS
+	bool "Enable long options"
+	default n
+	depends on RUN_PARTS && GETOPT_LONG
+	help
+	  Support long options for the run-parts applet.
+
+config FEATURE_RUN_PARTS_FANCY
+	bool "Support additional arguments"
+	default n
+	depends on RUN_PARTS
+	help
+	  Support additional options:
+	  -l --list print the names of the all matching files (not
+	            limited to executables), but don't actually run them.
+
+config START_STOP_DAEMON
+	bool "start-stop-daemon"
+	default n
+	help
+	  start-stop-daemon is used to control the creation and
+	  termination of system-level processes, usually the ones
+	  started during the startup of the system.
+
+config FEATURE_START_STOP_DAEMON_FANCY
+	bool "Support additional arguments"
+	default n
+	depends on START_STOP_DAEMON
+	help
+	  Support additional arguments.
+	  -o|--oknodo ignored since we exit with 0 anyway
+	  -v|--verbose
+	  -N|--nicelevel N
+
+config FEATURE_START_STOP_DAEMON_LONG_OPTIONS
+	bool "Enable long options"
+	default n
+	depends on START_STOP_DAEMON && GETOPT_LONG
+	help
+	  Support long options for the start-stop-daemon applet.
+
+config WHICH
+	bool "which"
+	default n
+	help
+	  which is used to find programs in your PATH and
+	  print out their pathnames.
+
+endmenu
+
diff --git a/debianutils/Kbuild b/debianutils/Kbuild
new file mode 100644
index 0000000..bcf6126
--- /dev/null
+++ b/debianutils/Kbuild
@@ -0,0 +1,12 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2005 by Erik Andersen <andersen@codepoet.org>
+#
+# Licensed under the GPL v2, see the file LICENSE in this tarball.
+
+lib-y:=
+lib-$(CONFIG_MKTEMP)            += mktemp.o
+lib-$(CONFIG_PIPE_PROGRESS)     += pipe_progress.o
+lib-$(CONFIG_RUN_PARTS)         += run_parts.o
+lib-$(CONFIG_START_STOP_DAEMON) += start_stop_daemon.o
+lib-$(CONFIG_WHICH)             += which.o
diff --git a/debianutils/mktemp.c b/debianutils/mktemp.c
new file mode 100644
index 0000000..0dcb1e8
--- /dev/null
+++ b/debianutils/mktemp.c
@@ -0,0 +1,69 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini mktemp implementation for busybox
+ *
+ *
+ * Copyright (C) 2000 by Daniel Jacobowitz
+ * Written by Daniel Jacobowitz <dan@debian.org>
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ */
+
+/* Coreutils 6.12 man page says:
+ *        mktemp [OPTION]... [TEMPLATE]
+ * Create a temporary file or directory, safely, and print its name. If
+ * TEMPLATE is not specified, use tmp.XXXXXXXXXX.
+ * -d, --directory
+ *        create a directory, not a file
+ * -q, --quiet
+ *        suppress diagnostics about file/dir-creation failure
+ * -u, --dry-run
+ *        do not create anything; merely print a name (unsafe)
+ * --tmpdir[=DIR]
+ *        interpret TEMPLATE relative to DIR. If DIR is not specified,
+ *        use  $TMPDIR if set, else /tmp.  With this option, TEMPLATE must
+ *        not be an absolute name. Unlike with -t, TEMPLATE may contain
+ *        slashes, but even here, mktemp still creates only the final com-
+ *        ponent.
+ * -p DIR use DIR as a prefix; implies -t [deprecated]
+ * -t     interpret TEMPLATE as a single file name component, relative  to
+ *        a  directory:  $TMPDIR, if set; else the directory specified via
+ *        -p; else /tmp [deprecated]
+ */
+
+
+#include "libbb.h"
+
+int mktemp_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int mktemp_main(int argc UNUSED_PARAM, char **argv)
+{
+	const char *path;
+	char *chp;
+	unsigned opt;
+
+	opt_complementary = "?1"; /* 1 argument max */
+	opt = getopt32(argv, "dqtp:", &path);
+	chp = argv[optind] ? argv[optind] : xstrdup("tmp.XXXXXX");
+
+	if (opt & (4|8)) { /* -t and/or -p */
+		const char *dir = getenv("TMPDIR");
+		if (dir && *dir != '\0')
+			path = dir;
+		else if (!(opt & 8)) /* no -p */
+			path = "/tmp/";
+		/* else path comes from -p DIR */
+		chp = concat_path_file(path, chp);
+	}
+
+	if (opt & 1) { /* -d */
+		if (mkdtemp(chp) == NULL)
+			return EXIT_FAILURE;
+	} else {
+		if (mkstemp(chp) < 0)
+			return EXIT_FAILURE;
+	}
+
+	puts(chp);
+
+	return EXIT_SUCCESS;
+}
diff --git a/debianutils/pipe_progress.c b/debianutils/pipe_progress.c
new file mode 100644
index 0000000..fa98e8b
--- /dev/null
+++ b/debianutils/pipe_progress.c
@@ -0,0 +1,39 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Monitor a pipe with a simple progress display.
+ *
+ * Copyright (C) 2003 by Rob Landley <rob@landley.net>, Joey Hess
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+#include "libbb.h"
+
+#define PIPE_PROGRESS_SIZE 4096
+
+/* Read a block of data from stdin, write it to stdout.
+ * Activity is indicated by a '.' to stderr
+ */
+int pipe_progress_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int pipe_progress_main(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
+{
+	RESERVE_CONFIG_BUFFER(buf, PIPE_PROGRESS_SIZE);
+	time_t t = time(NULL);
+	size_t len;
+
+	while ((len = fread(buf, 1, PIPE_PROGRESS_SIZE, stdin)) > 0) {
+		time_t new_time = time(NULL);
+		if (new_time != t) {
+			t = new_time;
+			fputc('.', stderr);
+		}
+		fwrite(buf, len, 1, stdout);
+	}
+
+	fputc('\n', stderr);
+
+	if (ENABLE_FEATURE_CLEAN_UP)
+		RELEASE_CONFIG_BUFFER(buf);
+
+	return 0;
+}
diff --git a/debianutils/run_parts.c b/debianutils/run_parts.c
new file mode 100644
index 0000000..7c38fa1
--- /dev/null
+++ b/debianutils/run_parts.c
@@ -0,0 +1,173 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini run-parts implementation for busybox
+ *
+ * Copyright (C) 2007 Bernhard Reutner-Fischer
+ *
+ * Based on a older version that was in busybox which was 1k big..
+ *   Copyright (C) 2001 by Emanuele Aina <emanuele.aina@tiscali.it>
+ *
+ * Based on the Debian run-parts program, version 1.15
+ *   Copyright (C) 1996 Jeff Noxon <jeff@router.patch.net>,
+ *   Copyright (C) 1996-1999 Guy Maor <maor@debian.org>
+ *
+ *
+ * Licensed under GPL v2 or later, see file LICENSE in this tarball for details.
+ */
+
+/* This is my first attempt to write a program in C (well, this is my first
+ * attempt to write a program! :-) . */
+
+/* This piece of code is heavily based on the original version of run-parts,
+ * taken from debian-utils. I've only removed the long options and a the
+ * report mode. As the original run-parts support only long options, I've
+ * broken compatibility because the BusyBox policy doesn't allow them.
+ * The supported options are:
+ * -t           test. Print the name of the files to be executed, without
+ *              execute them.
+ * -a ARG       argument. Pass ARG as an argument the program executed. It can
+ *              be repeated to pass multiple arguments.
+ * -u MASK      umask. Set the umask of the program executed to MASK.
+ */
+
+#include "libbb.h"
+
+struct globals {
+	char **names;
+	int    cur;
+	char  *cmd[1];
+};
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define names (G.names)
+#define cur   (G.cur  )
+#define cmd   (G.cmd  )
+
+enum { NUM_CMD = (COMMON_BUFSIZE - sizeof(G)) / sizeof(cmd[0]) - 1 };
+
+enum {
+	OPT_r = (1 << 0),
+	OPT_a = (1 << 1),
+	OPT_u = (1 << 2),
+	OPT_t = (1 << 3),
+	OPT_l = (1 << 4) * ENABLE_FEATURE_RUN_PARTS_FANCY,
+};
+
+#if ENABLE_FEATURE_RUN_PARTS_FANCY
+#define list_mode (option_mask32 & OPT_l)
+#else
+#define list_mode 0
+#endif
+
+/* Is this a valid filename (upper/lower alpha, digits,
+ * underscores, and hyphens only?)
+ */
+static bool invalid_name(const char *c)
+{
+	c = bb_basename(c);
+
+	while (*c && (isalnum(*c) || *c == '_' || *c == '-'))
+		c++;
+
+	return *c; /* TRUE (!0) if terminating NUL is not reached */
+}
+
+static int bb_alphasort(const void *p1, const void *p2)
+{
+	int r = strcmp(*(char **) p1, *(char **) p2);
+	return (option_mask32 & OPT_r) ? -r : r;
+}
+
+static int FAST_FUNC act(const char *file, struct stat *statbuf, void *args UNUSED_PARAM, int depth)
+{
+	if (depth == 1)
+		return TRUE;
+
+	if (depth == 2
+	 && (  !(statbuf->st_mode & (S_IFREG | S_IFLNK))
+	    || invalid_name(file)
+	    || (!list_mode && access(file, X_OK) != 0))
+	) {
+		return SKIP;
+	}
+
+	names = xrealloc_vector(names, 4, cur);
+	names[cur++] = xstrdup(file);
+	/*names[cur] = NULL; - xrealloc_vector did it */
+
+	return TRUE;
+}
+
+#if ENABLE_FEATURE_RUN_PARTS_LONG_OPTIONS
+static const char runparts_longopts[] ALIGN1 =
+	"arg\0"     Required_argument "a"
+	"umask\0"   Required_argument "u"
+	"test\0"    No_argument       "t"
+#if ENABLE_FEATURE_RUN_PARTS_FANCY
+	"list\0"    No_argument       "l"
+	"reverse\0" No_argument       "r"
+//TODO: "verbose\0" No_argument       "v"
+#endif
+	;
+#endif
+
+int run_parts_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int run_parts_main(int argc UNUSED_PARAM, char **argv)
+{
+	const char *umask_p = "22";
+	llist_t *arg_list = NULL;
+	unsigned n;
+	int ret;
+
+#if ENABLE_FEATURE_RUN_PARTS_LONG_OPTIONS
+	applet_long_options = runparts_longopts;
+#endif
+	/* We require exactly one argument: the directory name */
+	/* We require exactly one argument: the directory name */
+	opt_complementary = "=1:a::";
+	getopt32(argv, "ra:u:t"USE_FEATURE_RUN_PARTS_FANCY("l"), &arg_list, &umask_p);
+
+	umask(xstrtou_range(umask_p, 8, 0, 07777));
+
+	n = 1;
+	while (arg_list && n < NUM_CMD) {
+		cmd[n++] = llist_pop(&arg_list);
+	}
+	/* cmd[n] = NULL; - is already zeroed out */
+
+	/* run-parts has to sort executables by name before running them */
+
+	recursive_action(argv[optind],
+			ACTION_RECURSE|ACTION_FOLLOWLINKS,
+			act,            /* file action */
+			act,            /* dir action */
+			NULL,           /* user data */
+			1               /* depth */
+		);
+
+	if (!names)
+		return 0;
+
+	qsort(names, cur, sizeof(char *), bb_alphasort);
+
+	n = 0;
+	while (1) {
+		char *name = *names++;
+		if (!name)
+			break;
+		if (option_mask32 & (OPT_t | OPT_l)) {
+			puts(name);
+			continue;
+		}
+		cmd[0] = name;
+		ret = wait4pid(spawn(cmd));
+		if (ret == 0)
+			continue;
+		n = 1;
+		if (ret < 0)
+			bb_perror_msg("can't exec %s", name);
+		else /* ret > 0 */
+			bb_error_msg("%s exited with code %d", name, ret);
+	}
+
+	return n;
+}
diff --git a/debianutils/start_stop_daemon.c b/debianutils/start_stop_daemon.c
new file mode 100644
index 0000000..ab607bd
--- /dev/null
+++ b/debianutils/start_stop_daemon.c
@@ -0,0 +1,447 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini start-stop-daemon implementation(s) for busybox
+ *
+ * Written by Marek Michalkiewicz <marekm@i17linuxb.ists.pwr.wroc.pl>,
+ * Adapted for busybox David Kimdon <dwhedon@gordian.com>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ */
+
+/*
+This is how it is supposed to work:
+
+start-stop-daemon [OPTIONS] [--start|--stop] [[--] arguments...]
+
+One (only) of these must be given:
+        -S,--start              Start
+        -K,--stop               Stop
+
+Search for matching processes.
+If --stop is given, stop all matching processes (by sending a signal).
+If --start is given, start a new process unless a matching process was found.
+
+Options controlling process matching
+(if multiple conditions are specified, all must match):
+        -u,--user USERNAME|UID  Only consider this user's processes
+        -n,--name PROCESS_NAME  Look for processes by matching PROCESS_NAME
+                                with comm field in /proc/$PID/stat.
+                                Only basename is compared:
+                                "ntpd" == "./ntpd" == "/path/to/ntpd".
+[TODO: can PROCESS_NAME be a full pathname? Should we require full match then
+with /proc/$PID/exe or argv[0] (comm can't be matched, it never contains path)]
+        -x,--exec EXECUTABLE    Look for processes that were started with this
+                                command in /proc/$PID/cmdline.
+                                Unlike -n, we match against the full path:
+                                "ntpd" != "./ntpd" != "/path/to/ntpd"
+        -p,--pidfile PID_FILE   Look for processes with PID from this file
+
+Options which are valid for --start only:
+        -x,--exec EXECUTABLE    Program to run (1st arg of execvp). Mandatory.
+        -a,--startas NAME       argv[0] (defaults to EXECUTABLE)
+        -b,--background         Put process into background
+        -N,--nicelevel N        Add N to process' nice level
+        -c,--chuid USER[:[GRP]] Change to specified user [and group]
+        -m,--make-pidfile       Write PID to the pidfile
+                                (both -m and -p must be given!)
+
+Options which are valid for --stop only:
+        -s,--signal SIG         Signal to send (default:TERM)
+        -t,--test               Exit with status 0 if process is found
+                                (we don't actually start or stop daemons)
+
+Misc options:
+        -o,--oknodo             Exit with status 0 if nothing is done
+        -q,--quiet              Quiet
+        -v,--verbose            Verbose
+*/
+
+#include <sys/resource.h>
+
+/* Override ENABLE_FEATURE_PIDFILE */
+#define WANT_PIDFILE 1
+#include "libbb.h"
+
+struct pid_list {
+	struct pid_list *next;
+	pid_t pid;
+};
+
+enum {
+	CTX_STOP       = (1 <<  0),
+	CTX_START      = (1 <<  1),
+	OPT_BACKGROUND = (1 <<  2), // -b
+	OPT_QUIET      = (1 <<  3), // -q
+	OPT_TEST       = (1 <<  4), // -t
+	OPT_MAKEPID    = (1 <<  5), // -m
+	OPT_a          = (1 <<  6), // -a
+	OPT_n          = (1 <<  7), // -n
+	OPT_s          = (1 <<  8), // -s
+	OPT_u          = (1 <<  9), // -u
+	OPT_c          = (1 << 10), // -c
+	OPT_x          = (1 << 11), // -x
+	OPT_p          = (1 << 12), // -p
+	OPT_OKNODO     = (1 << 13) * ENABLE_FEATURE_START_STOP_DAEMON_FANCY, // -o
+	OPT_VERBOSE    = (1 << 14) * ENABLE_FEATURE_START_STOP_DAEMON_FANCY, // -v
+	OPT_NICELEVEL  = (1 << 15) * ENABLE_FEATURE_START_STOP_DAEMON_FANCY, // -N
+};
+#define QUIET (option_mask32 & OPT_QUIET)
+#define TEST  (option_mask32 & OPT_TEST)
+
+struct globals {
+	struct pid_list *found;
+	char *userspec;
+	char *cmdname;
+	char *execname;
+	char *pidfile;
+	int user_id;
+	smallint signal_nr;
+};
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define found             (G.found               )
+#define userspec          (G.userspec            )
+#define cmdname           (G.cmdname             )
+#define execname          (G.execname            )
+#define pidfile           (G.pidfile             )
+#define user_id           (G.user_id             )
+#define signal_nr         (G.signal_nr           )
+#define INIT_G() do { \
+	user_id = -1; \
+	signal_nr = 15; \
+} while (0)
+
+#ifdef OLDER_VERSION_OF_X
+/* -x,--exec EXECUTABLE
+ * Look for processes with matching /proc/$PID/exe.
+ * Match is performed using device+inode.
+ */
+static int pid_is_exec(pid_t pid)
+{
+	struct stat st;
+	char buf[sizeof("/proc//exe") + sizeof(int)*3];
+
+	sprintf(buf, "/proc/%u/exe", (unsigned)pid);
+	if (stat(buf, &st) < 0)
+		return 0;
+	if (st.st_dev == execstat.st_dev
+	 && st.st_ino == execstat.st_ino)
+		return 1;
+	return 0;
+}
+#endif
+
+static int pid_is_exec(pid_t pid)
+{
+	ssize_t bytes;
+	char buf[PATH_MAX];
+
+	sprintf(buf, "/proc/%u/cmdline", (unsigned)pid);
+	bytes = open_read_close(buf, buf, sizeof(buf) - 1);
+	if (bytes > 0) {
+		buf[bytes] = '\0';
+		return strcmp(buf, execname) == 0;
+	}
+	return 0;
+}
+
+static int pid_is_name(pid_t pid)
+{
+	/* /proc/PID/stat is "PID (comm_15_bytes_max) ..." */
+	char buf[32]; /* should be enough */
+	char *p, *pe;
+
+	sprintf(buf, "/proc/%u/stat", (unsigned)pid);
+	if (open_read_close(buf, buf, sizeof(buf) - 1) < 0)
+		return 0;
+	buf[sizeof(buf) - 1] = '\0'; /* paranoia */
+	p = strchr(buf, '(');
+	if (!p)
+		return 0;
+	pe = strrchr(++p, ')');
+	if (!pe)
+		return 0;
+	*pe = '\0';
+	/* we require comm to match and to not be truncated */
+	/* in Linux, if comm is 15 chars, it may be a truncated
+	 * name, so we don't allow that to match */
+	if (strlen(p) >= COMM_LEN - 1) /* COMM_LEN is 16 */
+		return 0;
+	return strcmp(p, cmdname) == 0;
+}
+
+static int pid_is_user(int pid)
+{
+	struct stat sb;
+	char buf[sizeof("/proc/") + sizeof(int)*3];
+
+	sprintf(buf, "/proc/%u", (unsigned)pid);
+	if (stat(buf, &sb) != 0)
+		return 0;
+	return (sb.st_uid == (uid_t)user_id);
+}
+
+static void check(int pid)
+{
+	struct pid_list *p;
+
+	if (execname && !pid_is_exec(pid)) {
+		return;
+	}
+	if (cmdname && !pid_is_name(pid)) {
+		return;
+	}
+	if (userspec && !pid_is_user(pid)) {
+		return;
+	}
+	p = xmalloc(sizeof(*p));
+	p->next = found;
+	p->pid = pid;
+	found = p;
+}
+
+static void do_pidfile(void)
+{
+	FILE *f;
+	unsigned pid;
+
+	f = fopen_for_read(pidfile);
+	if (f) {
+		if (fscanf(f, "%u", &pid) == 1)
+			check(pid);
+		fclose(f);
+	} else if (errno != ENOENT)
+		bb_perror_msg_and_die("open pidfile %s", pidfile);
+}
+
+static void do_procinit(void)
+{
+	DIR *procdir;
+	struct dirent *entry;
+	int pid;
+
+	if (pidfile) {
+		do_pidfile();
+		return;
+	}
+
+	procdir = xopendir("/proc");
+
+	pid = 0;
+	while (1) {
+		errno = 0; /* clear any previous error */
+		entry = readdir(procdir);
+// TODO: this check is too generic, it's better
+// to check for exact errno(s) which mean that we got stale entry
+		if (errno) /* Stale entry, process has died after opendir */
+			continue;
+		if (!entry) /* EOF, no more entries */
+			break;
+		pid = bb_strtou(entry->d_name, NULL, 10);
+		if (errno) /* NaN */
+			continue;
+		check(pid);
+	}
+	closedir(procdir);
+	if (!pid)
+		bb_error_msg_and_die("nothing in /proc - not mounted?");
+}
+
+static int do_stop(void)
+{
+	char *what;
+	struct pid_list *p;
+	int killed = 0;
+
+	if (cmdname) {
+		if (ENABLE_FEATURE_CLEAN_UP) what = xstrdup(cmdname);
+		if (!ENABLE_FEATURE_CLEAN_UP) what = cmdname;
+	} else if (execname) {
+		if (ENABLE_FEATURE_CLEAN_UP) what = xstrdup(execname);
+		if (!ENABLE_FEATURE_CLEAN_UP) what = execname;
+	} else if (pidfile) {
+		what = xasprintf("process in pidfile '%s'", pidfile);
+	} else if (userspec) {
+		what = xasprintf("process(es) owned by '%s'", userspec);
+	} else {
+		bb_error_msg_and_die("internal error, please report");
+	}
+
+	if (!found) {
+		if (!QUIET)
+			printf("no %s found; none killed\n", what);
+		killed = -1;
+		goto ret;
+	}
+	for (p = found; p; p = p->next) {
+		if (TEST || kill(p->pid, signal_nr) == 0) {
+			killed++;
+		} else {
+			p->pid = 0;
+			bb_perror_msg("warning: killing process %u", (unsigned)p->pid);
+		}
+	}
+	if (!QUIET && killed) {
+		printf("stopped %s (pid", what);
+		for (p = found; p; p = p->next)
+			if (p->pid)
+				printf(" %u", (unsigned)p->pid);
+		puts(")");
+	}
+ ret:
+	if (ENABLE_FEATURE_CLEAN_UP)
+		free(what);
+	return killed;
+}
+
+#if ENABLE_FEATURE_START_STOP_DAEMON_LONG_OPTIONS
+static const char start_stop_daemon_longopts[] ALIGN1 =
+	"stop\0"         No_argument       "K"
+	"start\0"        No_argument       "S"
+	"background\0"   No_argument       "b"
+	"quiet\0"        No_argument       "q"
+	"test\0"         No_argument       "t"
+	"make-pidfile\0" No_argument       "m"
+#if ENABLE_FEATURE_START_STOP_DAEMON_FANCY
+	"oknodo\0"       No_argument       "o"
+	"verbose\0"      No_argument       "v"
+	"nicelevel\0"    Required_argument "N"
+#endif
+	"startas\0"      Required_argument "a"
+	"name\0"         Required_argument "n"
+	"signal\0"       Required_argument "s"
+	"user\0"         Required_argument "u"
+	"chuid\0"        Required_argument "c"
+	"exec\0"         Required_argument "x"
+	"pidfile\0"      Required_argument "p"
+#if ENABLE_FEATURE_START_STOP_DAEMON_FANCY
+	"retry\0"        Required_argument "R"
+#endif
+	;
+#endif
+
+int start_stop_daemon_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int start_stop_daemon_main(int argc UNUSED_PARAM, char **argv)
+{
+	unsigned opt;
+	char *signame;
+	char *startas;
+	char *chuid;
+#ifdef OLDER_VERSION_OF_X
+	struct stat execstat;
+#endif
+#if ENABLE_FEATURE_START_STOP_DAEMON_FANCY
+//	char *retry_arg = NULL;
+//	int retries = -1;
+	char *opt_N;
+#endif
+
+	INIT_G();
+
+#if ENABLE_FEATURE_START_STOP_DAEMON_LONG_OPTIONS
+	applet_long_options = start_stop_daemon_longopts;
+#endif
+
+	/* -K or -S is required; they are mutually exclusive */
+	/* -p is required if -m is given */
+	/* -xpun (at least one) is required if -K is given */
+	/* -xa (at least one) is required if -S is given */
+	/* -q turns off -v */
+	opt_complementary = "K:S:K--S:S--K:m?p:K?xpun:S?xa"
+		USE_FEATURE_START_STOP_DAEMON_FANCY("q-v");
+	opt = getopt32(argv, "KSbqtma:n:s:u:c:x:p:"
+		USE_FEATURE_START_STOP_DAEMON_FANCY("ovN:R:"),
+		&startas, &cmdname, &signame, &userspec, &chuid, &execname, &pidfile
+		USE_FEATURE_START_STOP_DAEMON_FANCY(,&opt_N)
+		/* We accept and ignore -R <param> / --retry <param> */
+		USE_FEATURE_START_STOP_DAEMON_FANCY(,NULL)
+	);
+
+	if (opt & OPT_s) {
+		signal_nr = get_signum(signame);
+		if (signal_nr < 0) bb_show_usage();
+	}
+
+	if (!(opt & OPT_a))
+		startas = execname;
+	if (!execname) /* in case -a is given and -x is not */
+		execname = startas;
+
+//	USE_FEATURE_START_STOP_DAEMON_FANCY(
+//		if (retry_arg)
+//			retries = xatoi_u(retry_arg);
+//	)
+	//argc -= optind;
+	argv += optind;
+
+	if (userspec) {
+		user_id = bb_strtou(userspec, NULL, 10);
+		if (errno)
+			user_id = xuname2uid(userspec);
+	}
+	/* Both start and stop need to know current processes */
+	do_procinit();
+
+	if (opt & CTX_STOP) {
+		int i = do_stop();
+		return (opt & OPT_OKNODO) ? 0 : (i <= 0);
+	}
+
+	if (found) {
+		if (!QUIET)
+			printf("%s is already running\n%u\n", execname, (unsigned)found->pid);
+		return !(opt & OPT_OKNODO);
+	}
+
+#ifdef OLDER_VERSION_OF_X
+	if (execname)
+		xstat(execname, &execstat);
+#endif
+
+	*--argv = startas;
+	if (opt & OPT_BACKGROUND) {
+#if BB_MMU
+		bb_daemonize(DAEMON_DEVNULL_STDIO + DAEMON_CLOSE_EXTRA_FDS);
+		/* DAEMON_DEVNULL_STDIO is superfluous -
+		 * it's always done by bb_daemonize() */
+#else
+		pid_t pid = vfork();
+		if (pid < 0) /* error */
+			bb_perror_msg_and_die("vfork");
+		if (pid != 0) {
+			/* parent */
+			/* why _exit? the child may have changed the stack,
+			 * so "return 0" may do bad things */
+			_exit(EXIT_SUCCESS);
+		}
+		/* Child */
+		setsid(); /* detach from controlling tty */
+		/* Redirect stdio to /dev/null, close extra FDs.
+		 * We do not actually daemonize because of DAEMON_ONLY_SANITIZE */
+		bb_daemonize_or_rexec(DAEMON_DEVNULL_STDIO
+			+ DAEMON_CLOSE_EXTRA_FDS
+			+ DAEMON_ONLY_SANITIZE,
+			NULL /* argv, unused */ );
+#endif
+	}
+	if (opt & OPT_MAKEPID) {
+		/* User wants _us_ to make the pidfile */
+		write_pidfile(pidfile);
+	}
+	if (opt & OPT_c) {
+		struct bb_uidgid_t ugid = { -1, -1 };
+		parse_chown_usergroup_or_die(&ugid, chuid);
+		if (ugid.gid != (gid_t) -1) xsetgid(ugid.gid);
+		if (ugid.uid != (uid_t) -1) xsetuid(ugid.uid);
+	}
+#if ENABLE_FEATURE_START_STOP_DAEMON_FANCY
+	if (opt & OPT_NICELEVEL) {
+		/* Set process priority */
+		int prio = getpriority(PRIO_PROCESS, 0) + xatoi_range(opt_N, INT_MIN/2, INT_MAX/2);
+		if (setpriority(PRIO_PROCESS, 0, prio) < 0) {
+			bb_perror_msg_and_die("setpriority(%d)", prio);
+		}
+	}
+#endif
+	execvp(startas, argv);
+	bb_perror_msg_and_die("cannot start %s", startas);
+}
diff --git a/debianutils/which.c b/debianutils/which.c
new file mode 100644
index 0000000..748e6dc
--- /dev/null
+++ b/debianutils/which.c
@@ -0,0 +1,90 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Which implementation for busybox
+ *
+ * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+ * Copyright (C) 2006 Gabriel Somlo <somlo at cmu.edu>
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ *
+ * Based on which from debianutils
+ */
+
+#include "libbb.h"
+
+int which_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int which_main(int argc UNUSED_PARAM, char **argv)
+{
+	USE_DESKTOP(int opt;)
+	int status = EXIT_SUCCESS;
+	char *path;
+	char *p;
+
+	opt_complementary = "-1"; /* at least one argument */
+	USE_DESKTOP(opt =) getopt32(argv, "a");
+	argv += optind;
+
+	/* This matches what is seen on e.g. ubuntu.
+	 * "which" there is a shell script. */
+	path = getenv("PATH");
+	if (!path) {
+		path = (char*)bb_PATH_root_path;
+		putenv(path);
+		path += 5; /* skip "PATH=" */
+	}
+
+	do {
+#if ENABLE_DESKTOP
+/* Much bloat just to support -a */
+		if (strchr(*argv, '/')) {
+			if (execable_file(*argv)) {
+				puts(*argv);
+				continue;
+			}
+			status = EXIT_FAILURE;
+		} else {
+			char *path2 = xstrdup(path);
+			char *tmp = path2;
+
+			p = find_execable(*argv, &tmp);
+			if (!p)
+				status = EXIT_FAILURE;
+			else {
+ print:
+				puts(p);
+				free(p);
+				if (opt) {
+					/* -a: show matches in all PATH components */
+					if (tmp) {
+						p = find_execable(*argv, &tmp);
+						if (p)
+							goto print;
+					}
+				}
+			}
+			free(path2);
+		}
+#else
+/* Just ignoring -a */
+		if (strchr(*argv, '/')) {
+			if (execable_file(*argv)) {
+				puts(*argv);
+				continue;
+			}
+		} else {
+			char *path2 = xstrdup(path);
+			char *tmp = path2;
+			p = find_execable(*argv, &tmp);
+			free(path2);
+			if (p) {
+				puts(p);
+				free(p);
+				continue;
+			}
+		}
+		status = EXIT_FAILURE;
+#endif
+	} while (*(++argv) != NULL);
+
+	fflush_stdout_and_exit(status);
+}