init/init.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Mini init implementation for busybox
   4  *
   5  * Copyright (C) 1995, 1996 by Bruce Perens <bruce@pixar.com>.
   6  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
   7  * Adjusted by so many folks, it's impossible to keep track.
   8  *
   9  * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
  10  */
  11
  12 #include "busybox.h"
  13 #include <paths.h>
  14 #include <signal.h>
  15 #include <sys/ioctl.h>
  16 #include <sys/wait.h>
  17 #include <sys/reboot.h>
  18
  19 #if ENABLE_SYSLOGD
  20 # include <sys/syslog.h>
  21 #endif
  22
  23 #define INIT_BUFFS_SIZE 256
  24 #define CONSOLE_NAME_SIZE 32
  25 #define MAXENV  16              /* Number of env. vars */
  26
  27 #ifndef _PATH_STDPATH
  28 #define _PATH_STDPATH   "/usr/bin:/bin:/usr/sbin:/sbin"
  29 #endif
  30
  31 #if ENABLE_FEATURE_INIT_COREDUMPS
  32 /*
  33  * When a file named CORE_ENABLE_FLAG_FILE exists, setrlimit is called
  34  * before processes are spawned to set core file size as unlimited.
  35  * This is for debugging only.  Don't use this is production, unless
  36  * you want core dumps lying about....
  37  */
  38 #define CORE_ENABLE_FLAG_FILE "/.init_enable_core"
  39 #include <sys/resource.h>
  40 #endif
  41
  42 #define INITTAB      "/etc/inittab"     /* inittab file location */
  43 #ifndef INIT_SCRIPT
  44 #define INIT_SCRIPT  "/etc/init.d/rcS"  /* Default sysinit script. */
  45 #endif
  46
  47 /* Allowed init action types */
  48 #define SYSINIT     0x001
  49 #define RESPAWN     0x002
  50 #define ASKFIRST    0x004
  51 #define WAIT        0x008
  52 #define ONCE        0x010
  53 #define CTRLALTDEL  0x020
  54 #define SHUTDOWN    0x040
  55 #define RESTART     0x080
  56
  57 /* A mapping between "inittab" action name strings and action type codes. */
  58 struct init_action_type {
  59         const char *name;
  60         int action;
  61 };
  62
  63 static const struct init_action_type actions[] = {
  64         {"sysinit", SYSINIT},
  65         {"respawn", RESPAWN},
  66         {"askfirst", ASKFIRST},
  67         {"wait", WAIT},
  68         {"once", ONCE},
  69         {"ctrlaltdel", CTRLALTDEL},
  70         {"shutdown", SHUTDOWN},
  71         {"restart", RESTART},
  72         {0, 0}
  73 };
  74
  75 /* Set up a linked list of init_actions, to be read from inittab */
  76 struct init_action {
  77         struct init_action *next;
  78         int action;
  79         pid_t pid;
  80         char command[INIT_BUFFS_SIZE];
  81         char terminal[CONSOLE_NAME_SIZE];
  82 };
  83
  84 /* Static variables */
  85 static struct init_action *init_action_list = NULL;
  86
  87 #if !ENABLE_SYSLOGD
  88 static const char *log_console = VC_5;
  89 #endif
  90 #if !ENABLE_DEBUG_INIT
  91 static sig_atomic_t got_cont = 0;
  92 #endif
  93
  94 enum {
  95         L_LOG = 0x1,
  96         L_CONSOLE = 0x2,
  97
  98 #if ENABLE_FEATURE_EXTRA_QUIET
  99         MAYBE_CONSOLE = 0x0,
 100 #else
 101         MAYBE_CONSOLE = L_CONSOLE,
 102 #endif
 103
 104 #ifndef RB_HALT_SYSTEM
 105         RB_HALT_SYSTEM = 0xcdef0123, /* FIXME: this overflows enum */
 106         RB_ENABLE_CAD = 0x89abcdef,
 107         RB_DISABLE_CAD = 0,
 108         RB_POWER_OFF = 0x4321fedc,
 109         RB_AUTOBOOT = 0x01234567,
 110 #endif
 111 };
 112
 113 static const char * const environment[] = {
 114         "HOME=/",
 115         "PATH=" _PATH_STDPATH,
 116         "SHELL=/bin/sh",
 117         "USER=root",
 118         NULL
 119 };
 120
 121 /* Function prototypes */
 122 static void delete_init_action(struct init_action *a);
 123 static int waitfor(const struct init_action *a, pid_t pid);
 124 #if !ENABLE_DEBUG_INIT
 125 static void shutdown_signal(int sig);
 126 #endif
 127
 128 #if !ENABLE_DEBUG_INIT
 129 static void loop_forever(void)
 130 {
 131         while (1)
 132                 sleep(1);
 133 }
 134 #endif
 135
 136 /* Print a message to the specified device.
 137  * Device may be bitwise-or'd from L_LOG | L_CONSOLE */
 138 #if ENABLE_DEBUG_INIT
 139 #define messageD message
 140 #else
 141 #define messageD(...)  do {} while (0)
 142 #endif
 143 static void message(int device, const char *fmt, ...)
 144         __attribute__ ((format(printf, 2, 3)));
 145 static void message(int device, const char *fmt, ...)
 146 {
 147 #if !ENABLE_SYSLOGD
 148         static int log_fd = -1;
 149 #endif
 150
 151         va_list arguments;
 152         int l;
 153         char msg[128];
 154
 155         msg[0] = '\r';
 156         va_start(arguments, fmt);
 157         vsnprintf(msg + 1, sizeof(msg) - 2, fmt, arguments);
 158         va_end(arguments);
 159         msg[sizeof(msg) - 2] = '\0';
 160         l = strlen(msg);
 161
 162 #if ENABLE_SYSLOGD
 163         /* Log the message to syslogd */
 164         if (device & L_LOG) {
 165                 /* don't out "\r" */
 166                 openlog(applet_name, 0, LOG_DAEMON);
 167                 syslog(LOG_INFO, "init: %s", msg + 1);
 168                 closelog();
 169         }
 170         msg[l++] = '\n';
 171         msg[l] = '\0';
 172 #else
 173         msg[l++] = '\n';
 174         msg[l] = '\0';
 175         /* Take full control of the log tty, and never close it.
 176          * It's mine, all mine!  Muhahahaha! */
 177         if (log_fd < 0) {
 178                 if (!log_console) {
 179                         log_fd = 2;
 180                 } else {
 181                         log_fd = device_open(log_console, O_WRONLY | O_NONBLOCK | O_NOCTTY);
 182                         if (log_fd < 0) {
 183                                 bb_error_msg("can't log to %s", log_console);
 184                                 device = L_CONSOLE;
 185                         } else {
 186                                 fcntl(log_fd, F_SETFD, FD_CLOEXEC);
 187                         }
 188                 }
 189         }
 190         if (device & L_LOG) {
 191                 full_write(log_fd, msg, l);
 192                 if (log_fd == 2)
 193                         return; /* don't print dup messages */
 194         }
 195 #endif
 196
 197         if (device & L_CONSOLE) {
 198                 /* Send console messages to console so people will see them. */
 199                 full_write(2, msg, l);
 200         }
 201 }
 202
 203 /* Set terminal settings to reasonable defaults */
 204 static void set_term(void)
 205 {
 206         struct termios tty;
 207
 208         tcgetattr(STDIN_FILENO, &tty);
 209
 210         /* set control chars */
 211         tty.c_cc[VINTR] = 3;    /* C-c */
 212         tty.c_cc[VQUIT] = 28;   /* C-\ */
 213         tty.c_cc[VERASE] = 127; /* C-? */
 214         tty.c_cc[VKILL] = 21;   /* C-u */
 215         tty.c_cc[VEOF] = 4;     /* C-d */
 216         tty.c_cc[VSTART] = 17;  /* C-q */
 217         tty.c_cc[VSTOP] = 19;   /* C-s */
 218         tty.c_cc[VSUSP] = 26;   /* C-z */
 219
 220         /* use line dicipline 0 */
 221         tty.c_line = 0;
 222
 223         /* Make it be sane */
 224         tty.c_cflag &= CBAUD | CBAUDEX | CSIZE | CSTOPB | PARENB | PARODD;
 225         tty.c_cflag |= CREAD | HUPCL | CLOCAL;
 226
 227         /* input modes */
 228         tty.c_iflag = ICRNL | IXON | IXOFF;
 229
 230         /* output modes */
 231         tty.c_oflag = OPOST | ONLCR;
 232
 233         /* local modes */
 234         tty.c_lflag =
 235                 ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN;
 236
 237         tcsetattr(STDIN_FILENO, TCSANOW, &tty);
 238 }
 239
 240 /* From <linux/serial.h> */
 241 struct serial_struct {
 242         int     type;
 243         int     line;
 244         unsigned int    port;
 245         int     irq;
 246         int     flags;
 247         int     xmit_fifo_size;
 248         int     custom_divisor;
 249         int     baud_base;
 250         unsigned short  close_delay;
 251         char    io_type;
 252         char    reserved_char[1];
 253         int     hub6;
 254         unsigned short  closing_wait; /* time to wait before closing */
 255         unsigned short  closing_wait2; /* no longer used... */
 256         unsigned char   *iomem_base;
 257         unsigned short  iomem_reg_shift;
 258         unsigned int    port_high;
 259         unsigned long   iomap_base;     /* cookie passed into ioremap */
 260         int     reserved[1];
 261         /* Paranoia (imagine 64bit kernel overwriting 32bit userspace stack) */
 262         uint32_t bbox_reserved[16];
 263 };
 264 static void console_init(void)
 265 {
 266         struct serial_struct sr;
 267         char *s;
 268
 269         s = getenv("CONSOLE");
 270         if (!s) s = getenv("console");
 271         if (s) {
 272                 int fd = open(s, O_RDWR | O_NONBLOCK | O_NOCTTY);
 273                 if (fd >= 0) {
 274                         dup2(fd, 0);
 275                         dup2(fd, 1);
 276                         dup2(fd, 2);
 277                         while (fd > 2) close(fd--);
 278                 }
 279                 messageD(L_LOG, "console='%s'", s);
 280         }
 281
 282         s = getenv("TERM");
 283         if (ioctl(0, TIOCGSERIAL, &sr) == 0) {
 284                 /* Force the TERM setting to vt102 for serial console --
 285                  * if TERM is set to linux (the default) */
 286                 if (!s || strcmp(s, "linux") == 0)
 287                         putenv((char*)"TERM=vt102");
 288 #if !ENABLE_SYSLOGD
 289                 log_console = NULL;
 290 #endif
 291         } else if (!s)
 292                 putenv((char*)"TERM=linux");
 293 }
 294
 295 static void fixup_argv(int argc, char **argv, const char *new_argv0)
 296 {
 297         int len;
 298
 299         /* Fix up argv[0] to be certain we claim to be init */
 300         len = strlen(argv[0]);
 301         strncpy(argv[0], new_argv0, len);
 302
 303         /* Wipe argv[1]-argv[N] so they don't clutter the ps listing */
 304         len = 1;
 305         while (argc > len) {
 306                 memset(argv[len], 0, strlen(argv[len]));
 307                 len++;
 308         }
 309 }
 310
 311 /* Open the new terminal device */
 312 static void open_stdio_to_tty(const char* tty_name, int fail)
 313 {
 314         /* empty tty_name means "use init's tty", else... */
 315         if (tty_name[0]) {
 316                 close(0);
 317                 if ((device_open(tty_name, O_RDWR)) < 0) {
 318                         dup2(1, 0); /* restore fd #0 - avoid nasty surprises */
 319                         message(L_LOG | L_CONSOLE, "can't open %s: %s",
 320                                 tty_name, strerror(errno));
 321                         if (fail)
 322                                 _exit(1);
 323 #if !ENABLE_DEBUG_INIT
 324                         shutdown_signal(SIGUSR1);
 325 #else
 326                         _exit(2);
 327 #endif
 328                 }
 329         }
 330         close(1);
 331         close(2);
 332         set_term();
 333         dup(0);
 334         dup(0);
 335 }
 336
 337 static pid_t run(const struct init_action *a)
 338 {
 339         int i;
 340         pid_t pid;
 341         char *s, *tmpCmd, *cmdpath;
 342         char *cmd[INIT_BUFFS_SIZE];
 343         char buf[INIT_BUFFS_SIZE + 6];  /* INIT_BUFFS_SIZE+strlen("exec ")+1 */
 344         sigset_t nmask, omask;
 345         static const char press_enter[] =
 346 #ifdef CUSTOMIZED_BANNER
 347 #include CUSTOMIZED_BANNER
 348 #endif
 349                 "\nPlease press Enter to activate this console. ";
 350
 351         /* Block sigchild while forking.  */
 352         sigemptyset(&nmask);
 353         sigaddset(&nmask, SIGCHLD);
 354         sigprocmask(SIG_BLOCK, &nmask, &omask);
 355
 356         if ((pid = fork()) == 0) {
 357                 /* Clean up */
 358                 sigprocmask(SIG_SETMASK, &omask, NULL);
 359
 360                 /* Reset signal handlers that were set by the parent process */
 361                 signal(SIGUSR1, SIG_DFL);
 362                 signal(SIGUSR2, SIG_DFL);
 363                 signal(SIGINT, SIG_DFL);
 364                 signal(SIGTERM, SIG_DFL);
 365                 signal(SIGHUP, SIG_DFL);
 366                 signal(SIGQUIT, SIG_DFL);
 367                 signal(SIGCONT, SIG_DFL);
 368                 signal(SIGSTOP, SIG_DFL);
 369                 signal(SIGTSTP, SIG_DFL);
 370
 371                 /* Create a new session and make ourself the process
 372                  * group leader */
 373                 setsid();
 374
 375                 /* Open the new terminal device */
 376                 open_stdio_to_tty(a->terminal, 1);
 377
 378                 /* If the init Action requires us to wait, then force the
 379                  * supplied terminal to be the controlling tty. */
 380                 if (a->action & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN | RESTART)) {
 381
 382                         /* Now fork off another process to just hang around */
 383                         if ((pid = fork()) < 0) {
 384                                 message(L_LOG | L_CONSOLE, "can't fork");
 385                                 _exit(1);
 386                         }
 387
 388                         if (pid > 0) {
 389
 390                                 /* We are the parent -- wait till the child is done */
 391                                 signal(SIGINT, SIG_IGN);
 392                                 signal(SIGTSTP, SIG_IGN);
 393                                 signal(SIGQUIT, SIG_IGN);
 394                                 signal(SIGCHLD, SIG_DFL);
 395
 396                                 waitfor(NULL, pid);
 397                                 /* See if stealing the controlling tty back is necessary */
 398                                 if (tcgetpgrp(0) != getpid())
 399                                         _exit(0);
 400
 401                                 /* Use a temporary process to steal the controlling tty. */
 402                                 if ((pid = fork()) < 0) {
 403                                         message(L_LOG | L_CONSOLE, "can't fork");
 404                                         _exit(1);
 405                                 }
 406                                 if (pid == 0) {
 407                                         setsid();
 408                                         ioctl(0, TIOCSCTTY, 1);
 409                                         _exit(0);
 410                                 }
 411                                 waitfor(NULL, pid);
 412                                 _exit(0);
 413                         }
 414
 415                         /* Now fall though to actually execute things */
 416                 }
 417
 418                 /* See if any special /bin/sh requiring characters are present */
 419                 if (strpbrk(a->command, "~`!$^&*()=|\\{}[];\"'<>?") != NULL) {
 420                         cmd[0] = (char *)DEFAULT_SHELL;
 421                         cmd[1] = (char*)"-c";
 422                         cmd[2] = strcat(strcpy(buf, "exec "), a->command);
 423                         cmd[3] = NULL;
 424                 } else {
 425                         /* Convert command (char*) into cmd (char**, one word per string) */
 426                         strcpy(buf, a->command);
 427                         s = buf;
 428                         for (tmpCmd = buf, i = 0; (tmpCmd = strsep(&s, " \t")) != NULL;) {
 429                                 if (*tmpCmd != '\0') {
 430                                         cmd[i] = tmpCmd;
 431                                         i++;
 432                                 }
 433                         }
 434                         cmd[i] = NULL;
 435                 }
 436
 437                 cmdpath = cmd[0];
 438
 439                 /*
 440                  * Interactive shells want to see a dash in argv[0].  This
 441                  * typically is handled by login, argv will be setup this
 442                  * way if a dash appears at the front of the command path
 443                  * (like "-/bin/sh").
 444                  */
 445                 if (*cmdpath == '-') {
 446                         /* skip over the dash */
 447                         ++cmdpath;
 448
 449                         /* find the last component in the command pathname */
 450                         s = bb_get_last_path_component(cmdpath);
 451
 452                         /* make a new argv[0] */
 453                         if ((cmd[0] = malloc(strlen(s) + 2)) == NULL) {
 454                                 message(L_LOG | L_CONSOLE, bb_msg_memory_exhausted);
 455                                 cmd[0] = cmdpath;
 456                         } else {
 457                                 cmd[0][0] = '-';
 458                                 strcpy(cmd[0] + 1, s);
 459                         }
 460 #if ENABLE_FEATURE_INIT_SCTTY
 461                         /* Establish this process as session leader and
 462                          * (attempt) to make the tty (if any) a controlling tty.
 463                          */
 464                         setsid();
 465                         ioctl(0, TIOCSCTTY, 0 /*don't steal it*/);
 466 #endif
 467                 }
 468
 469 #if !defined(__UCLIBC__) || defined(__ARCH_HAS_MMU__)
 470                 if (a->action & ASKFIRST) {
 471                         char c;
 472                         /*
 473                          * Save memory by not exec-ing anything large (like a shell)
 474                          * before the user wants it. This is critical if swap is not
 475                          * enabled and the system has low memory. Generally this will
 476                          * be run on the second virtual console, and the first will
 477                          * be allowed to start a shell or whatever an init script
 478                          * specifies.
 479                          */
 480                         messageD(L_LOG, "Waiting for enter to start '%s'"
 481                                                 "(pid %d, tty '%s')\n",
 482                                           cmdpath, getpid(), a->terminal);
 483                         full_write(1, press_enter, sizeof(press_enter) - 1);
 484                         while (read(0, &c, 1) == 1 && c != '\n')
 485                                 ;
 486                 }
 487 #endif
 488
 489                 /* Log the process name and args */
 490                 message(L_LOG, "starting pid %d, tty '%s': '%s'",
 491                                   getpid(), a->terminal, cmdpath);
 492
 493 #if ENABLE_FEATURE_INIT_COREDUMPS
 494                 {
 495                         struct stat sb;
 496                         if (stat(CORE_ENABLE_FLAG_FILE, &sb) == 0) {
 497                                 struct rlimit limit;
 498
 499                                 limit.rlim_cur = RLIM_INFINITY;
 500                                 limit.rlim_max = RLIM_INFINITY;
 501                                 setrlimit(RLIMIT_CORE, &limit);
 502                         }
 503                 }
 504 #endif
 505
 506                 /* Now run it.  The new program will take over this PID,
 507                  * so nothing further in init.c should be run. */
 508                 BB_EXECVP(cmdpath, cmd);
 509
 510                 /* We're still here?  Some error happened. */
 511                 message(L_LOG | L_CONSOLE, "Cannot run '%s': %s",
 512                                 cmdpath, strerror(errno));
 513                 _exit(-1);
 514         }
 515         sigprocmask(SIG_SETMASK, &omask, NULL);
 516         return pid;
 517 }
 518
 519 static int waitfor(const struct init_action *a, pid_t pid)
 520 {
 521         int runpid;
 522         int status, wpid;
 523
 524         runpid = (NULL == a)? pid : run(a);
 525         while (1) {
 526                 wpid = waitpid(runpid, &status, 0);
 527                 if (wpid == runpid)
 528                         break;
 529                 if (wpid == -1 && errno == ECHILD) {
 530                         /* we missed its termination */
 531                         break;
 532                 }
 533                 /* FIXME other errors should maybe trigger an error, but allow
 534                  * the program to continue */
 535         }
 536         return wpid;
 537 }
 538
 539 /* Run all commands of a particular type */
 540 static void run_actions(int action)
 541 {
 542         struct init_action *a, *tmp;
 543
 544         for (a = init_action_list; a; a = tmp) {
 545                 tmp = a->next;
 546                 if (a->action == action) {
 547                         /* a->terminal of "" means "init's console" */
 548                         if (a->terminal[0] && access(a->terminal, R_OK | W_OK)) {
 549                                 delete_init_action(a);
 550                         } else if (a->action & (SYSINIT | WAIT | CTRLALTDEL | SHUTDOWN | RESTART)) {
 551                                 waitfor(a, 0);
 552                                 delete_init_action(a);
 553                         } else if (a->action & ONCE) {
 554                                 run(a);
 555                                 delete_init_action(a);
 556                         } else if (a->action & (RESPAWN | ASKFIRST)) {
 557                                 /* Only run stuff with pid==0.  If they have
 558                                  * a pid, that means it is still running */
 559                                 if (a->pid == 0) {
 560                                         a->pid = run(a);
 561                                 }
 562                         }
 563                 }
 564         }
 565 }
 566
 567 #if !ENABLE_DEBUG_INIT
 568 static void init_reboot(unsigned long magic)
 569 {
 570         pid_t pid;
 571         /* We have to fork here, since the kernel calls do_exit(0) in
 572          * linux/kernel/sys.c, which can cause the machine to panic when
 573          * the init process is killed.... */
 574         pid = vfork();
 575         if (pid == 0) { /* child */
 576                 reboot(magic);
 577                 _exit(0);
 578         }
 579         waitpid(pid, NULL, 0);
 580 }
 581
 582 static void shutdown_system(void)
 583 {
 584         sigset_t block_signals;
 585
 586         /* run everything to be run at "shutdown".  This is done _prior_
 587          * to killing everything, in case people wish to use scripts to
 588          * shut things down gracefully... */
 589         run_actions(SHUTDOWN);
 590
 591         /* first disable all our signals */
 592         sigemptyset(&block_signals);
 593         sigaddset(&block_signals, SIGHUP);
 594         sigaddset(&block_signals, SIGQUIT);
 595         sigaddset(&block_signals, SIGCHLD);
 596         sigaddset(&block_signals, SIGUSR1);
 597         sigaddset(&block_signals, SIGUSR2);
 598         sigaddset(&block_signals, SIGINT);
 599         sigaddset(&block_signals, SIGTERM);
 600         sigaddset(&block_signals, SIGCONT);
 601         sigaddset(&block_signals, SIGSTOP);
 602         sigaddset(&block_signals, SIGTSTP);
 603         sigprocmask(SIG_BLOCK, &block_signals, NULL);
 604
 605         message(L_CONSOLE | L_LOG, "The system is going down NOW!");
 606
 607         /* Allow Ctrl-Alt-Del to reboot system. */
 608         init_reboot(RB_ENABLE_CAD);
 609
 610         /* Send signals to every process _except_ pid 1 */
 611         message(L_CONSOLE | L_LOG, "Sending SIG%s to all processes", "TERM");
 612         kill(-1, SIGTERM);
 613         sync();
 614         sleep(1);
 615
 616         message(L_CONSOLE | L_LOG, "Sending SIG%s to all processes", "KILL");
 617         kill(-1, SIGKILL);
 618         sync();
 619         sleep(1);
 620 }
 621
 622 static void exec_signal(int sig ATTRIBUTE_UNUSED)
 623 {
 624         struct init_action *a, *tmp;
 625         sigset_t unblock_signals;
 626
 627         for (a = init_action_list; a; a = tmp) {
 628                 tmp = a->next;
 629                 if (a->action & RESTART) {
 630                         shutdown_system();
 631
 632                         /* unblock all signals, blocked in shutdown_system() */
 633                         sigemptyset(&unblock_signals);
 634                         sigaddset(&unblock_signals, SIGHUP);
 635                         sigaddset(&unblock_signals, SIGQUIT);
 636                         sigaddset(&unblock_signals, SIGCHLD);
 637                         sigaddset(&unblock_signals, SIGUSR1);
 638                         sigaddset(&unblock_signals, SIGUSR2);
 639                         sigaddset(&unblock_signals, SIGINT);
 640                         sigaddset(&unblock_signals, SIGTERM);
 641                         sigaddset(&unblock_signals, SIGCONT);
 642                         sigaddset(&unblock_signals, SIGSTOP);
 643                         sigaddset(&unblock_signals, SIGTSTP);
 644                         sigprocmask(SIG_UNBLOCK, &unblock_signals, NULL);
 645
 646                         /* Open the new terminal device */
 647                         open_stdio_to_tty(a->terminal, 0);
 648
 649                         messageD(L_CONSOLE | L_LOG, "Trying to re-exec %s", a->command);
 650                         BB_EXECLP(a->command, a->command, NULL);
 651
 652                         message(L_CONSOLE | L_LOG, "Cannot run '%s': %s",
 653                                         a->command, strerror(errno));
 654                         sleep(2);
 655                         init_reboot(RB_HALT_SYSTEM);
 656                         loop_forever();
 657                 }
 658         }
 659 }
 660
 661 static void shutdown_signal(int sig)
 662 {
 663         const char *m;
 664         int rb;
 665
 666         shutdown_system();
 667
 668         m = "halt";
 669         rb = RB_HALT_SYSTEM;
 670         if (sig == SIGTERM) {
 671                 m = "reboot";
 672                 rb = RB_AUTOBOOT;
 673         } else if (sig == SIGUSR2) {
 674                 m = "poweroff";
 675                 rb = RB_POWER_OFF;
 676         }
 677         message(L_CONSOLE | L_LOG, "Requesting system %s", m);
 678         /* allow time for last message to reach serial console */
 679         sleep(2);
 680         init_reboot(rb);
 681         loop_forever();
 682 }
 683
 684 static void ctrlaltdel_signal(int sig ATTRIBUTE_UNUSED)
 685 {
 686         run_actions(CTRLALTDEL);
 687 }
 688
 689 /* The SIGSTOP & SIGTSTP handler */
 690 static void stop_handler(int sig ATTRIBUTE_UNUSED)
 691 {
 692         int saved_errno = errno;
 693
 694         got_cont = 0;
 695         while (!got_cont)
 696                 pause();
 697         got_cont = 0;
 698         errno = saved_errno;
 699 }
 700
 701 /* The SIGCONT handler */
 702 static void cont_handler(int sig ATTRIBUTE_UNUSED)
 703 {
 704         got_cont = 1;
 705 }
 706
 707 #endif  /* !ENABLE_DEBUG_INIT */
 708
 709 static void new_init_action(int action, const char *command, const char *cons)
 710 {
 711         struct init_action *new_action, *a, *last;
 712
 713         if (strcmp(cons, bb_dev_null) == 0 && (action & ASKFIRST))
 714                 return;
 715
 716         /* Append to the end of the list */
 717         for (a = last = init_action_list; a; a = a->next) {
 718                 /* don't enter action if it's already in the list,
 719                  * but do overwrite existing actions */
 720                 if ((strcmp(a->command, command) == 0)
 721                  && (strcmp(a->terminal, cons) == 0)
 722                 ) {
 723                         a->action = action;
 724                         return;
 725                 }
 726                 last = a;
 727         }
 728
 729         new_action = xzalloc(sizeof(struct init_action));
 730         if (last) {
 731                 last->next = new_action;
 732         } else {
 733                 init_action_list = new_action;
 734         }
 735         strcpy(new_action->command, command);
 736         new_action->action = action;
 737         strcpy(new_action->terminal, cons);
 738         messageD(L_LOG | L_CONSOLE, "command='%s' action=%d tty='%s'\n",
 739                 new_action->command, new_action->action, new_action->terminal);
 740 }
 741
 742 static void delete_init_action(struct init_action *action)
 743 {
 744         struct init_action *a, *b = NULL;
 745
 746         for (a = init_action_list; a; b = a, a = a->next) {
 747                 if (a == action) {
 748                         if (b == NULL) {
 749                                 init_action_list = a->next;
 750                         } else {
 751                                 b->next = a->next;
 752                         }
 753                         free(a);
 754                         break;
 755                 }
 756         }
 757 }
 758
 759 /* NOTE that if CONFIG_FEATURE_USE_INITTAB is NOT defined,
 760  * then parse_inittab() simply adds in some default
 761  * actions(i.e., runs INIT_SCRIPT and then starts a pair
 762  * of "askfirst" shells).  If CONFIG_FEATURE_USE_INITTAB
 763  * _is_ defined, but /etc/inittab is missing, this
 764  * results in the same set of default behaviors.
 765  */
 766 static void parse_inittab(void)
 767 {
 768 #if ENABLE_FEATURE_USE_INITTAB
 769         FILE *file;
 770         char buf[INIT_BUFFS_SIZE], lineAsRead[INIT_BUFFS_SIZE];
 771         char tmpConsole[CONSOLE_NAME_SIZE];
 772         char *id, *runlev, *action, *command, *eol;
 773         const struct init_action_type *a = actions;
 774
 775         file = fopen(INITTAB, "r");
 776         if (file == NULL) {
 777                 /* No inittab file -- set up some default behavior */
 778 #endif
 779                 /* Reboot on Ctrl-Alt-Del */
 780                 new_init_action(CTRLALTDEL, "reboot", "");
 781                 /* Umount all filesystems on halt/reboot */
 782                 new_init_action(SHUTDOWN, "umount -a -r", "");
 783                 /* Swapoff on halt/reboot */
 784                 if (ENABLE_SWAPONOFF) new_init_action(SHUTDOWN, "swapoff -a", "");
 785                 /* Prepare to restart init when a HUP is received */
 786                 new_init_action(RESTART, "init", "");
 787                 /* Askfirst shell on tty1-4 */
 788                 new_init_action(ASKFIRST, bb_default_login_shell, "");
 789                 new_init_action(ASKFIRST, bb_default_login_shell, VC_2);
 790                 new_init_action(ASKFIRST, bb_default_login_shell, VC_3);
 791                 new_init_action(ASKFIRST, bb_default_login_shell, VC_4);
 792                 /* sysinit */
 793                 new_init_action(SYSINIT, INIT_SCRIPT, "");
 794
 795                 return;
 796 #if ENABLE_FEATURE_USE_INITTAB
 797         }
 798
 799         while (fgets(buf, INIT_BUFFS_SIZE, file) != NULL) {
 800                 /* Skip leading spaces */
 801                 for (id = buf; *id == ' ' || *id == '\t'; id++);
 802
 803                 /* Skip the line if it's a comment */
 804                 if (*id == '#' || *id == '\n')
 805                         continue;
 806
 807                 /* Trim the trailing \n */
 808                 //XXX: chomp() ?
 809                 eol = strrchr(id, '\n');
 810                 if (eol != NULL)
 811                         *eol = '\0';
 812
 813                 /* Keep a copy around for posterity's sake (and error msgs) */
 814                 strcpy(lineAsRead, buf);
 815
 816                 /* Separate the ID field from the runlevels */
 817                 runlev = strchr(id, ':');
 818                 if (runlev == NULL || *(runlev + 1) == '\0') {
 819                         message(L_LOG | L_CONSOLE, "Bad inittab entry: %s", lineAsRead);
 820                         continue;
 821                 } else {
 822                         *runlev = '\0';
 823                         ++runlev;
 824                 }
 825
 826                 /* Separate the runlevels from the action */
 827                 action = strchr(runlev, ':');
 828                 if (action == NULL || *(action + 1) == '\0') {
 829                         message(L_LOG | L_CONSOLE, "Bad inittab entry: %s", lineAsRead);
 830                         continue;
 831                 } else {
 832                         *action = '\0';
 833                         ++action;
 834                 }
 835
 836                 /* Separate the action from the command */
 837                 command = strchr(action, ':');
 838                 if (command == NULL || *(command + 1) == '\0') {
 839                         message(L_LOG | L_CONSOLE, "Bad inittab entry: %s", lineAsRead);
 840                         continue;
 841                 } else {
 842                         *command = '\0';
 843                         ++command;
 844                 }
 845
 846                 /* Ok, now process it */
 847                 for (a = actions; a->name != 0; a++) {
 848                         if (strcmp(a->name, action) == 0) {
 849                                 if (*id != '\0') {
 850                                         if(strncmp(id, "/dev/", 5) == 0)
 851                                                 id += 5;
 852                                         strcpy(tmpConsole, "/dev/");
 853                                         safe_strncpy(tmpConsole + 5, id,
 854                                                 sizeof(tmpConsole) - 5);
 855                                         id = tmpConsole;
 856                                 }
 857                                 new_init_action(a->action, command, id);
 858                                 break;
 859                         }
 860                 }
 861                 if (a->name == 0) {
 862                         /* Choke on an unknown action */
 863                         message(L_LOG | L_CONSOLE, "Bad inittab entry: %s", lineAsRead);
 864                 }
 865         }
 866         fclose(file);
 867 #endif /* FEATURE_USE_INITTAB */
 868 }
 869
 870 #if ENABLE_FEATURE_USE_INITTAB
 871 static void reload_signal(int sig ATTRIBUTE_UNUSED)
 872 {
 873         struct init_action *a, *tmp;
 874
 875         message(L_LOG, "reloading /etc/inittab");
 876
 877         /* disable old entrys */
 878         for (a = init_action_list; a; a = a->next ) {
 879                 a->action = ONCE;
 880         }
 881
 882         parse_inittab();
 883
 884         /* remove unused entrys */
 885         for (a = init_action_list; a; a = tmp) {
 886                 tmp = a->next;
 887                 if (a->action & (ONCE | SYSINIT | WAIT ) &&
 888                                 a->pid == 0 ) {
 889                         delete_init_action(a);
 890                 }
 891         }
 892         run_actions(RESPAWN);
 893 }
 894 #endif  /* FEATURE_USE_INITTAB */
 895
 896 int init_main(int argc, char **argv);
 897 int init_main(int argc, char **argv)
 898 {
 899         struct init_action *a;
 900         pid_t wpid;
 901
 902         die_sleep = 30 * 24*60*60; /* if xmalloc will ever die... */
 903
 904         if (argc > 1 && !strcmp(argv[1], "-q")) {
 905                 return kill(1, SIGHUP);
 906         }
 907 #if !ENABLE_DEBUG_INIT
 908         /* Expect to be invoked as init with PID=1 or be invoked as linuxrc */
 909         if (getpid() != 1
 910          && (!ENABLE_FEATURE_INITRD || !strstr(applet_name, "linuxrc"))
 911         ) {
 912                 bb_show_usage();
 913         }
 914         /* Set up sig handlers  -- be sure to
 915          * clear all of these in run() */
 916         signal(SIGHUP, exec_signal);
 917         signal(SIGQUIT, exec_signal);
 918         signal(SIGUSR1, shutdown_signal);
 919         signal(SIGUSR2, shutdown_signal);
 920         signal(SIGINT, ctrlaltdel_signal);
 921         signal(SIGTERM, shutdown_signal);
 922         signal(SIGCONT, cont_handler);
 923         signal(SIGSTOP, stop_handler);
 924         signal(SIGTSTP, stop_handler);
 925
 926         /* Turn off rebooting via CTL-ALT-DEL -- we get a
 927          * SIGINT on CAD so we can shut things down gracefully... */
 928         init_reboot(RB_DISABLE_CAD);
 929 #endif
 930
 931         /* Figure out where the default console should be */
 932         console_init();
 933         set_term();
 934         chdir("/");
 935         setsid();
 936         {
 937                 const char * const *e;
 938                 /* Make sure environs is set to something sane */
 939                 for (e = environment; *e; e++)
 940                         putenv((char *) *e);
 941         }
 942
 943         if (argc > 1) setenv("RUNLEVEL", argv[1], 1);
 944
 945         /* Hello world */
 946         message(MAYBE_CONSOLE | L_LOG, "init started: %s", bb_msg_full_version);
 947
 948         /* Make sure there is enough memory to do something useful. */
 949         if (ENABLE_SWAPONOFF) {
 950                 struct sysinfo info;
 951
 952                 if (!sysinfo(&info) &&
 953                         (info.mem_unit ? : 1) * (long long)info.totalram < 1024*1024)
 954                 {
 955                         message(L_CONSOLE, "Low memory, forcing swapon");
 956                         /* swapon -a requires /proc typically */
 957                         new_init_action(SYSINIT, "mount -t proc proc /proc", "");
 958                         /* Try to turn on swap */
 959                         new_init_action(SYSINIT, "swapon -a", "");
 960                         run_actions(SYSINIT);   /* wait and removing */
 961                 }
 962         }
 963
 964         /* Check if we are supposed to be in single user mode */
 965         if (argc > 1
 966          && (!strcmp(argv[1], "single") || !strcmp(argv[1], "-s") || LONE_CHAR(argv[1], '1'))
 967         ) {
 968                 /* Start a shell on console */
 969                 new_init_action(RESPAWN, bb_default_login_shell, "");
 970         } else {
 971                 /* Not in single user mode -- see what inittab says */
 972
 973                 /* NOTE that if CONFIG_FEATURE_USE_INITTAB is NOT defined,
 974                  * then parse_inittab() simply adds in some default
 975                  * actions(i.e., runs INIT_SCRIPT and then starts a pair
 976                  * of "askfirst" shells */
 977                 parse_inittab();
 978         }
 979
 980 #if ENABLE_SELINUX
 981         if (getenv("SELINUX_INIT") == NULL) {
 982                 int enforce = 0;
 983
 984                 putenv("SELINUX_INIT=YES");
 985                 if (selinux_init_load_policy(&enforce) == 0) {
 986                         BB_EXECVP(argv[0], argv);
 987                 } else if (enforce > 0) {
 988                         /* SELinux in enforcing mode but load_policy failed */
 989                         /* At this point, we probably can't open /dev/console, so log() won't work */
 990                         message(L_CONSOLE, "Cannot load SELinux Policy. "
 991                                 "Machine is in enforcing mode. Halting now.");
 992                         exit(1);
 993                 }
 994         }
 995 #endif /* CONFIG_SELINUX */
 996
 997         /* Make the command line just say "init"  -- thats all, nothing else */
 998         fixup_argv(argc, argv, "init");
 999
1000         /* Now run everything that needs to be run */
1001
1002         /* First run the sysinit command */
1003         run_actions(SYSINIT);
1004
1005         /* Next run anything that wants to block */
1006         run_actions(WAIT);
1007
1008         /* Next run anything to be run only once */
1009         run_actions(ONCE);
1010
1011 #if ENABLE_FEATURE_USE_INITTAB
1012         /* Redefine SIGHUP to reread /etc/inittab */
1013         signal(SIGHUP, reload_signal);
1014 #else
1015         signal(SIGHUP, SIG_IGN);
1016 #endif /* FEATURE_USE_INITTAB */
1017
1018         /* Now run the looping stuff for the rest of forever */
1019         while (1) {
1020                 /* run the respawn stuff */
1021                 run_actions(RESPAWN);
1022
1023                 /* run the askfirst stuff */
1024                 run_actions(ASKFIRST);
1025
1026                 /* Don't consume all CPU time -- sleep a bit */
1027                 sleep(1);
1028
1029                 /* Wait for a child process to exit */
1030                 wpid = wait(NULL);
1031                 while (wpid > 0) {
1032                         /* Find out who died and clean up their corpse */
1033                         for (a = init_action_list; a; a = a->next) {
1034                                 if (a->pid == wpid) {
1035                                         /* Set the pid to 0 so that the process gets
1036                                          * restarted by run_actions() */
1037                                         a->pid = 0;
1038                                         message(L_LOG, "process '%s' (pid %d) exited. "
1039                                                         "Scheduling it for restart.",
1040                                                         a->command, wpid);
1041                                 }
1042                         }
1043                         /* see if anyone else is waiting to be reaped */
1044                         wpid = waitpid(-1, NULL, WNOHANG);
1045                 }
1046         }
1047 }