imported original firmware WRT54GL_v4.30.11_11_US

13 files changed, 2686 insertions, 0 deletions

diff --git a/release/src/router/busybox/init/Config.in b/release/src/router/busybox/init/Config.in
new file mode 100755
index 00000000..eb421138
--- /dev/null
+++ b/release/src/router/busybox/init/Config.in
@@ -0,0 +1,97 @@
+#
+# For a description of the syntax of this configuration file,
+# see scripts/kbuild/config-language.txt.
+#
+
+menu "Init Utilities"
+
+config CONFIG_INIT
+	bool "init"
+	default n
+	help
+	  init is the first program run when the system boots.
+
+config CONFIG_FEATURE_USE_INITTAB
+	bool "  Support reading an inittab file?"
+	default y
+	depends on CONFIG_INIT
+	help
+	  Allow init to read an inittab file when the system boot.
+
+config CONFIG_FEATURE_INITRD
+	bool "  Support running init from within an initrd?"
+	default y
+	depends on CONFIG_INIT
+	help
+	  Allow init to be called from an initrd as linuxrc.
+
+config CONFIG_FEATURE_INIT_COREDUMPS
+	bool "  Support dumping core for child processes (debugging only)?"
+	default n
+	depends on CONFIG_INIT
+	help
+	  If this option is enabled and the file /.init_enable_core
+	  exists, then init will call setrlimit() to allow unlimited
+	  core file sizes.  If this option is disabled, processes
+	  will not generate any core files.
+
+config CONFIG_FEATURE_EXTRA_QUIET
+	bool "  Should init be _extra_ quiet on boot?"
+	default y
+	depends on CONFIG_INIT
+	help
+	  Prevent init from logging some messages to the console
+	  during boot.
+
+config CONFIG_HALT
+	bool "halt"
+	default y
+	help
+	  Stop all processes and halt the system.
+
+config CONFIG_POWEROFF
+	bool "poweroff"
+	default y
+	help
+	  Stop all processes and (try to) power off the system.
+
+config CONFIG_REBOOT
+	bool "reboot"
+	default y
+	help
+	  Stop all processes and reboot the system.
+
+config CONFIG_MINIT
+	bool "minit"
+	default n
+	depends on ! CONFIG_INIT
+	help
+	  Minimal init, based on minit v0.9.1.  This is a simple
+	  init replacement that handles starting/stopping services,
+	  and service dependencies.  See http://www.fefe.de/minit/
+	  for additional information.
+
+config CONFIG_PIDFILEHACK
+	bool "pidfilehack"
+	default y
+	depends on CONFIG_MINIT
+	help
+	  pidfilehack is used by minit to run servers.
+
+config CONFIG_MSVC
+	bool "msvc"
+	default y
+	depends on CONFIG_MINIT
+	help
+	  msvc is used to start and stop processes controlled by minit
+
+config CONFIG_MESG
+	bool "mesg"
+	default y
+	help
+	  Mesg  controls  the  access to your terminal by others.  It
+	  is typically used to allow or disallow other users to write
+	  to your  terminal
+
+endmenu
+
diff --git a/release/src/router/busybox/init/Makefile b/release/src/router/busybox/init/Makefile
new file mode 100644
index 00000000..816230bf
--- /dev/null
+++ b/release/src/router/busybox/init/Makefile
@@ -0,0 +1,30 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+
+TOPDIR:= ../
+INIT_DIR:=./
+include $(TOPDIR).config
+include $(TOPDIR)Rules.mak
+include Makefile.in
+all: $(libraries-y)
+-include $(TOPDIR).depend
+
+clean:
+	rm -f *.o *.a $(AR_TARGET)
+
diff --git a/release/src/router/busybox/init/Makefile.in b/release/src/router/busybox/init/Makefile.in
new file mode 100755
index 00000000..1b13f693
--- /dev/null
+++ b/release/src/router/busybox/init/Makefile.in
@@ -0,0 +1,61 @@
+# Makefile for busybox
+#
+# Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+
+INIT_AR:=init.a
+ifndef $(INIT_DIR)
+INIT_DIR:=$(TOPDIR)init/
+endif
+
+INIT-y:=
+INIT-$(CONFIG_HALT)			+= halt.o
+INIT-$(CONFIG_INIT)			+= init.o
+INIT-$(CONFIG_MESG)			+= mesg.o
+INIT-$(CONFIG_MINIT)			+= minit.o
+INIT-$(CONFIG_MSVC)			+= msvc.o
+INIT-$(CONFIG_PIDFILEHACK)		+= pidfilehack.o
+INIT-$(CONFIG_POWEROFF)			+= poweroff.o
+INIT-$(CONFIG_REBOOT)			+= reboot.o
+
+ifeq ($(CONFIG_HALT), y)
+CONFIG_INIT_SHARED=y
+else
+ifeq ($(CONFIG_INIT), y)
+CONFIG_INIT_SHARED=y
+else
+ifeq ($(CONFIG_POWEROFF), y)
+CONFIG_INIT_SHARED=y
+else
+ifeq ($(CONFIG_REBOOT), y)
+CONFIG_INIT_SHARED=y
+else
+CONFIG_INIT_SHARED=n
+endif
+endif
+endif
+endif
+
+ifeq ($(CONFIG_INIT_SHARED), y)
+INIT-$(CONFIG_INIT_SHARED)        += init_shared.o
+endif
+
+libraries-y+=$(INIT_DIR)$(INIT_AR)
+
+$(INIT_DIR)$(INIT_AR): $(patsubst %,$(INIT_DIR)%, $(INIT-y))
+	$(AR) -ro $@ $(patsubst %,$(INIT_DIR)%, $(INIT-y))
+
diff --git a/release/src/router/busybox/init/halt.c b/release/src/router/busybox/init/halt.c
new file mode 100644
index 00000000..decdaeaf
--- /dev/null
+++ b/release/src/router/busybox/init/halt.c
@@ -0,0 +1,48 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini halt implementation for busybox
+ *
+ * Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <sys/reboot.h>
+#include "busybox.h"
+#include "init_shared.h"
+
+
+extern int halt_main(int argc, char **argv)
+{
+	char *delay; /* delay in seconds before rebooting */
+
+	if(bb_getopt_ulflags(argc, argv, "d:", &delay)) {
+		sleep(atoi(delay));
+	}
+
+#ifndef CONFIG_INIT
+#ifndef RB_HALT_SYSTEM
+#define RB_HALT_SYSTEM		0xcdef0123
+#endif
+	return(bb_shutdown_system(RB_HALT_SYSTEM));
+#else
+	return kill_init(SIGUSR1);
+#endif
+}
diff --git a/release/src/router/busybox/init/init.c b/release/src/router/busybox/init/init.c
new file mode 100644
index 00000000..1ecc43e1
--- /dev/null
+++ b/release/src/router/busybox/init/init.c
@@ -0,0 +1,1190 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini init implementation for busybox
+ *
+ * Copyright (C) 1995, 1996 by Bruce Perens <bruce@pixar.com>.
+ * Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
+ * Adjusted by so many folks, it's impossible to keep track.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* Turn this on to disable all the dangerous 
+   rebooting stuff when debugging.
+#define DEBUG_INIT
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <paths.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <string.h>
+#include <termios.h>
+#include <unistd.h>
+#include <limits.h>
+#include <sys/fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/mount.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/reboot.h>
+#include "busybox.h"
+
+#include "init_shared.h"
+
+
+#ifdef CONFIG_SYSLOGD
+# include <sys/syslog.h>
+#endif
+
+
+#if defined(__UCLIBC__) && !defined(__UCLIBC_HAS_MMU__)
+#define fork	vfork
+#endif
+
+#define INIT_BUFFS_SIZE 256
+
+/* From <linux/vt.h> */
+struct vt_stat {
+	unsigned short v_active;	/* active vt */
+	unsigned short v_signal;	/* signal to send */
+	unsigned short v_state;	/* vt bitmask */
+};
+static const int VT_GETSTATE = 0x5603;	/* get global vt state info */
+
+/* From <linux/serial.h> */
+struct serial_struct {
+	int type;
+	int line;
+	int port;
+	int irq;
+	int flags;
+	int xmit_fifo_size;
+	int custom_divisor;
+	int baud_base;
+	unsigned short close_delay;
+	char reserved_char[2];
+	int hub6;
+	unsigned short closing_wait;	/* time to wait before closing */
+	unsigned short closing_wait2;	/* no longer used... */
+	int reserved[4];
+};
+
+
+#ifndef _PATH_STDPATH
+#define _PATH_STDPATH	"/usr/bin:/bin:/usr/sbin:/sbin"
+#endif
+
+#if defined CONFIG_FEATURE_INIT_COREDUMPS
+/*
+ * When a file named CORE_ENABLE_FLAG_FILE exists, setrlimit is called 
+ * before processes are spawned to set core file size as unlimited.
+ * This is for debugging only.  Don't use this is production, unless
+ * you want core dumps lying about....
+ */
+#define CORE_ENABLE_FLAG_FILE "/.init_enable_core"
+#include <sys/resource.h>
+#include <sys/time.h>
+#endif
+
+#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
+
+#define SHELL        "/bin/sh"	/* Default shell */
+#define LOGIN_SHELL  "-" SHELL	/* Default login shell */
+#define INITTAB      "/etc/inittab"	/* inittab file location */
+#ifndef INIT_SCRIPT
+#define INIT_SCRIPT  "/etc/init.d/rcS"	/* Default sysinit script. */
+#endif
+
+#define MAXENV	16		/* Number of env. vars */
+
+#define CONSOLE_BUFF_SIZE 32
+
+/* Allowed init action types */
+#define SYSINIT     0x001
+#define RESPAWN     0x002
+#define ASKFIRST    0x004
+#define WAIT        0x008
+#define ONCE        0x010
+#define CTRLALTDEL  0x020
+#define SHUTDOWN    0x040
+#define RESTART     0x080
+
+/* A mapping between "inittab" action name strings and action type codes. */
+struct init_action_type {
+	const char *name;
+	int action;
+};
+
+static const struct init_action_type actions[] = {
+	{"sysinit", SYSINIT},
+	{"respawn", RESPAWN},
+	{"askfirst", ASKFIRST},
+	{"wait", WAIT},
+	{"once", ONCE},
+	{"ctrlaltdel", CTRLALTDEL},
+	{"shutdown", SHUTDOWN},
+	{"restart", RESTART},
+	{0, 0}
+};
+
+/* Set up a linked list of init_actions, to be read from inittab */
+struct init_action {
+	pid_t pid;
+	char command[INIT_BUFFS_SIZE];
+	char terminal[CONSOLE_BUFF_SIZE];
+	struct init_action *next;
+	int action;
+};
+
+/* Static variables */
+static struct init_action *init_action_list = NULL;
+static char console[CONSOLE_BUFF_SIZE] = _PATH_CONSOLE;
+
+#ifndef CONFIG_SYSLOGD
+static char *log = VC_5;
+#endif
+static sig_atomic_t got_cont = 0;
+static const int LOG = 0x1;
+static const int CONSOLE = 0x2;
+
+#if defined CONFIG_FEATURE_EXTRA_QUIET
+static const int MAYBE_CONSOLE = 0x0;
+#else
+#define MAYBE_CONSOLE	CONSOLE
+#endif
+#ifndef RB_HALT_SYSTEM
+static const int RB_HALT_SYSTEM = 0xcdef0123;
+static const int RB_ENABLE_CAD = 0x89abcdef;
+static const int RB_DISABLE_CAD = 0;
+
+#define RB_POWER_OFF    0x4321fedc
+static const int RB_AUTOBOOT = 0x01234567;
+#endif
+
+static const char * const environment[] = {
+	"HOME=/",
+	"PATH=" _PATH_STDPATH,
+	"SHELL=" SHELL,
+	"USER=root",
+	NULL
+};
+
+/* Function prototypes */
+static void delete_init_action(struct init_action *a);
+static int waitfor(const struct init_action *a);
+static void halt_signal(int sig);
+
+
+static void loop_forever(void)
+{
+	while (1)
+		sleep(1);
+}
+
+/* Print a message to the specified device.
+ * Device may be bitwise-or'd from LOG | CONSOLE */
+#ifndef DEBUG_INIT
+static inline void messageD(int device, const char *fmt, ...)
+{
+}
+#else
+#define messageD message
+#endif
+static void message(int device, const char *fmt, ...)
+	__attribute__ ((format(printf, 2, 3)));
+static void message(int device, const char *fmt, ...)
+{
+	va_list arguments;
+	int l;
+	char msg[1024];
+#ifndef CONFIG_SYSLOGD
+	static int log_fd = -1;
+#endif
+
+	msg[0] = '\r';
+		va_start(arguments, fmt);
+	l = vsnprintf(msg + 1, sizeof(msg) - 2, fmt, arguments) + 1;
+		va_end(arguments);
+
+#ifdef CONFIG_SYSLOGD
+	/* Log the message to syslogd */
+	if (device & LOG) {
+		/* don`t out "\r\n" */
+		syslog_msg(LOG_DAEMON, LOG_INFO, msg + 1);
+	}
+
+	msg[l++] = '\n';
+	msg[l] = 0;
+#else
+
+	msg[l++] = '\n';
+	msg[l] = 0;
+	/* Take full control of the log tty, and never close it.
+	 * It's mine, all mine!  Muhahahaha! */
+	if (log_fd < 0) {
+		if ((log_fd = device_open(log, O_RDWR | O_NDELAY | O_NOCTTY)) < 0) {
+			log_fd = -2;
+			bb_error_msg("Bummer, can't write to log on %s!", log);
+			device = CONSOLE;
+		} else {
+			fcntl(log_fd, F_SETFD, FD_CLOEXEC);
+		}
+	}
+	if ((device & LOG) && (log_fd >= 0)) {
+		bb_full_write(log_fd, msg, l);
+	}
+#endif
+
+	if (device & CONSOLE) {
+		int fd = device_open(_PATH_CONSOLE,
+					O_WRONLY | O_NOCTTY | O_NDELAY);
+		/* Always send console messages to /dev/console so people will see them. */
+		if (fd >= 0) {
+			bb_full_write(fd, msg, l);
+			close(fd);
+#ifdef DEBUG_INIT
+		/* all descriptors may be closed */
+		} else {
+			bb_error_msg("Bummer, can't print: ");
+			va_start(arguments, fmt);
+			vfprintf(stderr, fmt, arguments);
+			va_end(arguments);
+#endif
+		}
+	}
+}
+
+/* Set terminal settings to reasonable defaults */
+static void set_term(int fd)
+{
+	struct termios tty;
+
+	tcgetattr(fd, &tty);
+
+	/* set control chars */
+	tty.c_cc[VINTR] = 3;	/* C-c */
+	tty.c_cc[VQUIT] = 28;	/* C-\ */
+	tty.c_cc[VERASE] = 127;	/* C-? */
+	tty.c_cc[VKILL] = 21;	/* C-u */
+	tty.c_cc[VEOF] = 4;	/* C-d */
+	tty.c_cc[VSTART] = 17;	/* C-q */
+	tty.c_cc[VSTOP] = 19;	/* C-s */
+	tty.c_cc[VSUSP] = 26;	/* C-z */
+
+	/* use line dicipline 0 */
+	tty.c_line = 0;
+
+	/* Make it be sane */
+	tty.c_cflag &= CBAUD | CBAUDEX | CSIZE | CSTOPB | PARENB | PARODD;
+	tty.c_cflag |= CREAD | HUPCL | CLOCAL;
+
+
+	/* input modes */
+	tty.c_iflag = ICRNL | IXON | IXOFF;
+
+	/* output modes */
+	tty.c_oflag = OPOST | ONLCR;
+
+	/* local modes */
+	tty.c_lflag =
+		ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN;
+
+	tcsetattr(fd, TCSANOW, &tty);
+}
+
+/* How much memory does this machine have?
+   Units are kBytes to avoid overflow on 4GB machines */
+static int check_free_memory(void)
+{
+	struct sysinfo info;
+	unsigned int result, u, s = 10;
+
+	if (sysinfo(&info) != 0) {
+		bb_perror_msg("Error checking free memory");
+		return -1;
+	}
+
+	/* Kernels 2.0.x and 2.2.x return info.mem_unit==0 with values in bytes.
+	 * Kernels 2.4.0 return info.mem_unit in bytes. */
+	u = info.mem_unit;
+	if (u == 0)
+		u = 1;
+	while ((u & 1) == 0 && s > 0) {
+		u >>= 1;
+		s--;
+	}
+	result = (info.totalram >> s) + (info.totalswap >> s);
+	result = result * u;
+	if (result < 0)
+		result = INT_MAX;
+	return result;
+}
+
+static void console_init(void)
+{
+	int fd;
+	int tried = 0;
+	struct vt_stat vt;
+	struct serial_struct sr;
+	char *s;
+
+	if ((s = getenv("CONSOLE")) != NULL || (s = getenv("console")) != NULL) {
+		safe_strncpy(console, s, sizeof(console));
+#if #cpu(sparc)
+	/* sparc kernel supports console=tty[ab] parameter which is also 
+	 * passed to init, so catch it here */
+		/* remap tty[ab] to /dev/ttyS[01] */
+		if (strcmp(s, "ttya") == 0)
+			safe_strncpy(console, SC_0, sizeof(console));
+		else if (strcmp(s, "ttyb") == 0)
+			safe_strncpy(console, SC_1, sizeof(console));
+#endif
+	} else {
+		/* 2.2 kernels: identify the real console backend and try to use it */
+		if (ioctl(0, TIOCGSERIAL, &sr) == 0) {
+			/* this is a serial console */
+			snprintf(console, sizeof(console) - 1, SC_FORMAT, sr.line);
+		} else if (ioctl(0, VT_GETSTATE, &vt) == 0) {
+			/* this is linux virtual tty */
+			snprintf(console, sizeof(console) - 1, VC_FORMAT, vt.v_active);
+		} else {
+			safe_strncpy(console, _PATH_CONSOLE, sizeof(console));
+			tried++;
+		}
+	}
+
+	while ((fd = open(console, O_RDONLY | O_NONBLOCK)) < 0 && tried < 2) {
+		/* Can't open selected console -- try
+			logical system console and VT_MASTER */
+		safe_strncpy(console, (tried == 0 ? _PATH_CONSOLE : CURRENT_VC),
+							sizeof(console));
+		tried++;
+	}
+	if (fd < 0) {
+		/* Perhaps we should panic here? */
+#ifndef CONFIG_SYSLOGD
+		log =
+#endif
+		safe_strncpy(console, "/dev/null", sizeof(console));
+	} else {
+		s = getenv("TERM");
+		/* check for serial console */
+		if (ioctl(fd, TIOCGSERIAL, &sr) == 0) {
+			/* Force the TERM setting to vt102 for serial console --
+			 * if TERM is set to linux (the default) */
+			if (s == NULL || strcmp(s, "linux") == 0)
+				putenv("TERM=vt102");
+#ifndef CONFIG_SYSLOGD
+			log = console;
+#endif
+		} else {
+			if (s == NULL)
+				putenv("TERM=linux");
+		}
+		close(fd);
+	}
+	messageD(LOG, "console=%s", console);
+}
+
+static void fixup_argv(int argc, char **argv, char *new_argv0)
+{
+	int len;
+
+	/* Fix up argv[0] to be certain we claim to be init */
+	len = strlen(argv[0]);
+	memset(argv[0], 0, len);
+	safe_strncpy(argv[0], new_argv0, len + 1);
+
+	/* Wipe argv[1]-argv[N] so they don't clutter the ps listing */
+	len = 1;
+	while (argc > len) {
+		memset(argv[len], 0, strlen(argv[len]));
+		len++;
+	}
+}
+
+static pid_t run(const struct init_action *a)
+{
+	struct stat sb;
+	int i, junk;
+	pid_t pid, pgrp, tmp_pid;
+	char *s, *tmpCmd, *cmd[INIT_BUFFS_SIZE], *cmdpath;
+	char buf[INIT_BUFFS_SIZE + 6];	/* INIT_BUFFS_SIZE+strlen("exec ")+1 */
+	sigset_t nmask, omask;
+	static const char press_enter[] =
+#ifdef CUSTOMIZED_BANNER
+#include CUSTOMIZED_BANNER
+#endif
+		"\nPlease press Enter to activate this console. ";
+
+	/* Block sigchild while forking.  */
+	sigemptyset(&nmask);
+	sigaddset(&nmask, SIGCHLD);
+	sigprocmask(SIG_BLOCK, &nmask, &omask);
+
+	if ((pid = fork()) == 0) {
+		/* Clean up */
+		close(0);
+		close(1);
+		close(2);
+		sigprocmask(SIG_SETMASK, &omask, NULL);
+
+		/* Reset signal handlers that were set by the parent process */
+		signal(SIGUSR1, SIG_DFL);
+		signal(SIGUSR2, SIG_DFL);
+		signal(SIGINT, SIG_DFL);
+		signal(SIGTERM, SIG_DFL);
+		signal(SIGHUP, SIG_DFL);
+		signal(SIGCONT, SIG_DFL);
+		signal(SIGSTOP, SIG_DFL);
+		signal(SIGTSTP, SIG_DFL);
+
+		/* Create a new session and make ourself the process
+		 * group leader */
+		setsid();
+
+		/* Open the new terminal device */
+		if ((device_open(a->terminal, O_RDWR)) < 0) {
+			if (stat(a->terminal, &sb) != 0) {
+				message(LOG | CONSOLE, "device '%s' does not exist.",
+						a->terminal);
+				_exit(1);
+			}
+			message(LOG | CONSOLE, "Bummer, can't open %s", a->terminal);
+			_exit(1);
+		}
+
+		/* Make sure the terminal will act fairly normal for us */
+		set_term(0);
+		/* Setup stdout, stderr for the new process so
+		 * they point to the supplied terminal */
+		dup(0);
+		dup(0);
+
+		/* If the init Action requires us to wait, then force the
+		 * supplied terminal to be the controlling tty. */
+		if (a->action & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN | RESTART)) {
+
+			/* Now fork off another process to just hang around */
+			if ((pid = fork()) < 0) {
+				message(LOG | CONSOLE, "Can't fork!");
+				_exit(1);
+			}
+
+			if (pid > 0) {
+
+				/* We are the parent -- wait till the child is done */
+				signal(SIGINT, SIG_IGN);
+				signal(SIGTSTP, SIG_IGN);
+				signal(SIGQUIT, SIG_IGN);
+				signal(SIGCHLD, SIG_DFL);
+
+				/* Wait for child to exit */
+				while ((tmp_pid = waitpid(pid, &junk, 0)) != pid);
+
+				/* See if stealing the controlling tty back is necessary */
+				pgrp = tcgetpgrp(0);
+				if (pgrp != getpid())
+					_exit(0);
+
+				/* Use a temporary process to steal the controlling tty. */
+				if ((pid = fork()) < 0) {
+					message(LOG | CONSOLE, "Can't fork!");
+					_exit(1);
+				}
+				if (pid == 0) {
+					setsid();
+					ioctl(0, TIOCSCTTY, 1);
+					_exit(0);
+				}
+				while ((tmp_pid = waitpid(pid, &junk, 0)) != pid) {
+					if (tmp_pid < 0 && errno == ECHILD)
+						break;
+				}
+				_exit(0);
+			}
+
+			/* Now fall though to actually execute things */
+		}
+
+		/* See if any special /bin/sh requiring characters are present */
+		if (strpbrk(a->command, "~`!$^&*()=|\\{}[];\"'<>?") != NULL) {
+			cmd[0] = SHELL;
+			cmd[1] = "-c";
+			cmd[2] = strcat(strcpy(buf, "exec "), a->command);
+			cmd[3] = NULL;
+		} else {
+			/* Convert command (char*) into cmd (char**, one word per string) */
+			strcpy(buf, a->command);
+			s = buf;
+			for (tmpCmd = buf, i = 0; (tmpCmd = strsep(&s, " \t")) != NULL;) {
+				if (*tmpCmd != '\0') {
+					cmd[i] = tmpCmd;
+					i++;
+				}
+			}
+			cmd[i] = NULL;
+		}
+
+		cmdpath = cmd[0];
+
+		/*
+		   Interactive shells want to see a dash in argv[0].  This
+		   typically is handled by login, argv will be setup this 
+		   way if a dash appears at the front of the command path 
+		   (like "-/bin/sh").
+		 */
+
+		if (*cmdpath == '-') {
+
+			/* skip over the dash */
+			++cmdpath;
+
+			/* find the last component in the command pathname */
+			s = bb_get_last_path_component(cmdpath);
+
+			/* make a new argv[0] */
+			if ((cmd[0] = malloc(strlen(s) + 2)) == NULL) {
+				message(LOG | CONSOLE, bb_msg_memory_exhausted);
+				cmd[0] = cmdpath;
+			} else {
+				cmd[0][0] = '-';
+				strcpy(cmd[0] + 1, s);
+			}
+		}
+
+		if (a->action & ASKFIRST) {
+			char c;
+			/*
+			 * Save memory by not exec-ing anything large (like a shell)
+			 * before the user wants it. This is critical if swap is not
+			 * enabled and the system has low memory. Generally this will
+			 * be run on the second virtual console, and the first will
+			 * be allowed to start a shell or whatever an init script 
+			 * specifies.
+			 */
+			messageD(LOG, "Waiting for enter to start '%s'"
+						"(pid %d, terminal %s)\n",
+					  cmdpath, getpid(), a->terminal);
+			bb_full_write(1, press_enter, sizeof(press_enter) - 1);
+			while(read(0, &c, 1) == 1 && c != '\n')
+				;
+		}
+
+		/* Log the process name and args */
+		message(LOG, "Starting pid %d, console %s: '%s'",
+				  getpid(), a->terminal, cmdpath);
+
+#if defined CONFIG_FEATURE_INIT_COREDUMPS
+		if (stat(CORE_ENABLE_FLAG_FILE, &sb) == 0) {
+			struct rlimit limit;
+
+			limit.rlim_cur = RLIM_INFINITY;
+			limit.rlim_max = RLIM_INFINITY;
+			setrlimit(RLIMIT_CORE, &limit);
+		}
+#endif
+
+		/* Now run it.  The new program will take over this PID, 
+		 * so nothing further in init.c should be run. */
+		execv(cmdpath, cmd);
+
+		/* We're still here?  Some error happened. */
+		message(LOG | CONSOLE, "Bummer, could not run '%s': %m", cmdpath);
+		_exit(-1);
+	}
+	sigprocmask(SIG_SETMASK, &omask, NULL);
+	return pid;
+}
+
+static int waitfor(const struct init_action *a)
+{
+	int pid;
+	int status, wpid;
+
+	pid = run(a);
+	while (1) {
+		wpid = wait(&status);
+		if (wpid > 0 && wpid != pid) {
+			continue;
+		}
+		if (wpid == pid)
+			break;
+	}
+	return wpid;
+}
+
+/* Run all commands of a particular type */
+static void run_actions(int action)
+{
+	struct init_action *a, *tmp;
+
+	for (a = init_action_list; a; a = tmp) {
+		tmp = a->next;
+		if (a->action == action) {
+			if (a->action & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN | RESTART)) {
+				waitfor(a);
+				delete_init_action(a);
+			} else if (a->action & ONCE) {
+				run(a);
+				delete_init_action(a);
+			} else if (a->action & (RESPAWN | ASKFIRST)) {
+				/* Only run stuff with pid==0.  If they have
+				 * a pid, that means it is still running */
+				if (a->pid == 0) {
+					a->pid = run(a);
+				}
+			}
+		}
+	}
+}
+
+#ifndef DEBUG_INIT
+static void init_reboot(unsigned long magic)
+{
+	pid_t pid;
+	/* We have to fork here, since the kernel calls do_exit(0) in
+	 * linux/kernel/sys.c, which can cause the machine to panic when 
+	 * the init process is killed.... */
+	if ((pid = fork()) == 0) {
+		reboot(magic);
+		_exit(0);
+	}
+	waitpid (pid, NULL, 0);
+}
+
+static void shutdown_system(void)
+{
+	sigset_t block_signals;
+
+	/* run everything to be run at "shutdown".  This is done _prior_
+	 * to killing everything, in case people wish to use scripts to
+	 * shut things down gracefully... */
+	run_actions(SHUTDOWN);
+
+	/* first disable all our signals */
+	sigemptyset(&block_signals);
+	sigaddset(&block_signals, SIGHUP);
+	sigaddset(&block_signals, SIGCHLD);
+	sigaddset(&block_signals, SIGUSR1);
+	sigaddset(&block_signals, SIGUSR2);
+	sigaddset(&block_signals, SIGINT);
+	sigaddset(&block_signals, SIGTERM);
+	sigaddset(&block_signals, SIGCONT);
+	sigaddset(&block_signals, SIGSTOP);
+	sigaddset(&block_signals, SIGTSTP);
+	sigprocmask(SIG_BLOCK, &block_signals, NULL);
+
+	/* Allow Ctrl-Alt-Del to reboot system. */
+	init_reboot(RB_ENABLE_CAD);
+
+	message(CONSOLE | LOG, "The system is going down NOW !!");
+	sync();
+
+	/* Send signals to every process _except_ pid 1 */
+	message(CONSOLE | LOG, "Sending SIGTERM to all processes.");
+	kill(-1, SIGTERM);
+	sleep(1);
+	sync();
+
+	message(CONSOLE | LOG, "Sending SIGKILL to all processes.");
+	kill(-1, SIGKILL);
+	sleep(1);
+
+	sync();
+}
+
+static void exec_signal(int sig)
+{
+	struct init_action *a, *tmp;
+	sigset_t unblock_signals;
+
+	for (a = init_action_list; a; a = tmp) {
+		tmp = a->next;
+		if (a->action & RESTART) {
+			struct stat sb;
+
+			shutdown_system();
+
+			/* unblock all signals, blocked in shutdown_system() */
+			sigemptyset(&unblock_signals);
+			sigaddset(&unblock_signals, SIGHUP);
+			sigaddset(&unblock_signals, SIGCHLD);
+			sigaddset(&unblock_signals, SIGUSR1);
+			sigaddset(&unblock_signals, SIGUSR2);
+			sigaddset(&unblock_signals, SIGINT);
+			sigaddset(&unblock_signals, SIGTERM);
+			sigaddset(&unblock_signals, SIGCONT);
+			sigaddset(&unblock_signals, SIGSTOP);
+			sigaddset(&unblock_signals, SIGTSTP);
+			sigprocmask(SIG_UNBLOCK, &unblock_signals, NULL);
+
+			/* Close whatever files are open. */
+			close(0);
+			close(1);
+			close(2);
+
+			/* Open the new terminal device */
+			if ((device_open(a->terminal, O_RDWR)) < 0) {
+				if (stat(a->terminal, &sb) != 0) {
+					message(LOG | CONSOLE, "device '%s' does not exist.", a->terminal);
+				} else {
+					message(LOG | CONSOLE, "Bummer, can't open %s", a->terminal);
+				}
+				halt_signal(SIGUSR1);
+			}
+
+			/* Make sure the terminal will act fairly normal for us */
+			set_term(0);
+			/* Setup stdout, stderr on the supplied terminal */
+			dup(0);
+			dup(0);
+
+			messageD(CONSOLE | LOG, "Trying to re-exec %s", a->command);
+			execl(a->command, a->command, NULL);
+
+			message(CONSOLE | LOG, "exec of '%s' failed: %m",
+					a->command);
+			sync();
+			sleep(2);
+			init_reboot(RB_HALT_SYSTEM);
+			loop_forever();
+		}
+	}
+}
+
+static void halt_signal(int sig)
+{
+	shutdown_system();
+	message(CONSOLE | LOG,
+#if #cpu(s390)
+			/* Seems the s390 console is Wierd(tm). */
+			"The system is halted. You may reboot now."
+#else
+			"The system is halted. Press Reset or turn off power"
+#endif
+		);
+	sync();
+
+	/* allow time for last message to reach serial console */
+	sleep(2);
+
+	if (sig == SIGUSR2)
+		init_reboot(RB_POWER_OFF);
+	else
+		init_reboot(RB_HALT_SYSTEM);
+
+	loop_forever();
+}
+
+static void reboot_signal(int sig)
+{
+	shutdown_system();
+	message(CONSOLE | LOG, "Please stand by while rebooting the system.");
+	sync();
+
+	/* allow time for last message to reach serial console */
+	sleep(2);
+
+	init_reboot(RB_AUTOBOOT);
+
+	loop_forever();
+}
+
+static void ctrlaltdel_signal(int sig)
+{
+	run_actions(CTRLALTDEL);
+}
+
+/* The SIGSTOP & SIGTSTP handler */
+static void stop_handler(int sig)
+{
+	int saved_errno = errno;
+
+	got_cont = 0;
+	while (!got_cont)
+		pause();
+	got_cont = 0;
+	errno = saved_errno;
+}
+
+/* The SIGCONT handler */
+static void cont_handler(int sig)
+{
+	got_cont = 1;
+}
+
+/* Reap any zombie processes that are reparented to init */
+static void child_handler(int sig)
+{
+	int status;
+	while ( wait3(&status, WNOHANG, NULL) > 0 );
+}
+
+#endif							/* ! DEBUG_INIT */
+
+static void new_init_action(int action, char *command, const char *cons)
+{
+	struct init_action *new_action, *a;
+
+	if (*cons == '\0')
+		cons = console;
+
+	/* do not run entries if console device is not available */
+	if (access(cons, R_OK | W_OK))
+		return;
+	if (strcmp(cons, "/dev/null") == 0 && (action & ASKFIRST))
+		return;
+
+	new_action = calloc((size_t) (1), sizeof(struct init_action));
+	if (!new_action) {
+		message(LOG | CONSOLE, "Memory allocation failure");
+		loop_forever();
+	}
+
+	/* Append to the end of the list */
+	for (a = init_action_list; a && a->next; a = a->next) {
+		/* don't enter action if it's already in the list */
+		if ((strcmp(a->command, command) == 0) && 
+		    (strcmp(a->terminal, cons) ==0)) {
+			free(new_action);
+			return;
+		}
+	}
+	if (a) {
+		a->next = new_action;
+	} else {
+		init_action_list = new_action;
+	}
+	strcpy(new_action->command, command);
+	new_action->action = action;
+	strcpy(new_action->terminal, cons);
+#if 0   /* calloc zeroed always */
+	new_action->pid = 0;
+#endif
+	messageD(LOG|CONSOLE, "command='%s' action='%d' terminal='%s'\n",
+		new_action->command, new_action->action, new_action->terminal);
+}
+
+static void delete_init_action(struct init_action *action)
+{
+	struct init_action *a, *b = NULL;
+
+	for (a = init_action_list; a; b = a, a = a->next) {
+		if (a == action) {
+			if (b == NULL) {
+				init_action_list = a->next;
+			} else {
+				b->next = a->next;
+			}
+			free(a);
+			break;
+		}
+	}
+}
+
+/* Make sure there is enough memory to do something useful. *
+ * Calls "swapon -a" if needed so be sure /etc/fstab is present... */
+static void check_memory(void)
+{
+	struct stat statBuf;
+
+	if (check_free_memory() > 1000)
+		return;
+
+#if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__)
+	if (stat("/etc/fstab", &statBuf) == 0) {
+		/* swapon -a requires /proc typically */
+		new_init_action(SYSINIT, "/bin/mount -t proc proc /proc", "");
+		/* Try to turn on swap */
+		new_init_action(SYSINIT, "/sbin/swapon -a", "");
+		run_actions(SYSINIT);   /* wait and removing */
+		if (check_free_memory() < 1000)
+			goto goodnight;
+	} else
+		goto goodnight;
+	return;
+#endif
+
+  goodnight:
+	message(CONSOLE, "Sorry, your computer does not have enough memory.");
+	loop_forever();
+}
+
+/* NOTE that if CONFIG_FEATURE_USE_INITTAB is NOT defined,
+ * then parse_inittab() simply adds in some default
+ * actions(i.e., runs INIT_SCRIPT and then starts a pair 
+ * of "askfirst" shells).  If CONFIG_FEATURE_USE_INITTAB 
+ * _is_ defined, but /etc/inittab is missing, this 
+ * results in the same set of default behaviors.
+ */
+static void parse_inittab(void)
+{
+#ifdef CONFIG_FEATURE_USE_INITTAB
+	FILE *file;
+	char buf[INIT_BUFFS_SIZE], lineAsRead[INIT_BUFFS_SIZE];
+	char tmpConsole[CONSOLE_BUFF_SIZE];
+	char *id, *runlev, *action, *command, *eol;
+	const struct init_action_type *a = actions;
+
+
+	file = fopen(INITTAB, "r");
+	if (file == NULL) {
+		/* No inittab file -- set up some default behavior */
+#endif
+		/* Reboot on Ctrl-Alt-Del */
+		new_init_action(CTRLALTDEL, "/sbin/reboot", "");
+		/* Umount all filesystems on halt/reboot */
+		new_init_action(SHUTDOWN, "/bin/umount -a -r", "");
+#if !defined(__UCLIBC__) || defined(__UCLIBC_HAS_MMU__)
+		/* Swapoff on halt/reboot */
+		new_init_action(SHUTDOWN, "/sbin/swapoff -a", "");
+#endif
+		/* Prepare to restart init when a HUP is received */
+		new_init_action(RESTART, "/sbin/init", "");
+		/* Askfirst shell on tty1-4 */
+		new_init_action(ASKFIRST, LOGIN_SHELL, "");
+		new_init_action(ASKFIRST, LOGIN_SHELL, VC_2);
+		new_init_action(ASKFIRST, LOGIN_SHELL, VC_3);
+		new_init_action(ASKFIRST, LOGIN_SHELL, VC_4);
+		/* sysinit */
+		new_init_action(SYSINIT, INIT_SCRIPT, "");
+
+		return;
+#ifdef CONFIG_FEATURE_USE_INITTAB
+	}
+
+	while (fgets(buf, INIT_BUFFS_SIZE, file) != NULL) {
+		/* Skip leading spaces */
+		for (id = buf; *id == ' ' || *id == '\t'; id++);
+
+		/* Skip the line if it's a comment */
+		if (*id == '#' || *id == '\n')
+			continue;
+
+		/* Trim the trailing \n */
+		eol = strrchr(id, '\n');
+		if (eol != NULL)
+			*eol = '\0';
+
+		/* Keep a copy around for posterity's sake (and error msgs) */
+		strcpy(lineAsRead, buf);
+
+		/* Separate the ID field from the runlevels */
+		runlev = strchr(id, ':');
+		if (runlev == NULL || *(runlev + 1) == '\0') {
+			message(LOG | CONSOLE, "Bad inittab entry: %s", lineAsRead);
+			continue;
+		} else {
+			*runlev = '\0';
+			++runlev;
+		}
+
+		/* Separate the runlevels from the action */
+		action = strchr(runlev, ':');
+		if (action == NULL || *(action + 1) == '\0') {
+			message(LOG | CONSOLE, "Bad inittab entry: %s", lineAsRead);
+			continue;
+		} else {
+			*action = '\0';
+			++action;
+		}
+
+		/* Separate the action from the command */
+		command = strchr(action, ':');
+		if (command == NULL || *(command + 1) == '\0') {
+			message(LOG | CONSOLE, "Bad inittab entry: %s", lineAsRead);
+			continue;
+		} else {
+			*command = '\0';
+			++command;
+		}
+
+		/* Ok, now process it */
+		for (a = actions; a->name != 0; a++) {
+			if (strcmp(a->name, action) == 0) {
+				if (*id != '\0') {
+					if(strncmp(id, "/dev/", 5) == 0)
+						id += 5;
+					strcpy(tmpConsole, "/dev/");
+					safe_strncpy(tmpConsole + 5, id,
+						CONSOLE_BUFF_SIZE - 5);
+					id = tmpConsole;
+				}
+				new_init_action(a->action, command, id);
+				break;
+			}
+		}
+		if (a->name == 0) {
+			/* Choke on an unknown action */
+			message(LOG | CONSOLE, "Bad inittab entry: %s", lineAsRead);
+		}
+	}
+	fclose(file);
+	return;
+#endif							/* CONFIG_FEATURE_USE_INITTAB */
+}
+
+static void reload_signal(int sig)
+{
+        message(LOG, "Reloading /etc/inittab");
+        parse_inittab();
+	run_actions(RESPAWN);
+        return;
+}
+                                                                                
+extern int init_main(int argc, char **argv)
+{
+	struct init_action *a;
+	pid_t wpid;
+	int status;
+
+	if (argc > 1 && !strcmp(argv[1], "-q")) {
+		return kill_init(SIGHUP);
+	}
+#ifndef DEBUG_INIT
+	/* Expect to be invoked as init with PID=1 or be invoked as linuxrc */
+	if (getpid() != 1
+#ifdef CONFIG_FEATURE_INITRD
+		&& strstr(bb_applet_name, "linuxrc") == NULL
+#endif
+		) {
+		bb_show_usage();
+	}
+	/* Set up sig handlers  -- be sure to
+	 * clear all of these in run() */
+	signal(SIGHUP, exec_signal);
+	signal(SIGUSR1, halt_signal);
+	signal(SIGUSR2, halt_signal);
+	signal(SIGINT, ctrlaltdel_signal);
+	signal(SIGTERM, reboot_signal);
+	signal(SIGCONT, cont_handler);
+	signal(SIGSTOP, stop_handler);
+	signal(SIGTSTP, stop_handler);
+	signal(SIGCHLD, child_handler);
+
+	/* Turn off rebooting via CTL-ALT-DEL -- we get a 
+	 * SIGINT on CAD so we can shut things down gracefully... */
+	init_reboot(RB_DISABLE_CAD);
+#endif
+
+	/* Figure out where the default console should be */
+	console_init();
+
+	/* Close whatever files are open, and reset the console. */
+	close(0);
+	close(1);
+	close(2);
+
+	if (device_open(console, O_RDWR | O_NOCTTY) == 0) {
+		set_term(0);
+		close(0);
+	}
+
+	chdir("/");
+	setsid();
+	{
+		const char * const *e;
+		/* Make sure environs is set to something sane */
+		for(e = environment; *e; e++)
+			putenv((char *) *e);
+	}
+	/* Hello world */
+	message(MAYBE_CONSOLE | LOG, "init started:  %s", bb_msg_full_version);
+
+	/* Make sure there is enough memory to do something useful. */
+	check_memory();
+
+	/* Check if we are supposed to be in single user mode */
+	if (argc > 1 && (!strcmp(argv[1], "single") ||
+					 !strcmp(argv[1], "-s") || !strcmp(argv[1], "1"))) {
+		/* Start a shell on console */
+		new_init_action(RESPAWN, LOGIN_SHELL, "");
+	} else {
+		/* Not in single user mode -- see what inittab says */
+
+		/* NOTE that if CONFIG_FEATURE_USE_INITTAB is NOT defined,
+		 * then parse_inittab() simply adds in some default
+		 * actions(i.e., runs INIT_SCRIPT and then starts a pair 
+		 * of "askfirst" shells */
+		parse_inittab();
+	}
+
+	/* Make the command line just say "init"  -- thats all, nothing else */
+	fixup_argv(argc, argv, "init");
+
+	/* Now run everything that needs to be run */
+
+	/* First run the sysinit command */
+	run_actions(SYSINIT);
+
+	/* Next run anything that wants to block */
+	run_actions(WAIT);
+
+	/* Next run anything to be run only once */
+	run_actions(ONCE);
+
+	/* If there is nothing else to do, stop */
+	if (init_action_list == NULL) {
+		message(LOG | CONSOLE,
+				"No more tasks for init -- sleeping forever.");
+		loop_forever();
+	}
+
+	/* Redefine SIGHUP to reread /etc/inittab */
+	signal(SIGHUP, reload_signal);
+
+	/* Now run the looping stuff for the rest of forever */
+	while (1) {
+		/* run the respawn stuff */
+		run_actions(RESPAWN);
+
+		/* run the askfirst stuff */
+		run_actions(ASKFIRST);
+
+		/* Don't consume all CPU time -- sleep a bit */
+		sleep(1);
+
+		/* Wait for a child process to exit */
+		wpid = wait(&status);
+		while (wpid > 0) {
+			/* Find out who died and clean up their corpse */
+			for (a = init_action_list; a; a = a->next) {
+				if (a->pid == wpid) {
+					/* Set the pid to 0 so that the process gets
+					 * restarted by run_actions() */
+					a->pid = 0;
+					message(LOG, "Process '%s' (pid %d) exited.  "
+							"Scheduling it for restart.",
+							a->command, wpid);
+				}
+			}
+			/* see if anyone else is waiting to be reaped */
+			wpid = waitpid (-1, &status, WNOHANG);
+		}
+	}
+}
+
+/*
+Local Variables:
+c-file-style: "linux"
+c-basic-offset: 4
+tab-width: 4
+End:
+*/
diff --git a/release/src/router/busybox/init/init_shared.c b/release/src/router/busybox/init/init_shared.c
new file mode 100644
index 00000000..339add13
--- /dev/null
+++ b/release/src/router/busybox/init/init_shared.c
@@ -0,0 +1,97 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Stuff shared between init, reboot, halt, and poweroff
+ *
+ * Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <sys/reboot.h>
+#include <sys/reboot.h>
+#include <sys/syslog.h>
+#include "busybox.h"
+#include "init_shared.h"
+
+extern int kill_init(int sig)
+{
+#ifdef CONFIG_FEATURE_INITRD
+	/* don't assume init's pid == 1 */
+	long *pid = find_pid_by_name("init");
+	if (!pid || *pid<=0) {
+		pid = find_pid_by_name("linuxrc");
+		if (!pid || *pid<=0)
+			bb_error_msg_and_die("no process killed");
+	}
+	return(kill(*pid, sig));
+#else
+	return(kill(1, sig));
+#endif
+}
+
+#ifndef CONFIG_INIT
+const char * const bb_shutdown_format = "\r%s\n";
+extern int bb_shutdown_system(unsigned long magic)
+{
+	int pri = LOG_KERN|LOG_NOTICE|LOG_FACMASK;
+	const char *message;
+
+	/* Don't kill ourself */
+	signal(SIGTERM,SIG_IGN);
+	signal(SIGHUP,SIG_IGN);
+	setpgrp();
+
+	/* Allow Ctrl-Alt-Del to reboot system. */
+#ifndef RB_ENABLE_CAD
+#define RB_ENABLE_CAD	0x89abcdef
+#endif
+	reboot(RB_ENABLE_CAD);
+
+	openlog(bb_applet_name, 0, pri);
+
+	message = "\nThe system is going down NOW !!";
+	syslog(pri, "%s", message);
+	printf(bb_shutdown_format, message);
+
+	sync();
+
+	/* Send signals to every process _except_ pid 1 */
+	message = "Sending SIGTERM to all processes.";
+	syslog(pri, "%s", message);
+	printf(bb_shutdown_format, message);
+
+	kill(-1, SIGTERM);
+	sleep(1);
+	sync();
+
+	message = "Sending SIGKILL to all processes.";
+	syslog(pri, "%s", message);
+	printf(bb_shutdown_format, message);
+
+	kill(-1, SIGKILL);
+	sleep(1);
+
+	sync();
+
+	reboot(magic);
+	return 0; /* Shrug */
+}
+#endif
+
diff --git a/release/src/router/busybox/init/init_shared.h b/release/src/router/busybox/init/init_shared.h
new file mode 100644
index 00000000..1e4cfac9
--- /dev/null
+++ b/release/src/router/busybox/init/init_shared.h
@@ -0,0 +1,3 @@
+extern int kill_init(int sig);
+extern int bb_shutdown_system(unsigned long magic);
+
diff --git a/release/src/router/busybox/init/mesg.c b/release/src/router/busybox/init/mesg.c
new file mode 100644
index 00000000..7b8acf65
--- /dev/null
+++ b/release/src/router/busybox/init/mesg.c
@@ -0,0 +1,58 @@
+/*
+ *  mesg implementation for busybox
+ *
+ *  Copyright (c) 2002 Manuel Novoa III  <mjn3@codepoet.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include "libbb.h"
+
+#ifdef USE_TTY_GROUP
+#define S_IWGRP_OR_S_IWOTH	S_IWGRP
+#else
+#define S_IWGRP_OR_S_IWOTH	(S_IWGRP | S_IWOTH)
+#endif
+
+extern int mesg_main(int argc, char *argv[])
+{
+	struct stat sb;
+	char *tty;
+	char c;
+
+	if ((--argc == 0)
+		|| ((argc == 1) && (((c = **++argv) == 'y') || (c == 'n')))) {
+		if ((tty = ttyname(STDERR_FILENO)) == NULL) {
+			tty = "ttyname";
+		} else if (stat(tty, &sb) == 0) {
+			if (argc == 0) {
+				puts(((sb.st_mode & (S_IWGRP | S_IWOTH)) ==
+					  0) ? "is n" : "is y");
+				return EXIT_SUCCESS;
+			}
+			if (chmod
+				(tty,
+				 (c ==
+				  'y') ? sb.st_mode | (S_IWGRP_OR_S_IWOTH) : sb.
+				 st_mode & ~(S_IWGRP | S_IWOTH)) == 0) {
+				return EXIT_SUCCESS;
+			}
+		}
+		bb_perror_msg_and_die("%s", tty);
+	}
+	bb_show_usage();
+}
diff --git a/release/src/router/busybox/init/minit.c b/release/src/router/busybox/init/minit.c
new file mode 100644
index 00000000..6645dc6c
--- /dev/null
+++ b/release/src/router/busybox/init/minit.c
@@ -0,0 +1,612 @@
+/*
+ *  minit version 0.9.1 by Felix von Leitner
+ *  ported to busybox by Glenn McGrath <bug1@optushome.com.au>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <time.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <limits.h>
+#include <errno.h>
+#include <sys/fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/poll.h>
+#include <sys/reboot.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <sys/wait.h>
+#include <linux/kd.h>
+
+#include "busybox.h"
+
+#define MINITROOT "/etc/minit"
+
+static int i_am_init;
+static int infd, outfd;
+
+extern char **environ;
+
+static struct process {
+	char *name;
+	pid_t pid;
+	char respawn;
+	char circular;
+	time_t startedat;
+	int __stdin, __stdout;
+	int logservice;
+} *root;
+
+static int maxprocess = -1;
+
+static int processalloc = 0;
+
+static unsigned int fmt_ulong(char *dest, unsigned long i)
+{
+	register unsigned long len, tmp, len2;
+
+	/* first count the number of bytes needed */
+	for (len = 1, tmp = i; tmp > 9; ++len)
+		tmp /= 10;
+	if (dest)
+		for (tmp = i, dest += len, len2 = len + 1; --len2; tmp /= 10)
+			*--dest = (tmp % 10) + '0';
+	return len;
+}
+
+/* split buf into n strings that are separated by c.  return n as *len.
+ * Allocate plus more slots and leave the first ofs of them alone. */
+static char **split(char *buf, int c, int *len, int plus, int ofs)
+{
+	int n = 1;
+	char **v = 0;
+	char **w;
+
+	/* step 1: count tokens */
+	char *s;
+
+	for (s = buf; *s; s++)
+		if (*s == c)
+			n++;
+	/* step 2: allocate space for pointers */
+	v = (char **) malloc((n + plus) * sizeof(char *));
+	if (!v)
+		return 0;
+	w = v + ofs;
+	*w++ = buf;
+	for (s = buf;; s++) {
+		while (*s && *s != c)
+			s++;
+		if (*s == 0)
+			break;
+		if (*s == c) {
+			*s = 0;
+			*w++ = s + 1;
+		}
+	}
+	*len = w - v;
+	return v;
+}
+
+static int openreadclose(char *fn, char **buf, unsigned long *len)
+{
+	int fd = open(fn, O_RDONLY);
+
+	if (fd < 0)
+		return -1;
+	if (!*buf) {
+		*len = lseek(fd, 0, SEEK_END);
+		lseek(fd, 0, SEEK_SET);
+		*buf = (char *) malloc(*len + 1);
+		if (!*buf) {
+			close(fd);
+			return -1;
+		}
+	}
+	*len = read(fd, *buf, *len);
+	if (*len != (unsigned long) -1)
+		(*buf)[*len] = 0;
+	return close(fd);
+}
+
+/* return index of service in process data structure or -1 if not found */
+static int findservice(char *service)
+{
+	int i;
+
+	for (i = 0; i <= maxprocess; i++) {
+		if (!strcmp(root[i].name, service))
+			return i;
+	}
+	return -1;
+}
+
+/* look up process index in data structure by PID */
+static int findbypid(pid_t pid)
+{
+	int i;
+
+	for (i = 0; i <= maxprocess; i++) {
+		if (root[i].pid == pid)
+			return i;
+	}
+	return -1;
+}
+
+/* clear circular dependency detection flags */
+static void circsweep(void)
+{
+	int i;
+
+	for (i = 0; i <= maxprocess; i++)
+		root[i].circular = 0;
+}
+
+/* add process to data structure, return index or -1 */
+static int addprocess(struct process *p)
+{
+	if (maxprocess + 1 >= processalloc) {
+		struct process *fump;
+
+		processalloc += 8;
+		if ((fump =
+			 (struct process *) xrealloc(root,
+										 processalloc *
+										 sizeof(struct process))) == 0)
+			return -1;
+		root = fump;
+	}
+	memmove(&root[++maxprocess], p, sizeof(struct process));
+	return maxprocess;
+}
+
+/* load a service into the process data structure and return index or -1
+ * if failed */
+static int loadservice(char *service)
+{
+	struct process tmp;
+	int fd;
+
+	if (*service == 0)
+		return -1;
+	fd = findservice(service);
+	if (fd >= 0)
+		return fd;
+	if (chdir(MINITROOT) || chdir(service))
+		return -1;
+	if (!(tmp.name = strdup(service)))
+		return -1;
+	tmp.pid = 0;
+	fd = open("respawn", O_RDONLY);
+	if (fd >= 0) {
+		tmp.respawn = 1;
+		close(fd);
+	} else
+		tmp.respawn = 0;
+	tmp.startedat = 0;
+	tmp.circular = 0;
+	tmp.__stdin = 0;
+	tmp.__stdout = 1;
+	{
+		char *logservice = alloca(strlen(service) + 5);
+
+		strcpy(logservice, service);
+		strcat(logservice, "/log");
+		tmp.logservice = loadservice(logservice);
+		if (tmp.logservice >= 0) {
+			int pipefd[2];
+
+			if (pipe(pipefd))
+				return -1;
+			root[tmp.logservice].__stdin = pipefd[0];
+			tmp.__stdout = pipefd[1];
+		}
+	}
+	return (addprocess(&tmp));
+}
+
+/* usage: isup(findservice("sshd")).
+ * returns nonzero if process is up */
+static int isup(int service)
+{
+	if (service < 0)
+		return 0;
+	return (root[service].pid != 0);
+}
+
+static void opendevconsole(void)
+{
+	int fd;
+
+	if ((fd = open("/dev/console", O_RDWR | O_NOCTTY)) >= 0) {
+		dup2(fd, 0);
+		dup2(fd, 1);
+		dup2(fd, 2);
+		if (fd > 2)
+			close(fd);
+	}
+}
+
+/* called from inside the service directory, return the PID or 0 on error */
+static pid_t forkandexec(int pause_flag, int service)
+{
+	char **argv = 0;
+	int count = 0;
+	pid_t p;
+	int fd;
+	unsigned long len;
+	char *s = 0;
+	int argc;
+	char *argv0 = 0;
+
+  again:
+	switch (p = fork()) {
+	case (pid_t) - 1:
+		if (count > 3)
+			return 0;
+		sleep(++count * 2);
+		goto again;
+	case 0:
+		/* child */
+
+		if (i_am_init) {
+			ioctl(0, TIOCNOTTY, 0);
+			setsid();
+			opendevconsole();
+			tcsetpgrp(0, getpgrp());
+		}
+		close(infd);
+		close(outfd);
+		if (pause_flag) {
+			struct timespec req;
+
+			req.tv_sec = 0;
+			req.tv_nsec = 500000000;
+			nanosleep(&req, 0);
+		}
+		if (!openreadclose("params", &s, &len)) {
+			argv = split(s, '\n', &argc, 2, 1);
+			if (argv[argc - 1])
+				argv[argc - 1] = 0;
+			else
+				argv[argc] = 0;
+		} else {
+			argv = (char **) xmalloc(2 * sizeof(char *));
+			argv[1] = 0;
+		}
+		argv0 = (char *) xmalloc(PATH_MAX + 1);
+		if (!argv || !argv0)
+			goto abort;
+		if (readlink("run", argv0, PATH_MAX) < 0) {
+			if (errno != EINVAL)
+				goto abort;	/* not a symbolic link */
+			argv0 = strdup("./run");
+		}
+		argv[0] = strrchr(argv0, '/');
+		if (argv[0])
+			argv[0]++;
+		else
+			argv[0] = argv0;
+		if (root[service].__stdin != 0)
+			dup2(root[service].__stdin, 0);
+		if (root[service].__stdout != 1) {
+			dup2(root[service].__stdout, 1);
+			dup2(root[service].__stdout, 2);
+		}
+		{
+			int i;
+
+			for (i = 3; i < 1024; ++i)
+				close(i);
+		}
+		execve(argv0, argv, environ);
+		_exit(0);
+	  abort:
+		free(argv0);
+		free(argv);
+		_exit(0);
+	default:
+		fd = open("sync", O_RDONLY);
+		if (fd >= 0) {
+			pid_t p2;
+
+			close(fd);
+			p2 = waitpid(p, 0, 0);
+			return 1;
+		}
+		return p;
+	}
+}
+
+/* start a service, return nonzero on error */
+static int startnodep(int service, int pause_flag)
+{
+	/* step 1: see if the process is already up */
+	if (isup(service))
+		return 0;
+
+	/* step 2: fork and exec service, put PID in data structure */
+	if (chdir(MINITROOT) || chdir(root[service].name))
+		return -1;
+	root[service].startedat = time(0);
+	root[service].pid = forkandexec(pause_flag, service);
+	return root[service].pid;
+}
+
+static int startservice(int service, int pause_flag)
+{
+	int dir = -1;
+	unsigned long len;
+	char *s = 0;
+	pid_t pid;
+
+	if (service < 0)
+		return 0;
+	if (root[service].circular)
+		return 0;
+	root[service].circular = 1;
+	if (root[service].logservice >= 0)
+		startservice(root[service].logservice, pause_flag);
+	if (chdir(MINITROOT) || chdir(root[service].name))
+		return -1;
+	if ((dir = open(".", O_RDONLY)) >= 0) {
+		if (!openreadclose("depends", &s, &len)) {
+			char **deps;
+			int depc, i;
+
+			deps = split(s, '\n', &depc, 0, 0);
+			for (i = 0; i < depc; i++) {
+				int service_index;
+
+				if (deps[i][0] == '#')
+					continue;
+				service_index = loadservice(deps[i]);
+				if (service_index >= 0 && root[service_index].pid != 1)
+					startservice(service_index, 0);
+			}
+			fchdir(dir);
+		}
+		pid = startnodep(service, pause_flag);
+		close(dir);
+		dir = -1;
+		return pid;
+	}
+	return 0;
+}
+
+static void sulogin(void)
+{
+	/* exiting on an initialization failure is not a good idea for init */
+	char *argv[] = { "sulogin", 0 };
+	execve("/sbin/sulogin", argv, environ);
+	exit(1);
+}
+
+static void handlekilled(pid_t killed)
+{
+	int i;
+
+	if (killed == (pid_t) - 1) {
+		write(2, "all services exited.\n", 21);
+		exit(0);
+	}
+	if (killed == 0)
+		return;
+	i = findbypid(killed);
+	if (i >= 0) {
+		root[i].pid = 0;
+		if (root[i].respawn) {
+			circsweep();
+			startservice(i, time(0) - root[i].startedat < 1);
+		} else {
+			root[i].startedat = time(0);
+			root[i].pid = 1;
+		}
+	}
+}
+
+static void childhandler(void)
+{
+	int status;
+	pid_t killed;
+
+	do {
+		killed = waitpid(-1, &status, WNOHANG);
+		handlekilled(killed);
+	} while (killed && killed != (pid_t) - 1);
+}
+
+static volatile int dowinch = 0;
+static volatile int doint = 0;
+
+static void sigchild(int whatever)
+{
+}
+static void sigwinch(int sig)
+{
+	dowinch = 1;
+}
+static void sigint(int sig)
+{
+	doint = 1;
+}
+
+extern int minit_main(int argc, char *argv[])
+{
+	/* Schritt 1: argv[1] als Service nehmen und starten */
+	struct pollfd pfd;
+	time_t last = time(0);
+	int nfds = 1;
+	int count = 0;
+	int i;
+
+	infd = open("/etc/minit/in", O_RDWR);
+	outfd = open("/etc/minit/out", O_RDWR | O_NONBLOCK);
+	if (getpid() == 1) {
+		int fd;
+
+		i_am_init = 1;
+		reboot(0);
+		if ((fd = open("/dev/console", O_RDWR | O_NOCTTY))) {
+			ioctl(fd, KDSIGACCEPT, SIGWINCH);
+			close(fd);
+		} else
+			ioctl(0, KDSIGACCEPT, SIGWINCH);
+	}
+/*  signal(SIGPWR,sighandler); don't know what to do about it */
+/*  signal(SIGHUP,sighandler); ??? */
+	{
+		struct sigaction sa;
+
+		sigemptyset(&sa.sa_mask);
+		sa.sa_sigaction = 0;
+		sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
+		sa.sa_handler = sigchild;
+		sigaction(SIGCHLD, &sa, 0);
+		sa.sa_handler = sigint;
+		sigaction(SIGINT, &sa, 0);	/* ctrl-alt-del */
+		sa.sa_handler = sigwinch;
+		sigaction(SIGWINCH, &sa, 0);	/* keyboard request */
+	}
+	if (infd < 0 || outfd < 0) {
+		puts("minit: could not open /etc/minit/in or /etc/minit/out\n");
+		sulogin();
+		nfds = 0;
+	} else
+		pfd.fd = infd;
+	pfd.events = POLLIN;
+
+	for (i = 1; i < argc; i++) {
+		circsweep();
+		if (startservice(loadservice(argv[i]), 0))
+			count++;
+	}
+	circsweep();
+	if (!count)
+		startservice(loadservice("default"), 0);
+	for (;;) {
+		char buf[1501];
+		time_t now;
+
+		if (doint) {
+			doint = 0;
+			startservice(loadservice("ctrlaltdel"), 0);
+		}
+		if (dowinch) {
+			dowinch = 0;
+			startservice(loadservice("kbreq"), 0);
+		}
+		childhandler();
+		now = time(0);
+		if (now < last || now - last > 30) {
+			/* The system clock was reset.  Compensate. */
+			long diff = last - now;
+			int j;
+
+			for (j = 0; j <= maxprocess; ++j) {
+				root[j].startedat -= diff;
+			}
+		}
+		last = now;
+		switch (poll(&pfd, nfds, 5000)) {
+		case -1:
+			if (errno == EINTR) {
+				childhandler();
+				break;
+			}
+			opendevconsole();
+			puts("poll failed!\n");
+			sulogin();
+			/* what should we do if poll fails?! */
+			break;
+		case 1:
+			i = read(infd, buf, 1500);
+			if (i > 1) {
+				pid_t pid;
+				int idx = 0;
+				int tmp;
+
+				buf[i] = 0;
+
+				if (buf[0] != 's' && ((idx = findservice(buf + 1)) < 0))
+				  error:
+					write(outfd, "0", 1);
+				else {
+					switch (buf[0]) {
+					case 'p':
+						write(outfd, buf, fmt_ulong(buf, root[idx].pid));
+						break;
+					case 'r':
+						root[idx].respawn = 0;
+						goto ok;
+					case 'R':
+						root[idx].respawn = 1;
+						goto ok;
+					case 'C':
+						if (kill(root[idx].pid, 0)) {	/* check if still active */
+							handlekilled(root[idx].pid);	/* no!?! remove form active list */
+							goto error;
+						}
+						goto ok;
+						break;
+					case 'P':
+					{
+						unsigned char *x = buf + strlen(buf) + 1;
+						unsigned char c;
+
+						tmp = 0;
+						while ((c = *x++ - '0') < 10)
+							tmp = tmp * 10 + c;
+					}
+						if (tmp > 0) {
+							if (kill(tmp, 0))
+								goto error;
+							pid = tmp;
+						}
+						root[idx].pid = tmp;
+						goto ok;
+					case 's':
+						idx = loadservice(buf + 1);
+						if (idx < 0)
+							goto error;
+						if (root[idx].pid < 2) {
+							root[idx].pid = 0;
+							circsweep();
+							idx = startservice(idx, 0);
+							if (idx == 0) {
+								write(outfd, "0", 1);
+								break;
+							}
+						}
+					  ok:
+						write(outfd, "1", 1);
+						break;
+					case 'u':
+						write(outfd, buf,
+							  fmt_ulong(buf, time(0) - root[idx].startedat));
+					}
+				}
+			}
+			break;
+		default:
+			break;
+		}
+	}
+}
diff --git a/release/src/router/busybox/init/msvc.c b/release/src/router/busybox/init/msvc.c
new file mode 100644
index 00000000..d72ddce1
--- /dev/null
+++ b/release/src/router/busybox/init/msvc.c
@@ -0,0 +1,300 @@
+/*
+ *  minit version 0.9.1 by Felix von Leitner
+ *  ported to busybox by Glenn McGrath <bug1@optushome.com.au>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <sys/fcntl.h>
+#include <sys/file.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "busybox.h"
+
+static int infd, outfd;
+
+static char buf[1500];
+
+static unsigned int fmt_ulong(char *dest, unsigned long i)
+{
+	register unsigned long len, tmp, len2;
+
+	/* first count the number of bytes needed */
+	for (len = 1, tmp = i; tmp > 9; ++len)
+		tmp /= 10;
+	if (dest)
+		for (tmp = i, dest += len, len2 = len + 1; --len2; tmp /= 10)
+			*--dest = (tmp % 10) + '0';
+	return len;
+}
+
+static void addservice(char *service)
+{
+	char *service_ptr;
+
+	if (strncmp(service, "/etc/minit/", 11) == 0) {
+		service += 11;
+	}
+
+	while ((service_ptr = last_char_is(service, '/')) != NULL) {
+		*service_ptr = 0;
+	}
+	strncpy(buf + 1, service, 1400);
+	buf[1400] = 0;
+}
+
+static int addreadwrite(char *service)
+{
+	addservice(service);
+	write(infd, buf, strlen(buf));
+	return read(outfd, buf, 1500);
+}
+
+/* return PID, 0 if error */
+static pid_t __readpid(char *service)
+{
+	int len;
+
+	buf[0] = 'p';
+	len = addreadwrite(service);
+	if (len < 0)
+		return 0;
+	buf[len] = 0;
+	return atoi(buf);
+}
+
+/* return nonzero if error */
+static int respawn(char *service, int yesno)
+{
+	int len;
+
+	buf[0] = yesno ? 'R' : 'r';
+	len = addreadwrite(service);
+	return (len != 1 || buf[0] == '0');
+}
+
+/* return nonzero if error */
+static int startservice(char *service)
+{
+	int len;
+
+	buf[0] = 's';
+	len = addreadwrite(service);
+	return (len != 1 || buf[0] == '0');
+}
+
+extern int msvc_main(int argc, char **argv)
+{
+	if (argc < 2) {
+		bb_show_usage();
+	}
+	infd = bb_xopen("/etc/minit/in", O_WRONLY);
+	outfd = bb_xopen("/etc/minit/out", O_RDONLY);
+
+	while (lockf(infd, F_LOCK, 1)) {
+		bb_perror_msg("could not aquire lock!\n");
+		sleep(1);
+	}
+
+	if (argc == 2) {
+		pid_t pid = __readpid(argv[1]);
+
+		if (buf[0] != '0') {
+			int len;
+			int up_time;
+
+			printf("%s: ", argv[1]);
+			if (pid == 0)
+				printf("down ");
+			else if (pid == 1)
+				printf("finished ");
+			else {
+				printf("up (pid %d) ", pid);
+			}
+
+			buf[0] = 'u';
+			len = addreadwrite(argv[1]);
+			if (len < 0) {
+				up_time = 0;
+			} else {
+				buf[len] = 0;
+				up_time = atoi(buf);
+			}
+			printf("%d seconds\n", up_time);
+
+			if (pid == 0)
+				return 2;
+			else if (pid == 1)
+				return 3;
+			else
+				return 0;
+		} else {
+			bb_error_msg_and_die("no such service");
+		}
+	} else {
+		int i;
+		int ret = 0;
+		int sig = 0;
+		pid_t pid;
+
+		if (argv[1][0] == '-') {
+			switch (argv[1][1]) {
+			case 'g':
+				for (i = 2; i < argc; ++i) {
+					pid = __readpid(argv[i]);
+					if (pid < 2) {
+						if (pid == 1) {
+							bb_error_msg("%s, service termination", argv[i]);
+						} else {
+							bb_error_msg("%s, no such service", argv[i]);
+						}
+						ret = 1;
+					}
+					printf("%d\n", pid);
+				}
+				break;
+			case 'p':
+				sig = SIGSTOP;
+				goto dokill;
+				break;
+			case 'c':
+				sig = SIGCONT;
+				goto dokill;
+				break;
+			case 'h':
+				sig = SIGHUP;
+				goto dokill;
+				break;
+			case 'a':
+				sig = SIGALRM;
+				goto dokill;
+				break;
+			case 'i':
+				sig = SIGINT;
+				goto dokill;
+				break;
+			case 't':
+				sig = SIGTERM;
+				goto dokill;
+				break;
+			case 'k':
+				sig = SIGKILL;
+				goto dokill;
+				break;
+			case 'o':
+				for (i = 2; i < argc; ++i)
+					if (startservice(argv[i]) || respawn(argv[i], 0)) {
+						bb_error_msg("Couldnt not start %s\n", argv[i]);
+						ret = 1;
+					}
+				break;
+			case 'd':
+				for (i = 2; i < argc; ++i) {
+					pid = __readpid(argv[i]);
+					if (pid == 0) {
+						bb_error_msg("%s, no such service\n", argv[i]);
+						ret = 1;
+					} else if (pid == 1)
+						continue;
+					if (respawn(argv[i], 0) || kill(pid, SIGTERM)
+						|| kill(pid, SIGCONT));
+				}
+				break;
+			case 'u':
+				for (i = 2; i < argc; ++i) {
+					if (startservice(argv[i]) || respawn(argv[i], 1)) {
+						bb_error_msg("Couldnt not start %s\n", argv[i]);
+						ret = 1;
+					}
+					break;
+				}
+			case 'C':
+				for (i = 2; i < argc; ++i) {
+					int len;
+
+					buf[0] = 'C';
+					len = addreadwrite(argv[i]);
+					if (len != 1 || buf[0] == '0') {
+						bb_error_msg("%s has terminated or was killed\n",
+									 argv[i]);
+						ret = 1;
+					}
+				}
+				break;
+			case 'P':
+				pid = atoi(argv[1] + 2);
+				if (pid > 1) {
+					char *tmp;
+					int len;
+
+					buf[0] = 'P';
+					addservice(argv[2]);
+					tmp = buf + strlen(buf) + 1;
+					tmp[fmt_ulong(tmp, pid)] = 0;
+					write(infd, buf, strlen(buf) + strlen(tmp) + 2);
+					len = read(outfd, buf, 1500);
+					if (len != 1 || buf[0] == '0') {
+						bb_error_msg_and_die("Couldnt not set pid of service %s\n", argv[2]);
+					}
+				}
+				break;
+			default:
+				bb_show_usage();
+			}
+		} else {
+			bb_show_usage();
+		}
+		return ret;
+dokill:
+		for (i = 2; i < argc; i++) {
+			pid = __readpid(argv[i]);
+			if (!pid) {
+				bb_error_msg("%s no such service\n", argv[i]);
+				ret = 1;
+			}
+			if (kill(pid, sig)) {
+				bb_error_msg("%s, could not send signal %d to PID %d\n",
+							 argv[i], sig, pid);
+				ret = 1;
+			}
+		}
+		return ret;
+	}
+}
+
+/*
+  -u   Up.  If the service is not running, start it.  If the service stops,
+       restart it.
+  -d   Down.  If the service is running, send it a TERM signal and then a CONT
+       signal.  After it stops, do not restart it.
+  -o   Once.  If the service is not running, start it.  Do not restart it if it
+       stops.
+  -r   Tell supervise that the service is normally running; this affects status
+       messages.
+  -s   Tell supervise that the service is normally stopped; this affects status
+       messages.
+  -p   Pause.  Send the service a STOP signal.
+  -c   Continue.  Send the service a CONT signal.
+  -h   Hangup.  Send the service a HUP signal.
+  -a   Alarm.  Send the service an ALRM signal.
+  -i   Interrupt.  Send the service an INT signal.
+  -t   Terminate.  Send the service a TERM signal.
+  -k   Kill.  Send the service a KILL signal.
+  -x   Exit.  supervise will quit as soon as the service is down.
+*/
diff --git a/release/src/router/busybox/init/pidfilehack.c b/release/src/router/busybox/init/pidfilehack.c
new file mode 100644
index 00000000..a2d905b5
--- /dev/null
+++ b/release/src/router/busybox/init/pidfilehack.c
@@ -0,0 +1,78 @@
+/*
+ *  minit version 0.9.1 by Felix von Leitner
+ *  ported to busybox by Glenn McGrath <bug1@optushome.com.au>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <unistd.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/fcntl.h>
+
+#include "busybox.h"
+/* purpose: argv[1] is the full path to a PID file,
+ *          argv+2 is the daemon to run.
+ * the daemon is expected to fork in the background and write its PID in
+ * the pid file.
+ */
+
+extern int pidfilehack_main(int argc, char **argv)
+{
+	int count = 0;
+
+	if (argc < 3) {
+		bb_show_usage();
+
+	}
+	if (unlink(argv[2]) && (errno != ENOENT)) {
+		bb_perror_msg("could not remove pid file");
+	}
+	switch (fork()) {
+	case -1:
+		bb_perror_msg("could not fork");
+		return 2;
+	case 0:	/* child */
+		execv(argv[3], argv + 3);
+		bb_perror_msg("execvp failed");
+		return 3;
+	}
+	do {
+		int fd = open(argv[2], O_RDONLY);
+
+		if (fd >= 0) {
+			static char buf[100] = "-P";
+			int len = read(fd, buf + 2, 100);
+
+			close(fd);
+			if (len > 0) {
+				char *_argv[] = { "msvc", 0, 0, 0 };
+				if (buf[len + 1] == '\n') {
+					buf[len + 1] = 0;
+				} else {
+					buf[len + 2] = 0;
+				}
+				_argv[1] = buf;
+				_argv[2] = argv[1];
+				execvp(_argv[0], _argv);
+				bb_perror_msg("execvp failed");
+				return 0;
+			}
+		}
+		sleep(1);
+	} while (++count < 30);
+
+	return(0);
+}
diff --git a/release/src/router/busybox/init/poweroff.c b/release/src/router/busybox/init/poweroff.c
new file mode 100644
index 00000000..e5d45dfa
--- /dev/null
+++ b/release/src/router/busybox/init/poweroff.c
@@ -0,0 +1,56 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini poweroff implementation for busybox
+ *
+ * Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <sys/reboot.h>
+#include "busybox.h"
+#include "init_shared.h"
+
+
+extern int poweroff_main(int argc, char **argv)
+{
+	char *delay; /* delay in seconds before rebooting */
+
+	if(bb_getopt_ulflags(argc, argv, "d:", &delay)) {
+		sleep(atoi(delay));
+	}
+
+#ifndef CONFIG_INIT
+#ifndef RB_POWER_OFF
+#define RB_POWER_OFF		0x4321fedc
+#endif
+	return(bb_shutdown_system(RB_POWER_OFF));
+#else
+	return kill_init(SIGUSR2);
+#endif
+}
+
+/*
+Local Variables:
+c-file-style: "linux"
+c-basic-offset: 4
+tab-width: 4
+End:
+*/
diff --git a/release/src/router/busybox/init/reboot.c b/release/src/router/busybox/init/reboot.c
new file mode 100644
index 00000000..185152a7
--- /dev/null
+++ b/release/src/router/busybox/init/reboot.c
@@ -0,0 +1,56 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini reboot implementation for busybox
+ *
+ * Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <sys/reboot.h>
+#include "busybox.h"
+#include "init_shared.h"
+
+
+extern int reboot_main(int argc, char **argv)
+{
+	char *delay; /* delay in seconds before rebooting */
+
+	if(bb_getopt_ulflags(argc, argv, "d:", &delay)) {
+		sleep(atoi(delay));
+	}
+
+#ifndef CONFIG_INIT
+#ifndef RB_AUTOBOOT
+#define RB_AUTOBOOT		0x01234567
+#endif
+	return(bb_shutdown_system(RB_AUTOBOOT));
+#else
+	return kill_init(SIGTERM);
+#endif
+}
+
+/*
+Local Variables:
+c-file-style: "linux"
+c-basic-offset: 4
+tab-width: 4
+End:
+*/