* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
*/
-#include "busybox.h"
+#include "libbb.h"
#include <paths.h>
-#include <signal.h>
-#include <sys/ioctl.h>
-#include <sys/wait.h>
#include <sys/reboot.h>
-
-#if ENABLE_SYSLOGD
-# include <sys/syslog.h>
-#endif
+#include <sys/syslog.h>
#define INIT_BUFFS_SIZE 256
#define CONSOLE_NAME_SIZE 32
#define MAXENV 16 /* Number of env. vars */
-#ifndef _PATH_STDPATH
-#define _PATH_STDPATH "/usr/bin:/bin:/usr/sbin:/sbin"
-#endif
-
-#if ENABLE_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.
*/
#define CORE_ENABLE_FLAG_FILE "/.init_enable_core"
#include <sys/resource.h>
-#endif
#define INITTAB "/etc/inittab" /* inittab file location */
#ifndef INIT_SCRIPT
#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}
-};
+#define STR_SYSINIT "\x01"
+#define STR_RESPAWN "\x02"
+#define STR_ASKFIRST "\x04"
+#define STR_WAIT "\x08"
+#define STR_ONCE "\x10"
+#define STR_CTRLALTDEL "\x20"
+#define STR_SHUTDOWN "\x40"
+#define STR_RESTART "\x80"
/* Set up a linked list of init_actions, to be read from inittab */
struct init_action {
struct init_action *next;
- int action;
pid_t pid;
- char command[INIT_BUFFS_SIZE];
+ uint8_t action;
char terminal[CONSOLE_NAME_SIZE];
+ char command[INIT_BUFFS_SIZE];
};
/* Static variables */
static struct init_action *init_action_list = NULL;
-#if !ENABLE_SYSLOGD
static const char *log_console = VC_5;
-#endif
-#if !ENABLE_DEBUG_INIT
static sig_atomic_t got_cont = 0;
-#endif
enum {
L_LOG = 0x1,
#endif
};
-static const char * const environment[] = {
+static const char *const environment[] = {
"HOME=/",
- "PATH=" _PATH_STDPATH,
+ bb_PATH_root_path,
"SHELL=/bin/sh",
"USER=root",
NULL
/* Function prototypes */
static void delete_init_action(struct init_action *a);
-static int waitfor(const struct init_action *a, pid_t pid);
-#if !ENABLE_DEBUG_INIT
-static void shutdown_signal(int sig);
-#endif
+static void halt_reboot_pwoff(int sig) ATTRIBUTE_NORETURN;
-#if !ENABLE_DEBUG_INIT
+static void waitfor(pid_t pid)
+{
+ /* waitfor(run(x)): protect against failed fork inside run() */
+ if (pid <= 0)
+ return;
+
+ /* Wait for any child (prevent zombies from exiting orphaned processes)
+ * but exit the loop only when specified one has exited. */
+ while (wait(NULL) != pid)
+ continue;
+}
+
+static void loop_forever(void) ATTRIBUTE_NORETURN;
static void loop_forever(void)
{
while (1)
sleep(1);
}
-#endif
/* Print a message to the specified device.
* Device may be bitwise-or'd from L_LOG | L_CONSOLE */
-#if ENABLE_DEBUG_INIT
-#define messageD message
-#else
-#define messageD(...) do {} while (0)
-#endif
+#define messageD(...) do { if (ENABLE_DEBUG_INIT) message(__VA_ARGS__); } while (0)
static void message(int device, const char *fmt, ...)
__attribute__ ((format(printf, 2, 3)));
static void message(int device, const char *fmt, ...)
{
-#if !ENABLE_SYSLOGD
static int log_fd = -1;
-#endif
-
va_list arguments;
int l;
char msg[128];
msg[sizeof(msg) - 2] = '\0';
l = strlen(msg);
-#if ENABLE_SYSLOGD
- /* Log the message to syslogd */
- if (device & L_LOG) {
- /* don't out "\r" */
- openlog(applet_name, 0, LOG_DAEMON);
- syslog(LOG_INFO, "init: %s", msg + 1);
- closelog();
- }
- 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_console) {
- log_fd = 2;
- } 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);
- device = L_CONSOLE;
+ if (ENABLE_FEATURE_INIT_SYSLOG) {
+ /* Log the message to syslogd */
+ if (device & L_LOG) {
+ /* don't out "\r" */
+ openlog(applet_name, 0, LOG_DAEMON);
+ syslog(LOG_INFO, "init: %s", msg + 1);
+ closelog();
+ }
+ 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_console) {
+ log_fd = 2;
} else {
- fcntl(log_fd, F_SETFD, FD_CLOEXEC);
+ 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);
+ device = L_CONSOLE;
+ } else {
+ close_on_exec_on(log_fd);
+ }
}
}
+ if (device & L_LOG) {
+ full_write(log_fd, msg, l);
+ if (log_fd == 2)
+ return; /* don't print dup messages */
+ }
}
- if (device & L_LOG) {
- full_write(log_fd, msg, l);
- if (log_fd == 2)
- return; /* don't print dup messages */
- }
-#endif
if (device & L_CONSOLE) {
/* Send console messages to console so people will see them. */
}
}
-/* Set terminal settings to reasonable defaults */
-static void set_sane_term(void)
-{
- struct termios tty;
-
- tcgetattr(STDIN_FILENO, &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(STDIN_FILENO, TCSANOW, &tty);
-}
-
/* From <linux/serial.h> */
struct serial_struct {
int type;
while (fd > 2) close(fd--);
}
messageD(L_LOG, "console='%s'", s);
+ } else {
+ /* Make sure fd 0,1,2 are not closed */
+ bb_sanitize_stdio();
}
s = getenv("TERM");
if (ioctl(0, TIOCGSERIAL, &sr) == 0) {
- /* Force the TERM setting to vt102 for serial console --
+ /* Force the TERM setting to vt102 for serial console
* if TERM is set to linux (the default) */
if (!s || strcmp(s, "linux") == 0)
putenv((char*)"TERM=vt102");
-#if !ENABLE_SYSLOGD
- log_console = NULL;
-#endif
+ if (!ENABLE_FEATURE_INIT_SYSLOG)
+ log_console = NULL;
} else if (!s)
putenv((char*)"TERM=linux");
}
-static void fixup_argv(int argc, char **argv, const char *new_argv0)
+/* Set terminal settings to reasonable defaults */
+static void set_sane_term(void)
{
- int len;
+ struct termios tty;
- /* Fix up argv[0] to be certain we claim to be init */
- len = strlen(argv[0]);
- strncpy(argv[0], new_argv0, len);
+ tcgetattr(STDIN_FILENO, &tty);
- /* 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++;
- }
+ /* 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(STDIN_FILENO, TCSANOW, &tty);
}
/* Open the new terminal device */
-static void open_stdio_to_tty(const char* tty_name, int fail)
+static void open_stdio_to_tty(const char* tty_name, int exit_on_failure)
{
/* empty tty_name means "use init's tty", else... */
if (tty_name[0]) {
- int fd = device_open(tty_name, O_RDWR);
- if (fd < 0) {
+ int fd;
+ close(0);
+ /* 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));
- if (fail)
+ if (exit_on_failure)
_exit(1);
-#if !ENABLE_DEBUG_INIT
- shutdown_signal(SIGUSR1);
-#else
- _exit(2);
-#endif
- } else {
- dup2(fd, 0);
- dup2(fd, 1);
- dup2(fd, 2);
- if (fd > 2) close(fd);
+ if (ENABLE_DEBUG_INIT)
+ _exit(2);
+ halt_reboot_pwoff(SIGUSR1); /* halt the system */
}
+ dup2(0, 1);
+ dup2(0, 2);
}
set_sane_term();
}
+/* Used only by run_actions */
static pid_t run(const struct init_action *a)
{
int i;
char buf[INIT_BUFFS_SIZE + 6]; /* INIT_BUFFS_SIZE+strlen("exec ")+1 */
sigset_t nmask, omask;
- /* Block sigchild while forking. */
+ /* Block sigchild while forking (why?) */
sigemptyset(&nmask);
sigaddset(&nmask, SIGCHLD);
sigprocmask(SIG_BLOCK, &nmask, &omask);
pid = fork();
sigprocmask(SIG_SETMASK, &omask, NULL);
+ if (pid < 0)
+ message(L_LOG | L_CONSOLE, "Can't fork");
if (pid)
return pid;
+ /* Child */
+
/* Reset signal handlers that were set by the parent process */
signal(SIGUSR1, SIG_DFL);
signal(SIGUSR2, SIG_DFL);
setsid();
/* Open the new terminal device */
- open_stdio_to_tty(a->terminal, 1);
+ open_stdio_to_tty(a->terminal, 1 /* - exit if open fails*/);
+#ifdef BUT_RUN_ACTIONS_ALREADY_DOES_WAITING
/* 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) {
+ pid = fork();
+ if (pid < 0) {
message(L_LOG | L_CONSOLE, "Can't fork");
_exit(1);
}
if (pid > 0) {
-
- /* We are the parent -- wait till the child is done */
+ /* Parent - wait till the child is done */
signal(SIGINT, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
signal(SIGQUIT, SIG_IGN);
signal(SIGCHLD, SIG_DFL);
- waitfor(NULL, pid);
+ waitfor(pid);
/* See if stealing the controlling tty back is necessary */
if (tcgetpgrp(0) != getpid())
_exit(0);
/* Use a temporary process to steal the controlling tty. */
- if ((pid = fork()) < 0) {
+ pid = fork();
+ if (pid < 0) {
message(L_LOG | L_CONSOLE, "Can't fork");
_exit(1);
}
ioctl(0, TIOCSCTTY, 1);
_exit(0);
}
- waitfor(NULL, pid);
+ waitfor(pid);
_exit(0);
}
- /* Now fall though to actually execute things */
+ /* Child - fall though to actually execute things */
}
+#endif
/* See if any special /bin/sh requiring characters are present */
if (strpbrk(a->command, "~`!$^&*()=|\\{}[];\"'<>?") != NULL) {
/* skip over the dash */
++cmdpath;
+#ifdef WHY_WE_DO_THIS_SHELL_MUST_HANDLE_THIS_ITSELF
/* find the last component in the command pathname */
- s = bb_get_last_path_component(cmdpath);
-
+ s = bb_get_last_path_component_nostrip(cmdpath);
/* make a new argv[0] */
- if ((cmd[0] = malloc(strlen(s) + 2)) == NULL) {
+ cmd[0] = malloc(strlen(s) + 2);
+ if (cmd[0] == NULL) {
message(L_LOG | L_CONSOLE, bb_msg_memory_exhausted);
cmd[0] = cmdpath;
} else {
cmd[0][0] = '-';
strcpy(cmd[0] + 1, s);
}
-#if ENABLE_FEATURE_INIT_SCTTY
- /* Establish this process as session leader and
- * (attempt) to make the tty (if any) a controlling tty.
- */
- setsid();
- ioctl(0, TIOCSCTTY, 0 /*don't steal it*/);
#endif
+
+ /* _Attempt_ to make stdin a controlling tty. */
+ if (ENABLE_FEATURE_INIT_SCTTY)
+ ioctl(0, TIOCSCTTY, 0 /*only try, don't steal*/);
}
-#if !defined(__UCLIBC__) || defined(__ARCH_HAS_MMU__)
if (a->action & ASKFIRST) {
- static const char press_enter[] =
+ static const char press_enter[] ALIGN1 =
#ifdef CUSTOMIZED_BANNER
#include CUSTOMIZED_BANNER
#endif
"(pid %d, tty '%s')\n",
cmdpath, getpid(), a->terminal);
full_write(1, press_enter, sizeof(press_enter) - 1);
- while (read(0, &c, 1) == 1 && c != '\n')
- ;
+ while (safe_read(0, &c, 1) == 1 && c != '\n')
+ continue;
}
-#endif
+
/* Log the process name and args */
message(L_LOG, "starting pid %d, tty '%s': '%s'",
getpid(), a->terminal, cmdpath);
-#if ENABLE_FEATURE_INIT_COREDUMPS
- {
+ if (ENABLE_FEATURE_INIT_COREDUMPS) {
struct stat sb;
if (stat(CORE_ENABLE_FLAG_FILE, &sb) == 0) {
struct rlimit limit;
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. */
BB_EXECVP(cmdpath, cmd);
_exit(-1);
}
-static int waitfor(const struct init_action *a, pid_t pid)
-{
- int runpid;
- int status, wpid;
-
- runpid = (NULL == a)? pid : run(a);
- while (1) {
- wpid = waitpid(runpid, &status, 0);
- if (wpid == runpid)
- break;
- if (wpid == -1 && errno == ECHILD) {
- /* we missed its termination */
- break;
- }
- /* FIXME other errors should maybe trigger an error, but allow
- * the program to continue */
- }
- return wpid;
-}
-
/* Run all commands of a particular type */
static void run_actions(int action)
{
for (a = init_action_list; a; a = tmp) {
tmp = a->next;
if (a->action == action) {
- /* a->terminal of "" means "init's console" */
- if (a->terminal[0] && access(a->terminal, R_OK | W_OK)) {
- delete_init_action(a);
- } else if (a->action & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN | RESTART)) {
- waitfor(a, 0);
+ // Pointless: run() will error out if open of device fails.
+ ///* a->terminal of "" means "init's console" */
+ //if (a->terminal[0] && access(a->terminal, R_OK | W_OK)) {
+ // //message(L_LOG | L_CONSOLE, "Device %s cannot be opened in RW mode", a->terminal /*, strerror(errno)*/);
+ // delete_init_action(a);
+ //} else
+ if (a->action & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN | RESTART)) {
+ waitfor(run(a));
delete_init_action(a);
} else if (a->action & ONCE) {
run(a);
}
}
-#if !ENABLE_DEBUG_INIT
static void init_reboot(unsigned long magic)
{
pid_t pid;
reboot(magic);
_exit(0);
}
- waitpid(pid, NULL, 0);
+ waitfor(pid);
}
-static void shutdown_system(void)
+static void kill_all_processes(void)
{
sigset_t block_signals;
run_actions(SHUTDOWN);
/* first disable all our signals */
- sigemptyset(&block_signals);
+ sigfillset(&block_signals);
+ /*sigemptyset(&block_signals);
sigaddset(&block_signals, SIGHUP);
sigaddset(&block_signals, SIGQUIT);
sigaddset(&block_signals, SIGCHLD);
sigaddset(&block_signals, SIGTERM);
sigaddset(&block_signals, SIGCONT);
sigaddset(&block_signals, SIGSTOP);
- sigaddset(&block_signals, SIGTSTP);
+ sigaddset(&block_signals, SIGTSTP);*/
sigprocmask(SIG_BLOCK, &block_signals, NULL);
message(L_CONSOLE | L_LOG, "The system is going down NOW!");
sleep(1);
}
-static void exec_signal(int sig ATTRIBUTE_UNUSED)
+static void halt_reboot_pwoff(int sig)
+{
+ const char *m;
+ int rb;
+
+ kill_all_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 | L_LOG, "Requesting system %s", m);
+ /* allow time for last message to reach serial console */
+ sleep(2);
+ init_reboot(rb);
+ loop_forever();
+}
+
+/* Handler for HUP and QUIT - exec "restart" action,
+ * else (no such action defined) do nothing */
+static void exec_restart_action(int sig ATTRIBUTE_UNUSED)
{
struct init_action *a, *tmp;
sigset_t unblock_signals;
for (a = init_action_list; a; a = tmp) {
tmp = a->next;
if (a->action & RESTART) {
- shutdown_system();
+ kill_all_processes();
- /* unblock all signals, blocked in shutdown_system() */
- sigemptyset(&unblock_signals);
+ /* unblock all signals (blocked in kill_all_processes()) */
+ sigfillset(&unblock_signals);
+ /*sigemptyset(&unblock_signals);
sigaddset(&unblock_signals, SIGHUP);
sigaddset(&unblock_signals, SIGQUIT);
sigaddset(&unblock_signals, SIGCHLD);
sigaddset(&unblock_signals, SIGTERM);
sigaddset(&unblock_signals, SIGCONT);
sigaddset(&unblock_signals, SIGSTOP);
- sigaddset(&unblock_signals, SIGTSTP);
+ sigaddset(&unblock_signals, SIGTSTP);*/
sigprocmask(SIG_UNBLOCK, &unblock_signals, NULL);
/* Open the new terminal device */
- open_stdio_to_tty(a->terminal, 0);
+ open_stdio_to_tty(a->terminal, 0 /* - halt if open fails */);
messageD(L_CONSOLE | L_LOG, "Trying to re-exec %s", a->command);
BB_EXECLP(a->command, a->command, NULL);
}
}
-static void shutdown_signal(int sig)
-{
- const char *m;
- int rb;
-
- shutdown_system();
-
- 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 | L_LOG, "Requesting system %s", m);
- /* allow time for last message to reach serial console */
- sleep(2);
- init_reboot(rb);
- loop_forever();
-}
-
static void ctrlaltdel_signal(int sig ATTRIBUTE_UNUSED)
{
run_actions(CTRLALTDEL);
got_cont = 0;
while (!got_cont)
pause();
- got_cont = 0;
+
errno = saved_errno;
}
got_cont = 1;
}
-#endif /* !ENABLE_DEBUG_INIT */
-
-static void new_init_action(int action, const char *command, const char *cons)
+static void new_init_action(uint8_t action, const char *command, const char *cons)
{
struct init_action *new_action, *a, *last;
*/
static void parse_inittab(void)
{
-#if ENABLE_FEATURE_USE_INITTAB
FILE *file;
- char buf[INIT_BUFFS_SIZE], lineAsRead[INIT_BUFFS_SIZE];
- char tmpConsole[CONSOLE_NAME_SIZE];
- char *id, *runlev, *action, *command, *eol;
- const struct init_action_type *a = actions;
+ char buf[INIT_BUFFS_SIZE];
+
+ if (ENABLE_FEATURE_USE_INITTAB)
+ file = fopen(INITTAB, "r");
+ else
+ file = NULL;
- file = fopen(INITTAB, "r");
+ /* No inittab file -- set up some default behavior */
if (file == NULL) {
- /* No inittab file -- set up some default behavior */
-#endif
/* 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", "");
+ if (ENABLE_SWAPONOFF)
+ new_init_action(SHUTDOWN, "swapoff -a", "");
/* Prepare to restart init when a HUP is received */
new_init_action(RESTART, "init", "");
/* Askfirst shell on tty1-4 */
new_init_action(SYSINIT, INIT_SCRIPT, "");
return;
-#if ENABLE_FEATURE_USE_INITTAB
}
while (fgets(buf, INIT_BUFFS_SIZE, file) != NULL) {
- /* Skip leading spaces */
- for (id = buf; *id == ' ' || *id == '\t'; id++);
+ static const char actions[] =
+ STR_SYSINIT "sysinit\0"
+ STR_RESPAWN "respawn\0"
+ STR_ASKFIRST "askfirst\0"
+ STR_WAIT "wait\0"
+ STR_ONCE "once\0"
+ STR_CTRLALTDEL "ctrlaltdel\0"
+ STR_SHUTDOWN "shutdown\0"
+ STR_RESTART "restart\0"
+ ;
+ char tmpConsole[CONSOLE_NAME_SIZE];
+ char *id, *runlev, *action, *command;
+ const char *a;
+ /* Skip leading spaces */
+ id = skip_whitespace(buf);
/* Skip the line if it's a comment */
if (*id == '#' || *id == '\n')
continue;
+ /* Trim the trailing '\n' */
+ *strchrnul(id, '\n') = '\0';
- /* Trim the trailing \n */
- //XXX: chomp() ?
- 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 */
+ /* Line is: "id:runlevel_ignored:action:command" */
runlev = strchr(id, ':');
- if (runlev == NULL || *(runlev + 1) == '\0') {
- message(L_LOG | L_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(L_LOG | L_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(L_LOG | L_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 (runlev == NULL /*|| runlev[1] == '\0' - not needed */)
+ goto bad_entry;
+ action = strchr(runlev + 1, ':');
+ if (action == NULL /*|| action[1] == '\0' - not needed */)
+ goto bad_entry;
+ command = strchr(action + 1, ':');
+ if (command == NULL || command[1] == '\0')
+ goto bad_entry;
+
+ *command = '\0'; /* action => ":action\0" now */
+ for (a = actions; a[0]; a += strlen(a) + 1) {
+ if (strcmp(a + 1, action + 1) == 0) {
+ *runlev = '\0';
if (*id != '\0') {
- if(strncmp(id, "/dev/", 5) == 0)
+ if (strncmp(id, "/dev/", 5) == 0)
id += 5;
strcpy(tmpConsole, "/dev/");
safe_strncpy(tmpConsole + 5, id,
sizeof(tmpConsole) - 5);
id = tmpConsole;
}
- new_init_action(a->action, command, id);
- break;
+ new_init_action((uint8_t)a[0], command + 1, id);
+ goto next_line;
}
}
- if (a->name == 0) {
- /* Choke on an unknown action */
- message(L_LOG | L_CONSOLE, "Bad inittab entry: %s", lineAsRead);
- }
+ *command = ':';
+ /* Choke on an unknown action */
+ bad_entry:
+ message(L_LOG | L_CONSOLE, "Bad inittab entry: %s", id);
+ next_line: ;
}
fclose(file);
-#endif /* FEATURE_USE_INITTAB */
}
-#if ENABLE_FEATURE_USE_INITTAB
static void reload_signal(int sig ATTRIBUTE_UNUSED)
{
struct init_action *a, *tmp;
message(L_LOG, "reloading /etc/inittab");
/* disable old entrys */
- for (a = init_action_list; a; a = a->next ) {
+ for (a = init_action_list; a; a = a->next) {
a->action = ONCE;
}
parse_inittab();
+ if (ENABLE_FEATURE_KILL_REMOVED) {
+ /* Be nice and send SIGTERM first */
+ for (a = init_action_list; a; a = a->next) {
+ pid_t pid = a->pid;
+ if ((a->action & ONCE) && pid != 0) {
+ kill(pid, SIGTERM);
+ }
+ }
+#if CONFIG_FEATURE_KILL_DELAY
+ if (fork() == 0) { /* child */
+ sleep(CONFIG_FEATURE_KILL_DELAY);
+ for (a = init_action_list; a; a = a->next) {
+ pid_t pid = a->pid;
+ if ((a->action & ONCE) && pid != 0) {
+ kill(pid, SIGKILL);
+ }
+ }
+ _exit(0);
+ }
+#endif
+ }
+
/* remove unused entrys */
for (a = init_action_list; a; a = tmp) {
tmp = a->next;
- if (a->action & (ONCE | SYSINIT | WAIT ) &&
- a->pid == 0 ) {
+ if ((a->action & (ONCE | SYSINIT | WAIT)) && a->pid == 0) {
delete_init_action(a);
}
}
run_actions(RESPAWN);
}
-#endif /* FEATURE_USE_INITTAB */
-int init_main(int argc, char **argv);
+int init_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int init_main(int argc, char **argv)
{
struct init_action *a;
if (argc > 1 && !strcmp(argv[1], "-q")) {
return kill(1, SIGHUP);
}
-#if !ENABLE_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();
+
+ if (!ENABLE_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();
+ }
+ /* Set up sig handlers -- be sure to
+ * clear all of these in run() */
+ signal(SIGHUP, exec_restart_action);
+ signal(SIGQUIT, exec_restart_action);
+ signal(SIGUSR1, halt_reboot_pwoff); /* halt */
+ signal(SIGUSR2, halt_reboot_pwoff); /* poweroff */
+ signal(SIGTERM, halt_reboot_pwoff); /* reboot */
+ signal(SIGINT, ctrlaltdel_signal);
+ signal(SIGCONT, cont_handler);
+ signal(SIGSTOP, stop_handler);
+ signal(SIGTSTP, stop_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);
}
- /* Set up sig handlers -- be sure to
- * clear all of these in run() */
- signal(SIGHUP, exec_signal);
- signal(SIGQUIT, exec_signal);
- signal(SIGUSR1, shutdown_signal);
- signal(SIGUSR2, shutdown_signal);
- signal(SIGINT, ctrlaltdel_signal);
- signal(SIGTERM, shutdown_signal);
- signal(SIGCONT, cont_handler);
- signal(SIGSTOP, stop_handler);
- signal(SIGTSTP, stop_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();
chdir("/");
setsid();
{
- const char * const *e;
+ const char *const *e;
/* Make sure environs is set to something sane */
for (e = environment; *e; e++)
putenv((char *) *e);
if (argc > 1) setenv("RUNLEVEL", argv[1], 1);
/* Hello world */
- message(MAYBE_CONSOLE | L_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. */
if (ENABLE_SWAPONOFF) {
if (getenv("SELINUX_INIT") == NULL) {
int enforce = 0;
- putenv("SELINUX_INIT=YES");
+ 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 */
- /* At this point, we probably can't open /dev/console, so log() won't work */
message(L_CONSOLE, "Cannot load SELinux Policy. "
"Machine is in enforcing mode. Halting now.");
exit(1);
}
#endif /* CONFIG_SELINUX */
- /* Make the command line just say "init" -- thats all, nothing else */
- fixup_argv(argc, argv, "init");
+ /* 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));
/* Now run everything that needs to be run */
/* Next run anything to be run only once */
run_actions(ONCE);
-#if ENABLE_FEATURE_USE_INITTAB
/* Redefine SIGHUP to reread /etc/inittab */
- signal(SIGHUP, reload_signal);
-#else
- signal(SIGHUP, SIG_IGN);
-#endif /* FEATURE_USE_INITTAB */
+ if (ENABLE_FEATURE_USE_INITTAB)
+ signal(SIGHUP, reload_signal);
+ else
+ signal(SIGHUP, SIG_IGN);
/* Now run the looping stuff for the rest of forever */
while (1) {
/* Don't consume all CPU time -- sleep a bit */
sleep(1);
- /* Wait for a child process to exit */
+ /* Wait for any child process to exit */
wpid = wait(NULL);
while (wpid > 0) {
/* Find out who died and clean up their corpse */
}
}
/* see if anyone else is waiting to be reaped */
- wpid = waitpid(-1, NULL, WNOHANG);
+ wpid = wait_any_nohang(NULL);
}
}
}
projects / oweals / busybox.git / blobdiff