patch to Vanilla Tomato 1.28

1 files changed, 779 insertions, 965 deletions

diff --git a/release/src/router/busybox/init/init.c b/release/src/router/busybox/init/init.c
index 1ecc43e1..ce264283 100644
--- a/release/src/router/busybox/init/init.c
+++ b/release/src/router/busybox/init/init.c
@@ -3,279 +3,210 @@
  * 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>
+ * Copyright (C) 1999-2004 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
- *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
  */
 
-/* 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 "libbb.h"
+#include <syslog.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
+#include <sys/resource.h>
+#include <linux/vt.h>
 
 
-#if defined(__UCLIBC__) && !defined(__UCLIBC_HAS_MMU__)
-#define fork	vfork
-#endif
+/* Was a CONFIG_xxx option. A lot of people were building
+ * not fully functional init by switching it on! */
+#define DEBUG_INIT 0
 
-#define INIT_BUFFS_SIZE 256
+#define COMMAND_SIZE      256
+#define CONSOLE_NAME_SIZE 32
 
-/* 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"
+/* Default sysinit script. */
+#ifndef INIT_SCRIPT
+#define INIT_SCRIPT  "/etc/init.d/rcS"
 #endif
 
-#if defined CONFIG_FEATURE_INIT_COREDUMPS
+/* Each type of actions can appear many times. They will be
+ * handled in order. RESTART is an exception, only 1st is used.
+ */
+/* Start these actions first and wait for completion */
+#define SYSINIT     0x01
+/* Start these after SYSINIT and wait for completion */
+#define WAIT        0x02
+/* Start these after WAIT and *dont* wait for completion */
+#define ONCE        0x04
 /*
- * 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....
+ * NB: while SYSINIT/WAIT/ONCE are being processed,
+ * SIGHUP ("reread /etc/inittab") will be ignored.
+ * Rationale: it would be ambiguous whether SYSINIT/WAIT/ONCE
+ * need to be rerun or not.
  */
-#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;
-};
+/* Start these after ONCE are started, restart on exit */
+#define RESPAWN     0x08
+/* Like RESPAWN, but wait for <Enter> to be pressed on tty */
+#define ASKFIRST    0x10
+/*
+ * Start these on SIGINT, and wait for completion.
+ * Then go back to respawning RESPAWN and ASKFIRST actions.
+ * NB: kernel sends SIGINT to us if Ctrl-Alt-Del was pressed.
+ */
+#define CTRLALTDEL  0x20
+/*
+ * Start these before killing all processes in preparation for
+ * running RESTART actions or doing low-level halt/reboot/poweroff
+ * (initiated by SIGUSR1/SIGTERM/SIGUSR2).
+ * Wait for completion before proceeding.
+ */
+#define SHUTDOWN    0x40
+/*
+ * exec() on SIGQUIT. SHUTDOWN actions are started and waited for,
+ * then all processes are killed, then init exec's 1st RESTART action,
+ * replacing itself by it. If no RESTART action specified,
+ * SIGQUIT has no effect.
+ */
+#define RESTART     0x80
 
-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 */
+/* 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;
+	pid_t pid;
+	uint8_t action_type;
+	char terminal[CONSOLE_NAME_SIZE];
+	char command[COMMAND_SIZE];
 };
 
-/* 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;
+static const char *log_console = VC_5;
 
-#if defined CONFIG_FEATURE_EXTRA_QUIET
-static const int MAYBE_CONSOLE = 0x0;
-#else
-#define MAYBE_CONSOLE	CONSOLE
-#endif
+enum {
+	L_LOG = 0x1,
+	L_CONSOLE = 0x2,
+	MAYBE_CONSOLE = L_CONSOLE * !ENABLE_FEATURE_EXTRA_QUIET,
 #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;
+	RB_HALT_SYSTEM = 0xcdef0123, /* FIXME: this overflows enum */
+	RB_ENABLE_CAD = 0x89abcdef,
+	RB_DISABLE_CAD = 0,
+	RB_POWER_OFF = 0x4321fedc,
+	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, ...)
+ * "where" may be bitwise-or'd from L_LOG | L_CONSOLE
+ * NB: careful, we can be called after vfork!
+ */
+#define dbg_message(...) do { if (DEBUG_INIT) message(__VA_ARGS__); } while (0)
+static void message(int where, const char *fmt, ...)
 	__attribute__ ((format(printf, 2, 3)));
-static void message(int device, const char *fmt, ...)
+static void message(int where, const char *fmt, ...)
 {
 	va_list arguments;
-	int l;
-	char msg[1024];
-#ifndef CONFIG_SYSLOGD
-	static int log_fd = -1;
-#endif
+	unsigned l;
+	char msg[128];
 
 	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);
+	va_start(arguments, fmt);
+	l = 1 + vsnprintf(msg + 1, sizeof(msg) - 2, fmt, arguments);
+	if (l > sizeof(msg) - 1)
+		l = sizeof(msg) - 1;
+	va_end(arguments);
+
+#if ENABLE_FEATURE_INIT_SYSLOG
+	msg[l] = '\0';
+	if (where & L_LOG) {
+		/* Log the message to syslogd */
+		openlog("init", 0, LOG_DAEMON);
+		/* don't print "\r" */
+		syslog(LOG_INFO, "%s", msg + 1);
+		closelog();
 	}
-
 	msg[l++] = '\n';
-	msg[l] = 0;
+	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);
+	{
+		static int log_fd = -1;
+
+		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_console) {
+				log_fd = STDERR_FILENO;
+			} else {
+				log_fd = device_open(log_console, O_WRONLY | O_NONBLOCK | O_NOCTTY);
+				if (log_fd < 0) {
+					bb_error_msg("can't log to %s", log_console);
+					where = L_CONSOLE;
+				} else {
+					close_on_exec_on(log_fd);
+				}
+			}
+		}
+		if (where & L_LOG) {
+			full_write(log_fd, msg, l);
+			if (log_fd == STDERR_FILENO)
+				return; /* don't print dup messages */
 		}
-	}
-	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 (where & L_CONSOLE) {
+		/* Send console messages to console so people will see them. */
+		full_write(STDERR_FILENO, msg, l);
+	}
+}
+
+static void console_init(void)
+{
+	int vtno;
+	char *s;
+
+	s = getenv("CONSOLE");
+	if (!s)
+		s = getenv("console");
+	if (s) {
+		int fd = open(s, O_RDWR | O_NONBLOCK | O_NOCTTY);
 		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
+			dup2(fd, STDIN_FILENO);
+			dup2(fd, STDOUT_FILENO);
+			xmove_fd(fd, STDERR_FILENO);
 		}
+		dbg_message(L_LOG, "console='%s'", s);
+	} else {
+		/* Make sure fd 0,1,2 are not closed
+		 * (so that they won't be used by future opens) */
+		bb_sanitize_stdio();
+// Users report problems
+//		/* Make sure init can't be blocked by writing to stderr */
+//		fcntl(STDERR_FILENO, F_SETFL, fcntl(STDERR_FILENO, F_GETFL) | O_NONBLOCK);
 	}
+
+	s = getenv("TERM");
+	if (ioctl(STDIN_FILENO, VT_OPENQRY, &vtno) != 0) {
+		/* Not a linux terminal, probably serial console.
+		 * Force the TERM setting to vt102
+		 * if TERM is set to linux (the default) */
+		if (!s || strcmp(s, "linux") == 0)
+			putenv((char*)"TERM=vt102");
+		if (!ENABLE_FEATURE_INIT_SYSLOG)
+			log_console = NULL;
+	} else if (!s)
+		putenv((char*)"TERM=linux");
 }
 
-/* Set terminal settings to reasonable defaults */
-static void set_term(int fd)
+/* Set terminal settings to reasonable defaults.
+ * NB: careful, we can be called after vfork! */
+static void set_sane_term(void)
 {
 	struct termios tty;
 
-	tcgetattr(fd, &tty);
+	tcgetattr(STDIN_FILENO, &tty);
 
 	/* set control chars */
 	tty.c_cc[VINTR] = 3;	/* C-c */
@@ -287,14 +218,13 @@ static void set_term(int fd)
 	tty.c_cc[VSTOP] = 19;	/* C-s */
 	tty.c_cc[VSUSP] = 26;	/* C-z */
 
-	/* use line dicipline 0 */
+	/* use line discipline 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;
 
@@ -305,886 +235,770 @@ static void set_term(int fd)
 	tty.c_lflag =
 		ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN;
 
-	tcsetattr(fd, TCSANOW, &tty);
+	tcsetattr_stdin_TCSANOW(&tty);
 }
 
-/* How much memory does this machine have?
-   Units are kBytes to avoid overflow on 4GB machines */
-static int check_free_memory(void)
+/* Open the new terminal device.
+ * NB: careful, we can be called after vfork! */
+static int open_stdio_to_tty(const char* tty_name)
 {
-	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--;
+	/* empty tty_name means "use init's tty", else... */
+	if (tty_name[0]) {
+		int fd;
+
+		close(STDIN_FILENO);
+		/* fd can be only < 0 or 0: */
+		fd = device_open(tty_name, O_RDWR);
+		if (fd) {
+			message(L_LOG | L_CONSOLE, "can't open %s: %s",
+				tty_name, strerror(errno));
+			return 0; /* failure */
+		}
+		dup2(STDIN_FILENO, STDOUT_FILENO);
+		dup2(STDIN_FILENO, STDERR_FILENO);
 	}
-	result = (info.totalram >> s) + (info.totalswap >> s);
-	result = result * u;
-	if (result < 0)
-		result = INT_MAX;
-	return result;
+	set_sane_term();
+	return 1; /* success */
 }
 
-static void console_init(void)
+/* Wrapper around exec:
+ * Takes string (max COMMAND_SIZE chars).
+ * If chars like '>' detected, execs '[-]/bin/sh -c "exec ......."'.
+ * Otherwise splits words on whitespace, deals with leading dash,
+ * and uses plain exec().
+ * NB: careful, we can be called after vfork!
+ */
+static void init_exec(const char *command)
 {
-	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
+	char *cmd[COMMAND_SIZE / 2];
+	char buf[COMMAND_SIZE + 6];  /* COMMAND_SIZE+strlen("exec ")+1 */
+	int dash = (command[0] == '-' /* maybe? && command[1] == '/' */);
+
+	/* See if any special /bin/sh requiring characters are present */
+	if (strpbrk(command, "~`!$^&*()=|\\{}[];\"'<>?") != NULL) {
+		strcpy(buf, "exec ");
+		strcpy(buf + 5, command + dash); /* excluding "-" */
+		/* NB: LIBBB_DEFAULT_LOGIN_SHELL define has leading dash */
+		cmd[0] = (char*)(LIBBB_DEFAULT_LOGIN_SHELL + !dash);
+		cmd[1] = (char*)"-c";
+		cmd[2] = buf;
+		cmd[3] = NULL;
 	} 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++;
+		/* Convert command (char*) into cmd (char**, one word per string) */
+		char *word, *next;
+		int i = 0;
+		next = strcpy(buf, command); /* including "-" */
+		while ((word = strsep(&next, " \t")) != NULL) {
+			if (*word != '\0') { /* not two spaces/tabs together? */
+				cmd[i] = word;
+				i++;
+			}
 		}
+		cmd[i] = NULL;
 	}
-
-	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);
+	/* If we saw leading "-", it is interactive shell.
+	 * Try harder to give it a controlling tty.
+	 * And skip "-" in actual exec call. */
+	if (dash) {
+		/* _Attempt_ to make stdin a controlling tty. */
+		if (ENABLE_FEATURE_INIT_SCTTY)
+			ioctl(STDIN_FILENO, TIOCSCTTY, 0 /*only try, don't steal*/);
 	}
-	messageD(LOG, "console=%s", console);
+	BB_EXECVP(cmd[0] + dash, cmd);
+	message(L_LOG | L_CONSOLE, "cannot run '%s': %s", cmd[0], strerror(errno));
+	/* returns if execvp fails */
 }
 
-static void fixup_argv(int argc, char **argv, char *new_argv0)
+/* Used only by run_actions */
+static pid_t run(const struct init_action *a)
 {
-	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);
+	pid_t pid;
 
-	/* 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++;
+	/* Careful: don't be affected by a signal in vforked child */
+	sigprocmask_allsigs(SIG_BLOCK);
+	if (BB_MMU && (a->action_type & ASKFIRST))
+		pid = fork();
+	else
+		pid = vfork();
+	if (pid < 0)
+		message(L_LOG | L_CONSOLE, "can't fork");
+	if (pid) {
+		sigprocmask_allsigs(SIG_UNBLOCK);
+		return pid; /* Parent or error */
 	}
-}
 
-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[] =
+	/* Child */
+
+	/* Reset signal handlers that were set by the parent process */
+	bb_signals(0
+		+ (1 << SIGUSR1)
+		+ (1 << SIGUSR2)
+		+ (1 << SIGTERM)
+		+ (1 << SIGQUIT)
+		+ (1 << SIGINT)
+		+ (1 << SIGHUP)
+		+ (1 << SIGTSTP)
+		, SIG_DFL);
+	sigprocmask_allsigs(SIG_UNBLOCK);
+
+	/* Create a new session and make ourself the process group leader */
+	setsid();
+
+	/* Open the new terminal device */
+	if (!open_stdio_to_tty(a->terminal))
+		_exit(EXIT_FAILURE);
+
+	/* NB: on NOMMU we can't wait for input in child, so
+	 * "askfirst" will work the same as "respawn". */
+	if (BB_MMU && (a->action_type & ASKFIRST)) {
+		static const char press_enter[] ALIGN1 =
 #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);
+			"\nPlease press Enter to activate this console. ";
+		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.
+		 */
+		dbg_message(L_LOG, "waiting for enter to start '%s'"
+					"(pid %d, tty '%s')\n",
+				a->command, getpid(), a->terminal);
+		full_write(STDOUT_FILENO, press_enter, sizeof(press_enter) - 1);
+		while (safe_read(STDIN_FILENO, &c, 1) == 1 && c != '\n')
+			continue;
+	}
 
-				/* Wait for child to exit */
-				while ((tmp_pid = waitpid(pid, &junk, 0)) != pid);
+	/*
+	 * When a file named /.init_enable_core 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....
+	 */
+	if (ENABLE_FEATURE_INIT_COREDUMPS) {
+		if (access("/.init_enable_core", F_OK) == 0) {
+			struct rlimit limit;
+			limit.rlim_cur = RLIM_INFINITY;
+			limit.rlim_max = RLIM_INFINITY;
+			setrlimit(RLIMIT_CORE, &limit);
+		}
+	}
 
-				/* See if stealing the controlling tty back is necessary */
-				pgrp = tcgetpgrp(0);
-				if (pgrp != getpid())
-					_exit(0);
+	/* Log the process name and args */
+	message(L_LOG, "starting pid %d, tty '%s': '%s'",
+			  getpid(), a->terminal, a->command);
 
-				/* 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 run it.  The new program will take over this PID,
+	 * so nothing further in init.c should be run. */
+	init_exec(a->command);
+	/* We're still here?  Some error happened. */
+	_exit(-1);
+}
 
-			/* Now fall though to actually execute things */
-		}
+static struct init_action *mark_terminated(pid_t pid)
+{
+	struct init_action *a;
 
-		/* 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++;
-				}
+	if (pid > 0) {
+		for (a = init_action_list; a; a = a->next) {
+			if (a->pid == pid) {
+				a->pid = 0;
+				return a;
 			}
-			cmd[i] = NULL;
 		}
+	}
+	return 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").
-		 */
+static void waitfor(pid_t pid)
+{
+	/* waitfor(run(x)): protect against failed fork inside run() */
+	if (pid <= 0)
+		return;
 
-		if (*cmdpath == '-') {
+	/* Wait for any child (prevent zombies from exiting orphaned processes)
+	 * but exit the loop only when specified one has exited. */
+	while (1) {
+		pid_t wpid = wait(NULL);
+		mark_terminated(wpid);
+		/* Unsafe. SIGTSTP handler might have wait'ed it already */
+		/*if (wpid == pid) break;*/
+		/* More reliable: */
+		if (kill(pid, 0))
+			break;
+	}
+}
 
-			/* skip over the dash */
-			++cmdpath;
+/* Run all commands of a particular type */
+static void run_actions(int action_type)
+{
+	struct init_action *a;
 
-			/* find the last component in the command pathname */
-			s = bb_get_last_path_component(cmdpath);
+	for (a = init_action_list; a; a = a->next) {
+		if (!(a->action_type & action_type))
+			continue;
 
-			/* 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_type & (SYSINIT | WAIT | ONCE | CTRLALTDEL | SHUTDOWN)) {
+			pid_t pid = run(a);
+			if (a->action_type & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN))
+				waitfor(pid);
 		}
-
-		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.
+		if (a->action_type & (RESPAWN | ASKFIRST)) {
+			/* Only run stuff with pid == 0. If pid != 0,
+			 * it is already running
 			 */
-			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);
+			if (a->pid == 0)
+				a->pid = run(a);
 		}
-#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)
+static void new_init_action(uint8_t action_type, const char *command, const char *cons)
 {
-	int pid;
-	int status, wpid;
-
-	pid = run(a);
-	while (1) {
-		wpid = wait(&status);
-		if (wpid > 0 && wpid != pid) {
-			continue;
-		}
-		if (wpid == pid)
+	struct init_action *a, **nextp;
+
+	/* Scenario:
+	 * old inittab:
+	 * ::shutdown:umount -a -r
+	 * ::shutdown:swapoff -a
+	 * new inittab:
+	 * ::shutdown:swapoff -a
+	 * ::shutdown:umount -a -r
+	 * On reload, we must ensure entries end up in correct order.
+	 * To achieve that, if we find a matching entry, we move it
+	 * to the end.
+	 */
+	nextp = &init_action_list;
+	while ((a = *nextp) != NULL) {
+		/* Don't enter action if it's already in the list,
+		 * This prevents losing running RESPAWNs.
+		 */
+		if ((strcmp(a->command, command) == 0)
+		 && (strcmp(a->terminal, cons) == 0)
+		) {
+			/* Remove from list */
+			*nextp = a->next;
+			/* Find the end of the list */
+			while (*nextp != NULL)
+				nextp = &(*nextp)->next;
+			a->next = NULL;
 			break;
+		}
+		nextp = &a->next;
 	}
-	return wpid;
+
+	if (!a)
+		a = xzalloc(sizeof(*a));
+	/* Append to the end of the list */
+	*nextp = a;
+	a->action_type = action_type;
+	safe_strncpy(a->command, command, sizeof(a->command));
+	safe_strncpy(a->terminal, cons, sizeof(a->terminal));
+	dbg_message(L_LOG | L_CONSOLE, "command='%s' action=%d tty='%s'\n",
+		a->command, a->action_type, a->terminal);
 }
 
-/* Run all commands of a particular type */
-static void run_actions(int action)
+/* 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)
 {
-	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);
-				}
-			}
+#if ENABLE_FEATURE_USE_INITTAB
+	char *token[4];
+	parser_t *parser = config_open2("/etc/inittab", fopen_for_read);
+
+	if (parser == NULL)
+#endif
+	{
+		/* No inittab file - set up some default behavior */
+		/* Reboot on Ctrl-Alt-Del */
+		new_init_action(CTRLALTDEL, "reboot", "");
+		/* Umount all filesystems on halt/reboot */
+		new_init_action(SHUTDOWN, "umount -a -r", "");
+		/* Swapoff on halt/reboot */
+		if (ENABLE_SWAPONOFF)
+			new_init_action(SHUTDOWN, "swapoff -a", "");
+		/* Prepare to restart init when a QUIT is received */
+		new_init_action(RESTART, "init", "");
+		/* Askfirst shell on tty1-4 */
+		new_init_action(ASKFIRST, bb_default_login_shell, "");
+//TODO: VC_1 instead of ""? "" is console -> ctty problems -> angry users
+		new_init_action(ASKFIRST, bb_default_login_shell, VC_2);
+		new_init_action(ASKFIRST, bb_default_login_shell, VC_3);
+		new_init_action(ASKFIRST, bb_default_login_shell, VC_4);
+		/* sysinit */
+		new_init_action(SYSINIT, INIT_SCRIPT, "");
+		return;
+	}
+
+#if ENABLE_FEATURE_USE_INITTAB
+	/* optional_tty:ignored_runlevel:action:command
+	 * Delims are not to be collapsed and need exactly 4 tokens
+	 */
+	while (config_read(parser, token, 4, 0, "#:",
+				PARSE_NORMAL & ~(PARSE_TRIM | PARSE_COLLAPSE))) {
+		/* order must correspond to SYSINIT..RESTART constants */
+		static const char actions[] ALIGN1 =
+			"sysinit\0""wait\0""once\0""respawn\0""askfirst\0"
+			"ctrlaltdel\0""shutdown\0""restart\0";
+		int action;
+		char *tty = token[0];
+
+		if (!token[3]) /* less than 4 tokens */
+			goto bad_entry;
+		action = index_in_strings(actions, token[2]);
+		if (action < 0 || !token[3][0]) /* token[3]: command */
+			goto bad_entry;
+		/* turn .*TTY -> /dev/TTY */
+		if (tty[0]) {
+			if (strncmp(tty, "/dev/", 5) == 0)
+				tty += 5;
+			tty = concat_path_file("/dev/", tty);
 		}
+		new_init_action(1 << action, token[3], tty);
+		if (tty[0])
+			free(tty);
+		continue;
+ bad_entry:
+		message(L_LOG | L_CONSOLE, "Bad inittab entry at line %d",
+				parser->lineno);
 	}
+	config_close(parser);
+#endif
 }
 
-#ifndef DEBUG_INIT
-static void init_reboot(unsigned long magic)
+static void pause_and_low_level_reboot(unsigned magic) NORETURN;
+static void pause_and_low_level_reboot(unsigned 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) {
+
+	/* Allow time for last message to reach serial console, etc */
+	sleep(1);
+
+	/* We have to fork here, since the kernel calls do_exit(EXIT_SUCCESS)
+	 * in linux/kernel/sys.c, which can cause the machine to panic when
+	 * the init process exits... */
+	pid = vfork();
+	if (pid == 0) { /* child */
 		reboot(magic);
-		_exit(0);
+		_exit(EXIT_SUCCESS);
 	}
-	waitpid (pid, NULL, 0);
+	while (1)
+		sleep(1);
 }
 
-static void shutdown_system(void)
+static void run_shutdown_and_kill_processes(void)
 {
-	sigset_t block_signals;
-
-	/* run everything to be run at "shutdown".  This is done _prior_
+	/* 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();
+	message(L_CONSOLE | L_LOG, "The system is going down NOW!");
 
 	/* Send signals to every process _except_ pid 1 */
-	message(CONSOLE | LOG, "Sending SIGTERM to all processes.");
 	kill(-1, SIGTERM);
-	sleep(1);
+	message(L_CONSOLE | L_LOG, "Sent SIG%s to all processes", "TERM");
 	sync();
-
-	message(CONSOLE | LOG, "Sending SIGKILL to all processes.");
-	kill(-1, SIGKILL);
 	sleep(1);
 
+	kill(-1, SIGKILL);
+	message(L_CONSOLE, "Sent SIG%s to all processes", "KILL");
 	sync();
+	/*sleep(1); - callers take care about making a pause */
 }
 
-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();
-		}
-	}
-}
+/* Signal handling by init:
+ *
+ * For process with PID==1, on entry kernel sets all signals to SIG_DFL
+ * and unmasks all signals. However, for process with PID==1,
+ * default action (SIG_DFL) on any signal is to ignore it,
+ * even for special signals SIGKILL and SIGCONT.
+ * Also, any signal can be caught or blocked.
+ * (but SIGSTOP is still handled specially, at least in 2.6.20)
+ *
+ * We install two kinds of handlers, "immediate" and "delayed".
+ *
+ * Immediate handlers execute at any time, even while, say, sysinit
+ * is running.
+ *
+ * Delayed handlers just set a flag variable. The variable is checked
+ * in the main loop and acted upon.
+ *
+ * halt/poweroff/reboot and restart have immediate handlers.
+ * They only traverse linked list of struct action's, never modify it,
+ * this should be safe to do even in signal handler. Also they
+ * never return.
+ *
+ * SIGSTOP and SIGTSTP have immediate handlers. They just wait
+ * for SIGCONT to happen.
+ *
+ * SIGHUP has a delayed handler, because modifying linked list
+ * of struct action's from a signal handler while it is manipulated
+ * by the program may be disastrous.
+ *
+ * Ctrl-Alt-Del has a delayed handler. Not a must, but allowing
+ * it to happen even somewhere inside "sysinit" would be a bit awkward.
+ *
+ * There is a tiny probability that SIGHUP and Ctrl-Alt-Del will collide
+ * and only one will be remembered and acted upon.
+ */
 
-static void halt_signal(int sig)
+static void halt_reboot_pwoff(int sig) NORETURN;
+static void halt_reboot_pwoff(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();
+	const char *m;
+	unsigned rb;
+
+	run_shutdown_and_kill_processes();
+
+	m = "halt";
+	rb = RB_HALT_SYSTEM;
+	if (sig == SIGTERM) {
+		m = "reboot";
+		rb = RB_AUTOBOOT;
+	} else if (sig == SIGUSR2) {
+		m = "poweroff";
+		rb = RB_POWER_OFF;
+	}
+	message(L_CONSOLE, "Requesting system %s", m);
+	pause_and_low_level_reboot(rb);
+	/* not reached */
 }
 
-static void reboot_signal(int sig)
+/* The SIGSTOP/SIGTSTP handler
+ * NB: inside it, all signals except SIGCONT are masked
+ * via appropriate setup in sigaction().
+ */
+static void stop_handler(int sig UNUSED_PARAM)
 {
-	shutdown_system();
-	message(CONSOLE | LOG, "Please stand by while rebooting the system.");
-	sync();
-
-	/* allow time for last message to reach serial console */
-	sleep(2);
+	smallint saved_bb_got_signal;
+	int saved_errno;
 
-	init_reboot(RB_AUTOBOOT);
+	saved_bb_got_signal = bb_got_signal;
+	saved_errno = errno;
+	signal(SIGCONT, record_signo);
 
-	loop_forever();
-}
-
-static void ctrlaltdel_signal(int sig)
-{
-	run_actions(CTRLALTDEL);
-}
+	while (1) {
+		pid_t wpid;
 
-/* The SIGSTOP & SIGTSTP handler */
-static void stop_handler(int sig)
-{
-	int saved_errno = errno;
+		if (bb_got_signal == SIGCONT)
+			break;
+		/* NB: this can accidentally wait() for a process
+		 * which we waitfor() elsewhere! waitfor() must have
+		 * code which is resilient against this.
+		 */
+		wpid = wait_any_nohang(NULL);
+		mark_terminated(wpid);
+		sleep(1);
+	}
 
-	got_cont = 0;
-	while (!got_cont)
-		pause();
-	got_cont = 0;
+	signal(SIGCONT, SIG_DFL);
 	errno = saved_errno;
+	bb_got_signal = saved_bb_got_signal;
 }
 
-/* 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)
+/* Handler for QUIT - exec "restart" action,
+ * else (no such action defined) do nothing */
+static void restart_handler(int sig UNUSED_PARAM)
 {
-	struct init_action *new_action, *a;
-
-	if (*cons == '\0')
-		cons = console;
+	struct init_action *a;
 
-	/* 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;
+	for (a = init_action_list; a; a = a->next) {
+		if (!(a->action_type & RESTART))
+			continue;
 
-	new_action = calloc((size_t) (1), sizeof(struct init_action));
-	if (!new_action) {
-		message(LOG | CONSOLE, "Memory allocation failure");
-		loop_forever();
-	}
+		/* Starting from here, we won't return.
+		 * Thus don't need to worry about preserving errno
+		 * and such.
+		 */
+		run_shutdown_and_kill_processes();
 
-	/* 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;
+		/* Allow Ctrl-Alt-Del to reboot the system.
+		 * This is how kernel sets it up for init, we follow suit.
+		 */
+		reboot(RB_ENABLE_CAD); /* misnomer */
+
+		if (open_stdio_to_tty(a->terminal)) {
+			dbg_message(L_CONSOLE, "Trying to re-exec %s", a->command);
+			/* Theoretically should be safe.
+			 * But in practice, kernel bugs may leave
+			 * unkillable processes, and wait() may block forever.
+			 * Oh well. Hoping "new" init won't be too surprised
+			 * by having children it didn't create.
+			 */
+			//while (wait(NULL) > 0)
+			//	continue;
+			init_exec(a->command);
 		}
+		/* Open or exec failed */
+		pause_and_low_level_reboot(RB_HALT_SYSTEM);
+		/* not reached */
 	}
-	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)
+#if ENABLE_FEATURE_USE_INITTAB
+static void reload_inittab(void)
 {
-	struct init_action *a, *b = NULL;
+	struct init_action *a, **nextp;
+
+	message(L_LOG, "reloading /etc/inittab");
+
+	/* Disable old entries */
+	for (a = init_action_list; a; a = a->next)
+		a->action_type = ONCE;
+
+	/* Append new entries, or modify existing entries
+	 * (set a->action_type) if cmd and device name
+	 * match new ones. End result: only entries with
+	 * a->action_type == ONCE are stale.
+	 */
+	parse_inittab();
+
+#if ENABLE_FEATURE_KILL_REMOVED
+	/* Kill stale entries */
+	/* Be nice and send SIGTERM first */
+	for (a = init_action_list; a; a = a->next)
+		if (a->action_type == ONCE && a->pid != 0)
+			kill(a->pid, SIGTERM);
+	if (CONFIG_FEATURE_KILL_DELAY) {
+		/* NB: parent will wait in NOMMU case */
+		if ((BB_MMU ? fork() : vfork()) == 0) { /* child */
+			sleep(CONFIG_FEATURE_KILL_DELAY);
+			for (a = init_action_list; a; a = a->next)
+				if (a->action_type == ONCE && a->pid != 0)
+					kill(a->pid, SIGKILL);
+			_exit(EXIT_SUCCESS);
+		}
+	}
+#endif
 
-	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;
-			}
+	/* Remove stale (ONCE) and not useful (SYSINIT,WAIT) entries */
+	nextp = &init_action_list;
+	while ((a = *nextp) != NULL) {
+		if (a->action_type & (ONCE | SYSINIT | WAIT)) {
+			*nextp = a->next;
 			free(a);
-			break;
+		} else {
+			nextp = &a->next;
 		}
 	}
-}
-
-/* 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();
+	/* Not needed: */
+	/* run_actions(RESPAWN | ASKFIRST); */
+	/* - we return to main loop, which does this automagically */
 }
+#endif
 
-/* 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)
+static int check_delayed_sigs(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;
+	int sigs_seen = 0;
 
-
-	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", "");
+	while (1) {
+		smallint sig = bb_got_signal;
+
+		if (!sig)
+			return sigs_seen;
+		bb_got_signal = 0;
+		sigs_seen = 1;
+#if ENABLE_FEATURE_USE_INITTAB
+		if (sig == SIGHUP)
+			reload_inittab();
 #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);
-		}
+		if (sig == SIGINT)
+			run_actions(CTRLALTDEL);
 	}
-	fclose(file);
-	return;
-#endif							/* CONFIG_FEATURE_USE_INITTAB */
 }
 
-static void reload_signal(int sig)
+int init_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int init_main(int argc UNUSED_PARAM, char **argv)
 {
-        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;
+	die_sleep = 30 * 24*60*60; /* if xmalloc would ever die... */
 
-	if (argc > 1 && !strcmp(argv[1], "-q")) {
-		return kill_init(SIGHUP);
+	if (argv[1] && !strcmp(argv[1], "-q")) {
+		return kill(1, 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
+
+	if (!DEBUG_INIT) {
+		/* Expect to be invoked as init with PID=1 or be invoked as linuxrc */
+		if (getpid() != 1
+		 && (!ENABLE_FEATURE_INITRD || !strstr(applet_name, "linuxrc"))
 		) {
-		bb_show_usage();
+			bb_show_usage();
+		}
+		/* Turn off rebooting via CTL-ALT-DEL - we get a
+		 * SIGINT on CAD so we can shut things down gracefully... */
+		reboot(RB_DISABLE_CAD); /* misnomer */
 	}
-	/* 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();
+	set_sane_term();
+	xchdir("/");
+	setsid();
 
-	/* Close whatever files are open, and reset the console. */
-	close(0);
-	close(1);
-	close(2);
+	/* Make sure environs is set to something sane */
+	putenv((char *) "HOME=/");
+	putenv((char *) bb_PATH_root_path);
+	putenv((char *) "SHELL=/bin/sh");
+	putenv((char *) "USER=root"); /* needed? why? */
 
-	if (device_open(console, O_RDWR | O_NOCTTY) == 0) {
-		set_term(0);
-		close(0);
-	}
+	if (argv[1])
+		xsetenv("RUNLEVEL", argv[1]);
 
-	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);
+	message(MAYBE_CONSOLE | L_LOG, "init started: %s", bb_banner);
 
 	/* Make sure there is enough memory to do something useful. */
-	check_memory();
+	if (ENABLE_SWAPONOFF) {
+		struct sysinfo info;
+
+		if (sysinfo(&info) == 0
+		 && (info.mem_unit ? : 1) * (long long)info.totalram < 1024*1024
+		) {
+			message(L_CONSOLE, "Low memory, forcing swapon");
+			/* swapon -a requires /proc typically */
+			new_init_action(SYSINIT, "mount -t proc proc /proc", "");
+			/* Try to turn on swap */
+			new_init_action(SYSINIT, "swapon -a", "");
+			run_actions(SYSINIT);   /* wait and removing */
+		}
+	}
 
 	/* 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"))) {
+	if (argv[1]
+	 && (!strcmp(argv[1], "single") || !strcmp(argv[1], "-s") || LONE_CHAR(argv[1], '1'))
+	) {
+		/* ??? shouldn't we set RUNLEVEL="b" here? */
 		/* Start a shell on console */
-		new_init_action(RESPAWN, LOGIN_SHELL, "");
+		new_init_action(RESPAWN, bb_default_login_shell, "");
 	} else {
-		/* Not in single user mode -- see what inittab says */
+		/* 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 
+		 * actions(i.e., INIT_SCRIPT and a pair
 		 * of "askfirst" shells */
 		parse_inittab();
 	}
 
-	/* Make the command line just say "init"  -- thats all, nothing else */
-	fixup_argv(argc, argv, "init");
+#if ENABLE_SELINUX
+	if (getenv("SELINUX_INIT") == NULL) {
+		int enforce = 0;
+
+		putenv((char*)"SELINUX_INIT=YES");
+		if (selinux_init_load_policy(&enforce) == 0) {
+			BB_EXECVP(argv[0], argv);
+		} else if (enforce > 0) {
+			/* SELinux in enforcing mode but load_policy failed */
+			message(L_CONSOLE, "cannot load SELinux Policy. "
+				"Machine is in enforcing mode. Halting now.");
+			exit(EXIT_FAILURE);
+		}
+	}
+#endif
+
+	/* Make the command line just say "init"  - thats all, nothing else */
+	strncpy(argv[0], "init", strlen(argv[0]));
+	/* Wipe argv[1]-argv[N] so they don't clutter the ps listing */
+	while (*++argv)
+		memset(*argv, 0, strlen(*argv));
+
+	/* Set up signal handlers */
+	if (!DEBUG_INIT) {
+		struct sigaction sa;
+
+		bb_signals(0
+			+ (1 << SIGUSR1) /* halt */
+			+ (1 << SIGTERM) /* reboot */
+			+ (1 << SIGUSR2) /* poweroff */
+			, halt_reboot_pwoff);
+		signal(SIGQUIT, restart_handler); /* re-exec another init */
+
+		/* Stop handler must allow only SIGCONT inside itself */
+		memset(&sa, 0, sizeof(sa));
+		sigfillset(&sa.sa_mask);
+		sigdelset(&sa.sa_mask, SIGCONT);
+		sa.sa_handler = stop_handler;
+		/* NB: sa_flags doesn't have SA_RESTART.
+		 * It must be able to interrupt wait().
+		 */
+		sigaction_set(SIGTSTP, &sa); /* pause */
+		/* Does not work as intended, at least in 2.6.20.
+		 * SIGSTOP is simply ignored by init:
+		 */
+		sigaction_set(SIGSTOP, &sa); /* pause */
 
-	/* Now run everything that needs to be run */
+		/* SIGINT (Ctrl-Alt-Del) must interrupt wait(),
+		 * setting handler without SA_RESTART flag.
+		 */
+		bb_signals_recursive_norestart((1 << SIGINT), record_signo);
+	}
 
+	/* Now run everything that needs to be run */
 	/* First run the sysinit command */
 	run_actions(SYSINIT);
-
+	check_delayed_sigs();
 	/* Next run anything that wants to block */
 	run_actions(WAIT);
-
+	check_delayed_sigs();
 	/* 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);
+	/* Set up "reread /etc/inittab" handler.
+	 * Handler is set up without SA_RESTART, it will interrupt syscalls.
+	 */
+	if (!DEBUG_INIT && ENABLE_FEATURE_USE_INITTAB)
+		bb_signals_recursive_norestart((1 << SIGHUP), record_signo);
 
-	/* Now run the looping stuff for the rest of forever */
+	/* Now run the looping stuff for the rest of forever.
+	 * NB: if delayed signal happened, avoid blocking in wait().
+	 */
 	while (1) {
-		/* run the respawn stuff */
-		run_actions(RESPAWN);
+		int maybe_WNOHANG;
 
-		/* run the askfirst stuff */
-		run_actions(ASKFIRST);
+		maybe_WNOHANG = check_delayed_sigs();
 
-		/* Don't consume all CPU time -- sleep a bit */
+		/* (Re)run the respawn/askfirst stuff */
+		run_actions(RESPAWN | ASKFIRST);
+		maybe_WNOHANG |= check_delayed_sigs();
+
+		/* Don't consume all CPU time - sleep a bit */
 		sleep(1);
+		maybe_WNOHANG |= check_delayed_sigs();
 
-		/* 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);
-				}
+		/* Wait for any child process(es) to exit.
+		 * NB: "delayed" signals will also interrupt this wait(),
+		 * bb_signals_recursive_norestart() set them up for that.
+		 * This guarantees we won't be stuck here
+		 * till next orphan dies.
+		 */
+		if (maybe_WNOHANG)
+			maybe_WNOHANG = WNOHANG;
+		while (1) {
+			pid_t wpid;
+			struct init_action *a;
+
+			wpid = waitpid(-1, NULL, maybe_WNOHANG);
+			if (wpid <= 0)
+				break;
+
+			a = mark_terminated(wpid);
+			if (a) {
+				message(L_LOG, "process '%s' (pid %d) exited. "
+						"Scheduling for restart.",
+						a->command, wpid);
 			}
-			/* see if anyone else is waiting to be reaped */
-			wpid = waitpid (-1, &status, WNOHANG);
+			/* See if anyone else is waiting to be reaped */
+			maybe_WNOHANG = WNOHANG;
 		}
-	}
+	} /* while (1) */
 }
-
-/*
-Local Variables:
-c-file-style: "linux"
-c-basic-offset: 4
-tab-width: 4
-End:
-*/