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