summaryrefslogtreecommitdiff
path: root/polux/application/mininit
diff options
context:
space:
mode:
Diffstat (limited to 'polux/application/mininit')
-rw-r--r--polux/application/mininit/Makefile27
-rw-r--r--polux/application/mininit/init.c1146
2 files changed, 1173 insertions, 0 deletions
diff --git a/polux/application/mininit/Makefile b/polux/application/mininit/Makefile
new file mode 100644
index 0000000000..628ac9038e
--- /dev/null
+++ b/polux/application/mininit/Makefile
@@ -0,0 +1,27 @@
+PREFIX=/usr/local
+BINDIR=$(PREFIX)/sbin
+EXEC=init
+
+CC=arm-uclinux-gcc
+CFLAGS=-Os -fomit-frame-pointer -march=armv5 -msoft-float
+LDFLAGS=-Wl,-elf2flt='-z -s 8k'
+
+all: $(EXEC)
+
+OBJS+=init.o
+
+$(EXEC): $(OBJS)
+ $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+%.o: %.c
+ $(CC) -MMD $(CFLAGS) -c $<
+
+-include *.d
+
+install:
+ mkdir -p $(BINDIR)
+ rm -f $(BINDIR)/$(EXEC)
+ cp -f $(EXEC) $(BINDIR)
+
+clean:
+ rm -f *.o init *.gdb *.d
diff --git a/polux/application/mininit/init.c b/polux/application/mininit/init.c
new file mode 100644
index 0000000000..c3ca75af17
--- /dev/null
+++ b/polux/application/mininit/init.c
@@ -0,0 +1,1146 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini init implementation for busybox
+ *
+ * Copyright (C) 1995, 1996 by Bruce Perens <bruce@pixar.com>.
+ * 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
+ *
+ */
+
+/* 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 <dirent.h>
+#include <pwd.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 <sys/syslog.h>
+#include <sys/sysinfo.h>
+#include <sys/stat.h>
+
+#define SC_FORMAT "/dev/ttyS%d"
+#define VC_FORMAT "/dev/tty%d"
+#define CURRENT_VC "/dev/tty0"
+
+#define DEFAULT_SHELL "-/bin/sh"
+#define COMM_LEN 16
+
+#define INIT_BUFFS_SIZE 256
+
+const char * const msg_memory_exhausted = "memory exhausted";
+
+/* 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;
+ unsigned int port;
+ int irq;
+ int flags;
+ int xmit_fifo_size;
+ int custom_divisor;
+ int baud_base;
+ unsigned short close_delay;
+ char io_type;
+ char reserved_char[1];
+ int hub6;
+ unsigned short closing_wait; /* time to wait before closing */
+ unsigned short closing_wait2; /* no longer used... */
+ unsigned char *iomem_base;
+ unsigned short iomem_reg_shift;
+ unsigned int port_high;
+ unsigned long iomap_base; /* cookie passed into ioremap */
+ int reserved[1];
+};
+
+typedef struct {
+ int pid;
+ char user[9];
+ char state[4];
+ unsigned long rss;
+ int ppid;
+ unsigned pcpu;
+ unsigned long stime, utime;
+ char *cmd;
+
+ /* basename of executable file in call to exec(2),
+ size from kernel headers */
+ char short_cmd[16];
+} procps_status_t;
+
+/* The passwd structure. */
+// struct passwd
+// {
+// char *pw_name; /* Username. */
+// char *pw_passwd; /* Password. */
+// uid_t pw_uid; /* User ID. */
+// gid_t pw_gid; /* Group ID. */
+// char *pw_gecos; /* Real name. */
+// char *pw_dir; /* Home directory. */
+// char *pw_shell; /* Shell program. */
+// };
+
+#ifndef _PATH_STDPATH
+#define _PATH_STDPATH "/usr/bin:/bin:/usr/sbin:/sbin"
+#endif
+
+#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
+
+#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;
+
+static const int LOG = 0x1;
+static const int CONSOLE = 0x2;
+
+static const int MAYBE_CONSOLE = 0x0;
+#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=/bin/sh",
+ "USER=root",
+ NULL
+};
+
+/* Function prototypes */
+static void delete_init_action(struct init_action *a);
+static int waitfor(const struct init_action *a);
+
+static char * safe_strncpy(char *dst, const char *src, size_t size)
+{
+ dst[size-1] = '\0';
+ return strncpy(dst, src, size-1);
+}
+
+static void loop_forever(void)
+{
+ while (1)
+ sleep(1);
+}
+
+/*
+ * Write all of the supplied buffer out to a file.
+ * This does multiple writes as necessary.
+ * Returns the amount written, or -1 on an error.
+ */
+ssize_t bb_full_write(int fd, const void *buf, size_t len)
+{
+ ssize_t cc;
+ ssize_t total;
+
+ total = 0;
+
+ while (len > 0) {
+ do {
+ cc = write(fd, buf, len);
+ } while (cc < 0 && errno == EINTR);
+
+ if (cc < 0)
+ return cc; /* write() returns -1 on failure. */
+
+ total += cc;
+ buf = ((const char *)buf) + cc;
+ len -= cc;
+ }
+
+ return total;
+}
+
+/* try to open up the specified device */
+static int device_open(const char *device, int mode)
+{
+ int m, f, fd = -1;
+
+ m = mode | O_NONBLOCK;
+
+ /* Retry up to 5 times */
+ for (f = 0; f < 5; f++)
+ if ((fd = open(device, m, 0600)) >= 0)
+ break;
+ if (fd < 0)
+ return fd;
+ /* Reset original flags. */
+ if (m != mode)
+ fcntl(fd, F_SETFL, mode);
+ return fd;
+}
+
+static void bb_error_msg_and_die(const char *s, ...)
+{
+ va_list p;
+
+ va_start(p, s);
+ fflush(stdout);
+ fprintf(stderr, "init: ");
+ vfprintf(stderr, s, p);
+ va_end(p);
+ putc('\n', stderr);
+ exit(1);
+}
+
+/* gets a username given a uid */
+static char * my_getpwuid(char *name, long uid, int bufsize)
+{
+ struct passwd *myuser;
+ static char buffer[256];
+ static struct passwd resultbuf;
+ getpwuid_r(uid, &resultbuf, buffer, sizeof(buffer), &myuser);
+
+ if(bufsize > 0 ) {
+ if(myuser)
+ return safe_strncpy(name, myuser->pw_name, bufsize);
+ else
+ snprintf(name, bufsize, "%ld", uid);
+ } else if(bufsize < 0 && !myuser) {
+ bb_error_msg_and_die("unknown %cid %ld", 'u', uid);
+ }
+ return myuser->pw_name;
+}
+
+static procps_status_t * procps_scan(int save_user_arg0)
+{
+ static struct __dirstream *dir;
+ struct dirent *entry;
+ static procps_status_t ret_status;
+ char *name;
+ int n;
+ char status[32];
+ char buf[1024];
+ FILE *fp;
+ procps_status_t curstatus;
+ int pid;
+ long tasknice;
+ struct stat sb;
+
+ if (!dir) {
+ dir = opendir("/proc");
+ if(!dir) {
+ fflush(stdout);
+ fprintf(stderr, "init: Can't open /proc");
+ }
+ }
+ for(;;) {
+ if((entry = readdir(dir)) == NULL) {
+ closedir(dir);
+ dir = 0;
+ return 0;
+ }
+ name = entry->d_name;
+ if (!(*name >= '0' && *name <= '9'))
+ continue;
+
+ memset(&curstatus, 0, sizeof(procps_status_t));
+ pid = atoi(name);
+ curstatus.pid = pid;
+
+ sprintf(status, "/proc/%d", pid);
+ if(stat(status, &sb))
+ continue;
+ my_getpwuid(curstatus.user, sb.st_uid, sizeof(curstatus.user));
+
+ sprintf(status, "/proc/%d/stat", pid);
+ if((fp = fopen(status, "r")) == NULL)
+ continue;
+ name = fgets(buf, sizeof(buf), fp);
+ fclose(fp);
+ if(name == NULL)
+ continue;
+ name = strrchr(buf, ')'); /* split into "PID (cmd" and "<rest>" */
+ if(name == 0 || name[1] != ' ')
+ continue;
+ *name = 0;
+ sscanf(buf, "%*s (%15c", curstatus.short_cmd);
+ n = sscanf(name+2,
+ "%c %d "
+ "%*s %*s %*s %*s " /* pgrp, session, tty, tpgid */
+ "%*s %*s %*s %*s %*s " /* flags, min_flt, cmin_flt, maj_flt, cmaj_flt */
+ "%lu %lu "
+ "%*s %*s %*s " /* cutime, cstime, priority */
+ "%ld "
+ "%*s %*s %*s " /* timeout, it_real_value, start_time */
+ "%*s " /* vsize */
+ "%ld",
+ curstatus.state, &curstatus.ppid,
+ &curstatus.utime, &curstatus.stime,
+ &tasknice,
+ &curstatus.rss);
+ if(n != 6)
+ continue;
+
+ if (curstatus.rss == 0 && curstatus.state[0] != 'Z')
+ curstatus.state[1] = 'W';
+ else
+ curstatus.state[1] = ' ';
+ if (tasknice < 0)
+ curstatus.state[2] = '<';
+ else if (tasknice > 0)
+ curstatus.state[2] = 'N';
+ else
+ curstatus.state[2] = ' ';
+
+ curstatus.rss *= (getpagesize() >> 10); /* 2**10 = 1kb */
+
+ if(save_user_arg0) {
+ sprintf(status, "/proc/%d/cmdline", pid);
+ if((fp = fopen(status, "r")) == NULL)
+ continue;
+ if((n=fread(buf, 1, sizeof(buf)-1, fp)) > 0) {
+ if(buf[n-1]=='\n')
+ buf[--n] = 0;
+ name = buf;
+ while(n) {
+ if(((unsigned char)*name) < ' ')
+ *name = ' ';
+ name++;
+ n--;
+ }
+ *name = 0;
+ if(buf[0])
+ curstatus.cmd = strdup(buf);
+ /* if NULL it work true also */
+ }
+ fclose(fp);
+ }
+ return memcpy(&ret_status, &curstatus, sizeof(procps_status_t));
+ }
+}
+
+static long* find_pid_by_name( const char* pidName)
+{
+ long* pidList;
+ int i=0;
+ procps_status_t * p;
+
+ pidList = malloc(sizeof(long));
+ while ((p = procps_scan(0)) != 0) {
+ if (strncmp(p->short_cmd, pidName, COMM_LEN-1) == 0) {
+ pidList=realloc( pidList, sizeof(long) * (i+2));
+ pidList[i++]=p->pid;
+ }
+ }
+
+ pidList[i] = i==0 ? -1 : 0;
+ return pidList;
+}
+
+static int kill_init(int sig)
+{
+ /* 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));
+}
+
+const char * const bb_shutdown_format = "\r%s\n";
+
+static char *bb_get_last_path_component(char *path)
+{
+ char *first = path;
+ char *last;
+
+ last = path - 1;
+
+ while (*path) {
+ if ((*path != '/') && (path > ++last)) {
+ last = first = path;
+ }
+ ++path;
+ }
+
+ if (*first == '/') {
+ last = first;
+ }
+ last[1] = 0;
+
+ return first;
+}
+
+
+/* Print a message to the specified device.
+ * Device may be bitwise-or'd from LOG | CONSOLE */
+static inline void messageD(int device, const char *fmt, ...)
+{
+}
+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];
+
+ msg[0] = '\r';
+ va_start(arguments, fmt);
+ l = vsnprintf(msg + 1, sizeof(msg) - 2, fmt, arguments) + 1;
+ va_end(arguments);
+
+ /* Log the message to syslogd */
+ if (device & LOG) {
+ /* don`t out "\r\n" */
+ openlog("init", 0, LOG_DAEMON);
+ syslog(LOG_INFO, "%s", msg);
+ closelog();
+ }
+
+ msg[l++] = '\n';
+ msg[l] = 0;
+
+ 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);
+
+ }
+ }
+}
+
+/* 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);
+}
+
+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));
+ } 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? */
+ 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");
+ } 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;
+
+ /* Block sigchild while forking. */
+ sigemptyset(&nmask);
+ sigaddset(&nmask, SIGCHLD);
+ sigprocmask(SIG_BLOCK, &nmask, &omask);
+
+ if ((pid = vfork()) == 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 = vfork()) < 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) {
+ if (tmp_pid == -1 && errno == ECHILD) {
+ break;
+ }
+ /* FIXME handle other errors */
+ }
+
+ /* 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 = vfork()) < 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] = (char *)DEFAULT_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, msg_memory_exhausted);
+ cmd[0] = cmdpath;
+ } else {
+ cmd[0][0] = '-';
+ strcpy(cmd[0] + 1, s);
+ }
+ }
+
+ /* Log the process name and args */
+ message(LOG, "Starting pid %d, console %s: '%s'",
+ getpid(), a->terminal, cmdpath);
+
+ /* 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 = waitpid(pid,&status,0);
+ if (wpid == pid)
+ 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)
+{
+ 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);
+ }
+ }
+ }
+ }
+}
+
+static void new_init_action(int action, const char *command, const char *cons)
+{
+ struct init_action *new_action, *a, *last;
+
+ 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 = last = init_action_list; a; a = a->next) {
+ /* don't enter action if it's already in the list,
+ * but do overwrite existing actions */
+ if ((strcmp(a->command, command) == 0) &&
+ (strcmp(a->terminal, cons) ==0)) {
+ a->action = action;
+ free(new_action);
+ return;
+ }
+ last = a;
+ }
+ if (last) {
+ last->next = new_action;
+ } else {
+ init_action_list = new_action;
+ }
+ strcpy(new_action->command, command);
+ new_action->action = action;
+ strcpy(new_action->terminal, cons);
+ 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;
+ }
+ }
+}
+
+/* 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)
+{
+ 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 */
+ /* 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", "");
+ /* Prepare to restart init when a HUP is received */
+ new_init_action(RESTART, "/sbin/init", "");
+ /* sysinit */
+ new_init_action(SYSINIT, INIT_SCRIPT, "");
+
+ return;
+ }
+
+ 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;
+}
+
+static void reload_signal(int sig)
+{
+ struct init_action *a, *tmp;
+
+ message(LOG, "Reloading /etc/inittab");
+
+ /* disable old entrys */
+ for (a = init_action_list; a; a = a->next ) {
+ a->action = ONCE;
+ }
+
+ parse_inittab();
+
+ /* remove unused entrys */
+ for (a = init_action_list; a; a = tmp) {
+ tmp = a->next;
+ if (a->action & (ONCE | SYSINIT | WAIT ) &&
+ a->pid == 0 ) {
+ delete_init_action(a);
+ }
+ }
+ run_actions(RESPAWN);
+ return;
+}
+
+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.... */
+ pid = vfork();
+ if (pid == 0) { /* child */
+ reboot(magic);
+ _exit(0);
+ }
+ waitfor(pid);
+}
+
+static void shutdown_inittab_taks(int sig)
+{
+ const char *m;
+ int rb;
+
+ run_actions(SHUTDOWN);
+
+ 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(CONSOLE | LOG, "Requesting system %s", m);
+ /* allow time for last message to reach serial console */
+ sleep(2);
+ init_reboot(rb);
+ while (1)
+ sleep(1);
+}
+
+int main(int argc, char **argv)
+{
+ struct init_action *a;
+ pid_t wpid;
+ int status;
+
+ if (argc > 1 && !strcmp(argv[1], "-q")) {
+ printf("err: %d \"%s\"\n",argc,argv[1]);
+ return kill_init(SIGHUP);
+ }
+
+ /* 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... ");
+
+ /* Install callbacks for SIGTERM signals which will be called by reboot command */
+ signal(SIGTERM, shutdown_inittab_taks);
+
+ /* 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, DEFAULT_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);
+
+ /* 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:
+*/