sbin/init/init.c

   1 /*      $NetBSD: init.c,v 1.97 2009/01/18 00:25:13 lukem Exp $  */
   2
   3 /*-
   4  * Copyright (c) 1991, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Donn Seeley at Berkeley Software Design, Inc.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include <sys/cdefs.h>
  36 #ifndef lint
  37 __COPYRIGHT("@(#) Copyright (c) 1991, 1993\
  38  The Regents of the University of California.  All rights reserved.");
  39 #endif /* not lint */
  40
  41 #ifndef lint
  42 #if 0
  43 static char sccsid[] = "@(#)init.c      8.2 (Berkeley) 4/28/95";
  44 #else
  45 __RCSID("$NetBSD: init.c,v 1.97 2009/01/18 00:25:13 lukem Exp $");
  46 #endif
  47 #endif /* not lint */
  48
  49 #include <sys/param.h>
  50 #include <sys/sysctl.h>
  51 #include <sys/wait.h>
  52 #include <sys/mman.h>
  53 #include <sys/stat.h>
  54 #include <sys/mount.h>
  55 #include <machine/cpu.h>
  56
  57 #include <db.h>
  58 #include <errno.h>
  59 #include <fcntl.h>
  60 #include <signal.h>
  61 #include <stdio.h>
  62 #include <stdlib.h>
  63 #include <string.h>
  64 #include <syslog.h>
  65 #include <time.h>
  66 #include <ttyent.h>
  67 #include <unistd.h>
  68 #include <util.h>
  69 #include <paths.h>
  70 #include <err.h>
  71
  72 #include <stdarg.h>
  73
  74 #ifdef SECURE
  75 #include <pwd.h>
  76 #endif
  77
  78 #include "pathnames.h"
  79
  80 #define XSTR(x) #x
  81 #define STR(x) XSTR(x)
  82
  83 /*
  84  * Sleep times; used to prevent thrashing.
  85  */
  86 #define GETTY_SPACING            5      /* N secs minimum getty spacing */
  87 #define GETTY_SLEEP             30      /* sleep N secs after spacing problem */
  88 #define WINDOW_WAIT              3      /* wait N secs after starting window */
  89 #define STALL_TIMEOUT           30      /* wait N secs after warning */
  90 #define DEATH_WATCH             10      /* wait N secs for procs to die */
  91
  92 const struct timespec dtrtime = {.tv_sec = 0, .tv_nsec = 250000};
  93
  94 #if defined(RESCUEDIR)
  95 #define INIT_BSHELL     RESCUEDIR "/sh"
  96 #define INIT_MOUNT_MFS  RESCUEDIR "/mount_mfs"
  97 #define INIT_PATH       RESCUEDIR ":" _PATH_STDPATH
  98 #else
  99 #define INIT_BSHELL     _PATH_BSHELL
 100 #define INIT_MOUNT_MFS  "/sbin/mount_mfs"
 101 #define INIT_PATH       _PATH_STDPATH
 102 #endif
 103
 104 int main(int, char *[]);
 105
 106 void handle(sig_t, ...);
 107 void delset(sigset_t *, ...);
 108
 109 void stall(const char *, ...)
 110     __attribute__((__format__(__printf__,1,2)));
 111 void warning(const char *, ...)
 112     __attribute__((__format__(__printf__,1,2)));
 113 void emergency(const char *, ...)
 114     __attribute__((__format__(__printf__,1,2)));
 115 void disaster(int);
 116 void badsys(int);
 117
 118 /*
 119  * We really need a recursive typedef...
 120  * The following at least guarantees that the return type of (*state_t)()
 121  * is sufficiently wide to hold a function pointer.
 122  */
 123 typedef long (*state_func_t)(void);
 124 typedef state_func_t (*state_t)(void);
 125
 126 #define DEATH           'd'
 127 #define SINGLE_USER     's'
 128 #define RUNCOM          'r'
 129 #define READ_TTYS       't'
 130 #define MULTI_USER      'm'
 131 #define CLEAN_TTYS      'T'
 132 #define CATATONIA       'c'
 133
 134 state_func_t single_user(void);
 135 state_func_t runcom(void);
 136 state_func_t read_ttys(void);
 137 state_func_t multi_user(void);
 138 state_func_t clean_ttys(void);
 139 state_func_t catatonia(void);
 140 state_func_t death(void);
 141
 142 enum { AUTOBOOT, FASTBOOT } runcom_mode = AUTOBOOT;
 143
 144 void transition(state_t);
 145 void setctty(const char *);
 146
 147 typedef struct init_session {
 148         int     se_index;               /* index of entry in ttys file */
 149         pid_t   se_process;             /* controlling process */
 150         struct timeval  se_started;     /* used to avoid thrashing */
 151         int     se_flags;               /* status of session */
 152 #define SE_SHUTDOWN     0x1             /* session won't be restarted */
 153 #define SE_PRESENT      0x2             /* session is in /etc/ttys */
 154         char    *se_device;             /* filename of port */
 155         char    *se_getty;              /* what to run on that port */
 156         char    **se_getty_argv;        /* pre-parsed argument array */
 157         char    *se_window;             /* window system (started only once) */
 158         char    **se_window_argv;       /* pre-parsed argument array */
 159         struct  init_session *se_prev;
 160         struct  init_session *se_next;
 161 } session_t;
 162
 163 void free_session(session_t *);
 164 session_t *new_session(session_t *, int, struct ttyent *);
 165 session_t *sessions;
 166
 167 char **construct_argv(char *);
 168 void start_window_system(session_t *);
 169 void collect_child(pid_t, int);
 170 pid_t start_getty(session_t *);
 171 void transition_handler(int);
 172 void alrm_handler(int);
 173 void setsecuritylevel(int);
 174 int getsecuritylevel(void);
 175 int setupargv(session_t *, struct ttyent *);
 176 int clang;
 177
 178 int start_session_db(void);
 179 void add_session(session_t *);
 180 void del_session(session_t *);
 181 session_t *find_session(pid_t);
 182 DB *session_db;
 183
 184 int do_setttyent(void);
 185
 186 #ifndef LETS_GET_SMALL
 187 state_t requested_transition = runcom;
 188
 189 void clear_session_logs(session_t *, int);
 190 state_func_t runetcrc(int);
 191 #ifdef SUPPORT_UTMPX
 192 static struct timeval boot_time;
 193 state_t current_state = death;
 194 static void session_utmpx(const session_t *, int);
 195 static void make_utmpx(const char *, const char *, int, pid_t,
 196     const struct timeval *, int);
 197 static char get_runlevel(const state_t);
 198 static void utmpx_set_runlevel(char, char);
 199 #endif
 200
 201 #ifdef CHROOT
 202 int did_multiuser_chroot = 0;
 203 char rootdir[PATH_MAX];
 204 int shouldchroot(void);
 205 int createsysctlnode(void);
 206 #endif /* CHROOT */
 207
 208 #else /* LETS_GET_SMALL */
 209 state_t requested_transition = single_user;
 210 #endif /* !LETS_GET_SMALL */
 211
 212 #ifdef MFS_DEV_IF_NO_CONSOLE
 213
 214 static int mfs_dev(void);
 215
 216 #endif
 217
 218 /*
 219  * The mother of all processes.
 220  */
 221 int
 222 main(int argc, char **argv)
 223 {
 224         struct sigaction sa;
 225         sigset_t mask;
 226 #ifndef LETS_GET_SMALL
 227         int c;
 228
 229 #ifdef SUPPORT_UTMPX
 230         (void)gettimeofday(&boot_time, NULL);
 231 #endif /* SUPPORT_UTMPX */
 232
 233         /* Dispose of random users. */
 234         if (getuid() != 0) {
 235                 errno = EPERM;
 236                 err(1, NULL);
 237         }
 238
 239         /* System V users like to reexec init. */
 240         if (getpid() != 1)
 241                 errx(1, "already running");
 242 #endif
 243
 244         /*
 245          * Create an initial session.
 246          */
 247         if (setsid() < 0)
 248                 warn("initial setsid() failed");
 249
 250         /*
 251          * Establish an initial user so that programs running
 252          * single user do not freak out and die (like passwd).
 253          */
 254         if (setlogin("root") < 0)
 255                 warn("setlogin() failed");
 256
 257
 258 #ifdef MFS_DEV_IF_NO_CONSOLE
 259         if (mfs_dev() == -1)
 260                 requested_transition = single_user;
 261 #endif
 262
 263 #ifndef LETS_GET_SMALL
 264         /*
 265          * Note that this does NOT open a file...
 266          * Does 'init' deserve its own facility number?
 267          */
 268         openlog("init", LOG_CONS, LOG_AUTH);
 269 #endif /* LETS_GET_SMALL */
 270
 271
 272 #ifndef LETS_GET_SMALL
 273         /*
 274          * This code assumes that we always get arguments through flags,
 275          * never through bits set in some random machine register.
 276          */
 277         while ((c = getopt(argc, argv, "sf")) != -1)
 278                 switch (c) {
 279                 case 's':
 280                         requested_transition = single_user;
 281                         break;
 282                 case 'f':
 283                         runcom_mode = FASTBOOT;
 284                         break;
 285                 default:
 286                         warning("unrecognized flag `%c'", c);
 287                         break;
 288                 }
 289
 290         if (optind != argc)
 291                 warning("ignoring excess arguments");
 292 #else /* LETS_GET_SMALL */
 293         requested_transition = single_user;
 294 #endif /* LETS_GET_SMALL */
 295
 296         /*
 297          * We catch or block signals rather than ignore them,
 298          * so that they get reset on exec.
 299          */
 300         handle(badsys, SIGSYS, 0);
 301         handle(disaster, SIGABRT, SIGFPE, SIGILL, SIGSEGV,
 302                SIGBUS, SIGXCPU, SIGXFSZ, 0);
 303         handle(transition_handler, SIGHUP, SIGTERM, SIGTSTP, 0);
 304         handle(alrm_handler, SIGALRM, 0);
 305         (void)sigfillset(&mask);
 306         delset(&mask, SIGABRT, SIGFPE, SIGILL, SIGSEGV, SIGBUS, SIGSYS,
 307             SIGXCPU, SIGXFSZ, SIGHUP, SIGTERM, SIGTSTP, SIGALRM, 0);
 308         (void)sigprocmask(SIG_SETMASK, &mask, NULL);
 309         (void)sigemptyset(&sa.sa_mask);
 310         sa.sa_flags = 0;
 311         sa.sa_handler = SIG_IGN;
 312         (void)sigaction(SIGTTIN, &sa, NULL);
 313         (void)sigaction(SIGTTOU, &sa, NULL);
 314
 315         /*
 316          * Paranoia.
 317          */
 318         (void)close(0);
 319         (void)close(1);
 320         (void)close(2);
 321
 322 #if !defined(LETS_GET_SMALL) && defined(CHROOT)
 323         /* Create "init.root" sysctl node. */
 324         (void)createsysctlnode();
 325 #endif /* !LETS_GET_SMALL && CHROOT*/
 326
 327         /*
 328          * Start the state machine.
 329          */
 330         transition(requested_transition);
 331
 332         /*
 333          * Should never reach here.
 334          */
 335         return 1;
 336 }
 337
 338 /*
 339  * Associate a function with a signal handler.
 340  */
 341 void
 342 handle(sig_t handler, ...)
 343 {
 344         int sig;
 345         struct sigaction sa;
 346         sigset_t mask_everything;
 347         va_list ap;
 348
 349         va_start(ap, handler);
 350
 351         sa.sa_handler = handler;
 352         (void)sigfillset(&mask_everything);
 353
 354         while ((sig = va_arg(ap, int)) != 0) {
 355                 sa.sa_mask = mask_everything;
 356                 /* XXX SA_RESTART? */
 357                 sa.sa_flags = sig == SIGCHLD ? SA_NOCLDSTOP : 0;
 358                 (void)sigaction(sig, &sa, NULL);
 359         }
 360         va_end(ap);
 361 }
 362
 363 /*
 364  * Delete a set of signals from a mask.
 365  */
 366 void
 367 delset(sigset_t *maskp, ...)
 368 {
 369         int sig;
 370         va_list ap;
 371
 372         va_start(ap, maskp);
 373
 374         while ((sig = va_arg(ap, int)) != 0)
 375                 (void)sigdelset(maskp, sig);
 376         va_end(ap);
 377 }
 378
 379 #if 0   /* Enable to get error messages from init ! */
 380 #define vsyslog(level, fmt, ap) print_console(level, fmt, ap)
 381 #define closelog()
 382
 383 static void
 384 print_console(int level, const char *message, va_list ap)
 385 {
 386         /*
 387          * XXX: syslog seems to just plain not work in console-only
 388          * XXX: situation... that should be fixed.  Let's leave this
 389          * XXX: note + code here in case someone gets in trouble and
 390          * XXX: wants to debug. -- Jachym Holecek <freza@liberouter.org>
 391          */
 392         char errbuf[1024];
 393         int fd, len;
 394
 395         /* We can't do anything on errors, anyway... */
 396         fd = open(_PATH_CONSOLE, O_WRONLY);
 397         if (fd == -1)
 398                 return ;
 399
 400         /* %m will get lost... */
 401         len = vsnprintf(errbuf, sizeof(errbuf), message, ap);
 402         (void)write(fd, (void *)errbuf, len);
 403         (void)close(fd);
 404 }
 405 #endif
 406
 407 /*
 408  * Log a message and sleep for a while (to give someone an opportunity
 409  * to read it and to save log or hardcopy output if the problem is chronic).
 410  * NB: should send a message to the session logger to avoid blocking.
 411  */
 412 void
 413 stall(const char *message, ...)
 414 {
 415         va_list ap;
 416
 417         va_start(ap, message);
 418         vsyslog(LOG_ALERT, message, ap);
 419         va_end(ap);
 420         closelog();
 421         (void)sleep(STALL_TIMEOUT);
 422 }
 423
 424 /*
 425  * Like stall(), but doesn't sleep.
 426  * If cpp had variadic macros, the two functions could be #defines for another.
 427  * NB: should send a message to the session logger to avoid blocking.
 428  */
 429 void
 430 warning(const char *message, ...)
 431 {
 432         va_list ap;
 433
 434         va_start(ap, message);
 435         vsyslog(LOG_ALERT, message, ap);
 436         va_end(ap);
 437         closelog();
 438 }
 439
 440 /*
 441  * Log an emergency message.
 442  * NB: should send a message to the session logger to avoid blocking.
 443  */
 444 void
 445 emergency(const char *message, ...)
 446 {
 447         va_list ap;
 448
 449         va_start(ap, message);
 450         vsyslog(LOG_EMERG, message, ap);
 451         va_end(ap);
 452         closelog();
 453 }
 454
 455 /*
 456  * Catch a SIGSYS signal.
 457  *
 458  * These may arise if a system does not support sysctl.
 459  * We tolerate up to 25 of these, then throw in the towel.
 460  */
 461 void
 462 badsys(int sig)
 463 {
 464         static int badcount = 0;
 465
 466         if (badcount++ < 25)
 467                 return;
 468         disaster(sig);
 469 }
 470
 471 /*
 472  * Catch an unexpected signal.
 473  */
 474 void
 475 disaster(int sig)
 476 {
 477
 478         emergency("fatal signal: %s", strsignal(sig));
 479         (void)sleep(STALL_TIMEOUT);
 480         _exit(sig);             /* reboot */
 481 }
 482
 483 /*
 484  * Get the security level of the kernel.
 485  */
 486 int
 487 getsecuritylevel(void)
 488 {
 489 #ifdef KERN_SECURELVL
 490         int name[2], curlevel;
 491         size_t len;
 492
 493         name[0] = CTL_KERN;
 494         name[1] = KERN_SECURELVL;
 495         len = sizeof curlevel;
 496         if (sysctl(name, 2, &curlevel, &len, NULL, 0) == -1) {
 497                 emergency("cannot get kernel security level: %m");
 498                 return -1;
 499         }
 500         return curlevel;
 501 #else
 502         return -1;
 503 #endif
 504 }
 505
 506 /*
 507  * Set the security level of the kernel.
 508  */
 509 void
 510 setsecuritylevel(int newlevel)
 511 {
 512 #ifdef KERN_SECURELVL
 513         int name[2], curlevel;
 514
 515         curlevel = getsecuritylevel();
 516         if (newlevel == curlevel)
 517                 return;
 518         name[0] = CTL_KERN;
 519         name[1] = KERN_SECURELVL;
 520         if (sysctl(name, 2, NULL, NULL, &newlevel, sizeof newlevel) == -1) {
 521                 emergency("cannot change kernel security level from"
 522                     " %d to %d: %m", curlevel, newlevel);
 523                 return;
 524         }
 525 #ifdef SECURE
 526         warning("kernel security level changed from %d to %d",
 527             curlevel, newlevel);
 528 #endif
 529 #endif
 530 }
 531
 532 /*
 533  * Change states in the finite state machine.
 534  * The initial state is passed as an argument.
 535  */
 536 void
 537 transition(state_t s)
 538 {
 539
 540         if (s == NULL)
 541                 return;
 542         for (;;) {
 543 #ifdef SUPPORT_UTMPX
 544 #ifndef LETS_GET_SMALL
 545                 utmpx_set_runlevel(get_runlevel(current_state),
 546                     get_runlevel(s));
 547                 current_state = s;
 548 #endif
 549 #endif
 550                 s = (state_t)(*s)();
 551         }
 552 }
 553
 554 #ifndef LETS_GET_SMALL
 555 /*
 556  * Close out the accounting files for a login session.
 557  * NB: should send a message to the session logger to avoid blocking.
 558  */
 559 void
 560 clear_session_logs(session_t *sp, int status)
 561 {
 562 #if defined(SUPPORT_UTMP) || defined(SUPPORT_UTMPX)
 563         char *line = sp->se_device + sizeof(_PATH_DEV) - 1;
 564 #endif
 565
 566 #ifdef SUPPORT_UTMPX
 567         if (logoutx(line, status, DEAD_PROCESS))
 568                 logwtmpx(line, "", "", status, DEAD_PROCESS);
 569 #endif
 570 #ifdef SUPPORT_UTMP
 571         if (logout(line))
 572                 logwtmp(line, "", "");
 573 #endif
 574 }
 575 #endif
 576
 577 /*
 578  * Start a session and allocate a controlling terminal.
 579  * Only called by children of init after forking.
 580  */
 581 void
 582 setctty(const char *name)
 583 {
 584         int fd;
 585
 586         (void)revoke(name);
 587         (void)nanosleep(&dtrtime, NULL);        /* leave DTR low for a bit */
 588         if ((fd = open(name, O_RDWR)) == -1) {
 589                 stall("can't open %s: %m", name);
 590                 _exit(1);
 591         }
 592         if (login_tty(fd) == -1) {
 593                 stall("can't get %s for controlling terminal: %m", name);
 594                 _exit(2);
 595         }
 596 }
 597
 598 /*
 599  * Bring the system up single user.
 600  */
 601 state_func_t
 602 single_user(void)
 603 {
 604         pid_t pid, wpid;
 605         int status;
 606         int from_securitylevel;
 607         sigset_t mask;
 608         struct sigaction sa, satstp, sahup;
 609 #ifdef ALTSHELL
 610         const char *shell = INIT_BSHELL;
 611 #endif
 612         const char *argv[2];
 613 #ifdef SECURE
 614         struct ttyent *typ;
 615         struct passwd *pp;
 616         char *clear, *password;
 617 #endif
 618 #ifdef ALTSHELL
 619         char altshell[128];
 620 #endif /* ALTSHELL */
 621
 622 #if !defined(LETS_GET_SMALL) && defined(CHROOT)
 623         /* Clear previous idea, just in case. */
 624         did_multiuser_chroot = 0;
 625 #endif /* !LETS_GET_SMALL && CHROOT */
 626
 627         /*
 628          * If the kernel is in secure mode, downgrade it to insecure mode.
 629          */
 630         from_securitylevel = getsecuritylevel();
 631         if (from_securitylevel > 0)
 632                 setsecuritylevel(0);
 633
 634         (void)sigemptyset(&sa.sa_mask);
 635         sa.sa_flags = 0;
 636         sa.sa_handler = SIG_IGN;
 637         (void)sigaction(SIGTSTP, &sa, &satstp);
 638         (void)sigaction(SIGHUP, &sa, &sahup);
 639         if ((pid = fork()) == 0) {
 640                 /*
 641                  * Start the single user session.
 642                  */
 643                 if (access(_PATH_CONSTTY, F_OK) == 0)
 644                         setctty(_PATH_CONSTTY);
 645                 else
 646                         setctty(_PATH_CONSOLE);
 647
 648 #ifdef SECURE
 649                 /*
 650                  * Check the root password.
 651                  * We don't care if the console is 'on' by default;
 652                  * it's the only tty that can be 'off' and 'secure'.
 653                  */
 654                 typ = getttynam("console");
 655                 pp = getpwnam("root");
 656                 if (typ && (from_securitylevel >=2 || (typ->ty_status
 657                     & TTY_SECURE) == 0) && pp && *pp->pw_passwd != '\0') {
 658                         (void)fprintf(stderr,
 659                             "Enter root password, or ^D to go multi-user\n");
 660                         for (;;) {
 661                                 clear = getpass("Password:");
 662                                 if (clear == 0 || *clear == '\0')
 663                                         _exit(0);
 664                                 password = crypt(clear, pp->pw_passwd);
 665                                 (void)memset(clear, 0, _PASSWORD_LEN);
 666                                 if (strcmp(password, pp->pw_passwd) == 0)
 667                                         break;
 668                                 warning("single-user login failed");
 669                         }
 670                 }
 671                 (void)endttyent();
 672                 endpwent();
 673 #endif /* SECURE */
 674
 675 #ifdef ALTSHELL
 676                 (void)fprintf(stderr,
 677                     "Enter pathname of shell or RETURN for %s: ", shell);
 678                 if (fgets(altshell, sizeof(altshell), stdin) == NULL) {
 679                         altshell[0] = '\0';
 680                 } else {
 681                         /* nuke \n */
 682                         char *p;
 683
 684                         if ((p = strchr(altshell, '\n')) != NULL)
 685                                 *p = '\0';
 686                 }
 687
 688                 if (altshell[0])
 689                         shell = altshell;
 690 #endif /* ALTSHELL */
 691
 692                 /*
 693                  * Unblock signals.
 694                  * We catch all the interesting ones,
 695                  * and those are reset to SIG_DFL on exec.
 696                  */
 697                 (void)sigemptyset(&mask);
 698                 (void)sigprocmask(SIG_SETMASK, &mask, NULL);
 699
 700                 /*
 701                  * Fire off a shell.
 702                  * If the default one doesn't work, try the Bourne shell.
 703                  */
 704                 argv[0] = "-sh";
 705                 argv[1] = 0;
 706                 (void)setenv("PATH", INIT_PATH, 1);
 707 #ifdef ALTSHELL
 708                 if (altshell[0])
 709                         argv[0] = altshell;
 710                 (void)execv(shell, __UNCONST(argv));
 711                 emergency("can't exec `%s' for single user: %m", shell);
 712                 argv[0] = "-sh";
 713 #endif /* ALTSHELL */
 714                 (void)execv(INIT_BSHELL, __UNCONST(argv));
 715                 emergency("can't exec `%s' for single user: %m", INIT_BSHELL);
 716                 (void)sleep(STALL_TIMEOUT);
 717                 _exit(3);
 718         }
 719
 720         if (pid == -1) {
 721                 /*
 722                  * We are seriously hosed.  Do our best.
 723                  */
 724                 emergency("can't fork single-user shell: %m, trying again");
 725                 while (waitpid(-1, NULL, WNOHANG) > 0)
 726                         continue;
 727                 (void)sigaction(SIGTSTP, &satstp, NULL);
 728                 (void)sigaction(SIGHUP, &sahup, NULL);
 729                 return (state_func_t)single_user;
 730         }
 731
 732         requested_transition = 0;
 733         do {
 734                 if ((wpid = waitpid(-1, &status, WUNTRACED)) != -1)
 735                         collect_child(wpid, status);
 736                 if (wpid == -1) {
 737                         if (errno == EINTR)
 738                                 continue;
 739                         warning("wait for single-user shell failed: %m; "
 740                             "restarting");
 741                         return (state_func_t)single_user;
 742                 }
 743                 if (wpid == pid && WIFSTOPPED(status)) {
 744                         warning("shell stopped, restarting");
 745                         (void)kill(pid, SIGCONT);
 746                         wpid = -1;
 747                 }
 748         } while (wpid != pid && !requested_transition);
 749
 750         if (requested_transition) {
 751                 (void)sigaction(SIGTSTP, &satstp, NULL);
 752                 (void)sigaction(SIGHUP, &sahup, NULL);
 753                 return (state_func_t)requested_transition;
 754         }
 755
 756         if (WIFSIGNALED(status)) {
 757                 if (WTERMSIG(status) == SIGKILL) {
 758                         /* executed /sbin/reboot; wait for the end quietly */
 759                         sigset_t s;
 760
 761                         (void)sigfillset(&s);
 762                         for (;;)
 763                                 (void)sigsuspend(&s);
 764                 } else {
 765                         warning("single user shell terminated (%x), restarting",
 766                                 status);
 767                         (void)sigaction(SIGTSTP, &satstp, NULL);
 768                         (void)sigaction(SIGHUP, &sahup, NULL);
 769                         return (state_func_t)single_user;
 770                 }
 771         }
 772
 773         runcom_mode = FASTBOOT;
 774         (void)sigaction(SIGTSTP, &satstp, NULL);
 775         (void)sigaction(SIGHUP, &sahup, NULL);
 776 #ifndef LETS_GET_SMALL
 777         return (state_func_t)runcom;
 778 #else /* LETS_GET_SMALL */
 779         return (state_func_t)single_user;
 780 #endif /* LETS_GET_SMALL */
 781 }
 782
 783 #ifndef LETS_GET_SMALL
 784
 785 /* ARGSUSED */
 786 state_func_t
 787 runetcrc(int trychroot)
 788 {
 789         pid_t pid, wpid;
 790         int status;
 791         const char *argv[4];
 792         struct sigaction sa;
 793
 794         switch ((pid = fork())) {
 795         case 0:
 796                 (void)sigemptyset(&sa.sa_mask);
 797                 sa.sa_flags = 0;
 798                 sa.sa_handler = SIG_IGN;
 799                 (void)sigaction(SIGTSTP, &sa, NULL);
 800                 (void)sigaction(SIGHUP, &sa, NULL);
 801
 802                 setctty(_PATH_CONSOLE);
 803
 804                 argv[0] = "sh";
 805                 argv[1] = _PATH_RUNCOM;
 806                 argv[2] = (runcom_mode == AUTOBOOT ? "autoboot" : 0);
 807                 argv[3] = 0;
 808
 809                 (void)sigprocmask(SIG_SETMASK, &sa.sa_mask, NULL);
 810
 811 #ifdef CHROOT
 812                 if (trychroot)
 813                         if (chroot(rootdir) != 0) {
 814                                 warning("failed to chroot to `%s': %m",
 815                                     rootdir);
 816                                 _exit(4);       /* force single user mode */
 817                         }
 818 #endif /* CHROOT */
 819
 820                 (void)execv(INIT_BSHELL, __UNCONST(argv));
 821                 stall("can't exec `%s' for `%s': %m", INIT_BSHELL, _PATH_RUNCOM);
 822                 _exit(5);       /* force single user mode */
 823                 /*NOTREACHED*/
 824         case -1:
 825                 emergency("can't fork for `%s' on `%s': %m", INIT_BSHELL,
 826                     _PATH_RUNCOM);
 827                 while (waitpid(-1, NULL, WNOHANG) > 0)
 828                         continue;
 829                 (void)sleep(STALL_TIMEOUT);
 830                 return (state_func_t)single_user;
 831         default:
 832                 break;
 833         }
 834
 835         /*
 836          * Copied from single_user().  This is a bit paranoid.
 837          */
 838         do {
 839                 if ((wpid = waitpid(-1, &status, WUNTRACED)) != -1)
 840                         collect_child(wpid, status);
 841                 if (wpid == -1) {
 842                         if (errno == EINTR)
 843                                 continue;
 844                         warning("wait for `%s' on `%s' failed: %m; going to "
 845                             "single user mode", INIT_BSHELL, _PATH_RUNCOM);
 846                         return (state_func_t)single_user;
 847                 }
 848                 if (wpid == pid && WIFSTOPPED(status)) {
 849                         warning("`%s' on `%s' stopped, restarting",
 850                             INIT_BSHELL, _PATH_RUNCOM);
 851                         (void)kill(pid, SIGCONT);
 852                         wpid = -1;
 853                 }
 854         } while (wpid != pid);
 855
 856         if (WIFSIGNALED(status) && WTERMSIG(status) == SIGTERM &&
 857             requested_transition == catatonia) {
 858                 /* /etc/rc executed /sbin/reboot; wait for the end quietly */
 859                 sigset_t s;
 860
 861                 (void)sigfillset(&s);
 862                 for (;;)
 863                         (void)sigsuspend(&s);
 864         }
 865
 866         if (!WIFEXITED(status)) {
 867                 warning("`%s' on `%s' terminated abnormally, going to "
 868                     "single user mode", INIT_BSHELL, _PATH_RUNCOM);
 869                 return (state_func_t)single_user;
 870         }
 871
 872         if (WEXITSTATUS(status))
 873                 return (state_func_t)single_user;
 874
 875         return (state_func_t)read_ttys;
 876 }
 877
 878 /*
 879  * Run the system startup script.
 880  */
 881 state_func_t
 882 runcom(void)
 883 {
 884         state_func_t next_step;
 885
 886         /* Run /etc/rc and choose next state depending on the result. */
 887         next_step = runetcrc(0);
 888         if (next_step != (state_func_t)read_ttys)
 889                 return (state_func_t)next_step;
 890
 891 #ifdef CHROOT
 892         /*
 893          * If init.root sysctl does not point to "/", we'll chroot and run
 894          * The Real(tm) /etc/rc now.  Global variable rootdir will tell us
 895          * where to go.
 896          */
 897         if (shouldchroot()) {
 898                 next_step = runetcrc(1);
 899                 if (next_step != (state_func_t)read_ttys)
 900                         return (state_func_t)next_step;
 901
 902                 did_multiuser_chroot = 1;
 903         } else {
 904                 did_multiuser_chroot = 0;
 905         }
 906 #endif /* CHROOT */
 907
 908         /*
 909          * Regardless of whether in chroot or not, we booted successfuly.
 910          * It's time to spawn gettys (ie. next_step's value at this point).
 911          */
 912         runcom_mode = AUTOBOOT;         /* the default */
 913         /* NB: should send a message to the session logger to avoid blocking. */
 914 #ifdef SUPPORT_UTMPX
 915         logwtmpx("~", "reboot", "", 0, INIT_PROCESS);
 916 #endif
 917 #ifdef SUPPORT_UTMP
 918         logwtmp("~", "reboot", "");
 919 #endif
 920         return (state_func_t)read_ttys;
 921 }
 922
 923 /*
 924  * Open the session database.
 925  *
 926  * NB: We could pass in the size here; is it necessary?
 927  */
 928 int
 929 start_session_db(void)
 930 {
 931
 932         if (session_db && (*session_db->close)(session_db))
 933                 emergency("session database close: %m");
 934         if ((session_db = dbopen(NULL, O_RDWR, 0, DB_HASH, NULL)) == 0) {
 935                 emergency("session database open: %m");
 936                 return 1;
 937         }
 938         return 0;
 939
 940 }
 941
 942 /*
 943  * Add a new login session.
 944  */
 945 void
 946 add_session(session_t *sp)
 947 {
 948         DBT key;
 949         DBT data;
 950
 951         if (session_db == NULL)
 952                 return;
 953
 954         key.data = &sp->se_process;
 955         key.size = sizeof sp->se_process;
 956         data.data = &sp;
 957         data.size = sizeof sp;
 958
 959         if ((*session_db->put)(session_db, &key, &data, 0))
 960                 emergency("insert %d: %m", sp->se_process);
 961 #ifdef SUPPORT_UTMPX
 962         session_utmpx(sp, 1);
 963 #endif
 964 }
 965
 966 /*
 967  * Delete an old login session.
 968  */
 969 void
 970 del_session(session_t *sp)
 971 {
 972         DBT key;
 973
 974         key.data = &sp->se_process;
 975         key.size = sizeof sp->se_process;
 976
 977         if ((*session_db->del)(session_db, &key, 0))
 978                 emergency("delete %d: %m", sp->se_process);
 979 #ifdef SUPPORT_UTMPX
 980         session_utmpx(sp, 0);
 981 #endif
 982 }
 983
 984 /*
 985  * Look up a login session by pid.
 986  */
 987 session_t *
 988 find_session(pid_t pid)
 989 {
 990         DBT key;
 991         DBT data;
 992         session_t *ret;
 993
 994         if (session_db == NULL)
 995                 return NULL;
 996
 997         key.data = &pid;
 998         key.size = sizeof pid;
 999         if ((*session_db->get)(session_db, &key, &data, 0) != 0)
1000                 return 0;
1001         (void)memmove(&ret, data.data, sizeof(ret));
1002         return ret;
1003 }
1004
1005 /*
1006  * Construct an argument vector from a command line.
1007  */
1008 char **
1009 construct_argv(char *command)
1010 {
1011         int argc = 0;
1012         char **argv = malloc(((strlen(command) + 1) / 2 + 1) * sizeof (char *));
1013         static const char separators[] = " \t";
1014
1015         if (argv == NULL)
1016                 return NULL;
1017
1018         if ((argv[argc++] = strtok(command, separators)) == 0) {
1019                 free(argv);
1020                 return NULL;
1021         }
1022         while ((argv[argc++] = strtok(NULL, separators)) != NULL)
1023                 continue;
1024         return argv;
1025 }
1026
1027 /*
1028  * Deallocate a session descriptor.
1029  */
1030 void
1031 free_session(session_t *sp)
1032 {
1033
1034         free(sp->se_device);
1035         if (sp->se_getty) {
1036                 free(sp->se_getty);
1037                 free(sp->se_getty_argv);
1038         }
1039         if (sp->se_window) {
1040                 free(sp->se_window);
1041                 free(sp->se_window_argv);
1042         }
1043         free(sp);
1044 }
1045
1046 /*
1047  * Allocate a new session descriptor.
1048  */
1049 session_t *
1050 new_session(session_t *sprev, int session_index, struct ttyent *typ)
1051 {
1052         session_t *sp;
1053
1054         if ((typ->ty_status & TTY_ON) == 0 || typ->ty_name == NULL ||
1055             typ->ty_getty == NULL)
1056                 return NULL;
1057
1058         sp = malloc(sizeof (session_t));
1059         if (sp == NULL)
1060                 return NULL;
1061         (void)memset(sp, 0, sizeof *sp);
1062
1063         sp->se_flags = SE_PRESENT;
1064         sp->se_index = session_index;
1065
1066         (void)asprintf(&sp->se_device, "%s%s", _PATH_DEV, typ->ty_name);
1067         if (!sp->se_device)
1068                 return NULL;
1069
1070         if (setupargv(sp, typ) == 0) {
1071                 free_session(sp);
1072                 return NULL;
1073         }
1074
1075         sp->se_next = NULL;
1076         if (sprev == NULL) {
1077                 sessions = sp;
1078                 sp->se_prev = NULL;
1079         } else {
1080                 sprev->se_next = sp;
1081                 sp->se_prev = sprev;
1082         }
1083
1084         return sp;
1085 }
1086
1087 /*
1088  * Calculate getty and if useful window argv vectors.
1089  */
1090 int
1091 setupargv(session_t *sp, struct ttyent *typ)
1092 {
1093
1094         if (sp->se_getty) {
1095                 free(sp->se_getty);
1096                 free(sp->se_getty_argv);
1097         }
1098         (void)asprintf(&sp->se_getty, "%s %s", typ->ty_getty, typ->ty_name);
1099         if (!sp->se_getty)
1100                 return 0;
1101         sp->se_getty_argv = construct_argv(sp->se_getty);
1102         if (sp->se_getty_argv == NULL) {
1103                 warning("can't parse getty for port `%s'", sp->se_device);
1104                 free(sp->se_getty);
1105                 sp->se_getty = NULL;
1106                 return 0;
1107         }
1108         if (typ->ty_window) {
1109                 if (sp->se_window)
1110                         free(sp->se_window);
1111                 sp->se_window = strdup(typ->ty_window);
1112                 sp->se_window_argv = construct_argv(sp->se_window);
1113                 if (sp->se_window_argv == NULL) {
1114                         warning("can't parse window for port `%s'",
1115                             sp->se_device);
1116                         free(sp->se_window);
1117                         sp->se_window = NULL;
1118                         return 0;
1119                 }
1120         }
1121         return 1;
1122 }
1123
1124 /*
1125  * Walk the list of ttys and create sessions for each active line.
1126  */
1127 state_func_t
1128 read_ttys(void)
1129 {
1130         int session_index = 0;
1131         session_t *sp, *snext;
1132         struct ttyent *typ;
1133
1134 #ifdef SUPPORT_UTMPX
1135         if (sessions == NULL) {
1136                 struct stat st;
1137
1138                 make_utmpx("", BOOT_MSG, BOOT_TIME, 0, &boot_time, 0);
1139
1140                 /*
1141                  * If wtmpx is not empty, pick the the down time from there
1142                  */
1143                 if (stat(_PATH_WTMPX, &st) != -1 && st.st_size != 0) {
1144                         struct timeval down_time;
1145
1146                         TIMESPEC_TO_TIMEVAL(&down_time,
1147                             st.st_atime > st.st_mtime ?
1148                             &st.st_atimespec : &st.st_mtimespec);
1149                         make_utmpx("", DOWN_MSG, DOWN_TIME, 0, &down_time, 0);
1150                 }
1151         }
1152 #endif
1153         /*
1154          * Destroy any previous session state.
1155          * There shouldn't be any, but just in case...
1156          */
1157         for (sp = sessions; sp; sp = snext) {
1158 #ifndef LETS_GET_SMALL
1159                 if (sp->se_process)
1160                         clear_session_logs(sp, 0);
1161 #endif
1162                 snext = sp->se_next;
1163                 free_session(sp);
1164         }
1165         sessions = NULL;
1166
1167         if (start_session_db()) {
1168                 warning("start_session_db failed, death");
1169 #ifdef CHROOT
1170                 /* If /etc/rc ran in chroot, we want to kill any survivors. */
1171                 if (did_multiuser_chroot)
1172                         return (state_func_t)death;
1173                 else
1174 #endif /* CHROOT */
1175                         return (state_func_t)single_user;
1176         }
1177
1178         (void)do_setttyent();
1179
1180         /*
1181          * Allocate a session entry for each active port.
1182          * Note that sp starts at 0.
1183          */
1184         while ((typ = getttyent()) != NULL)
1185                 if ((snext = new_session(sp, ++session_index, typ)) != NULL)
1186                         sp = snext;
1187         (void)endttyent();
1188
1189         return (state_func_t)multi_user;
1190 }
1191
1192 /*
1193  * Start a window system running.
1194  */
1195 void
1196 start_window_system(session_t *sp)
1197 {
1198         pid_t pid;
1199         sigset_t mask;
1200
1201         if ((pid = fork()) == -1) {
1202                 emergency("can't fork for window system on port `%s': %m",
1203                     sp->se_device);
1204                 /* hope that getty fails and we can try again */
1205                 return;
1206         }
1207
1208         if (pid)
1209                 return;
1210
1211         (void)sigemptyset(&mask);
1212         (void)sigprocmask(SIG_SETMASK, &mask, NULL);
1213
1214         if (setsid() < 0)
1215                 emergency("setsid failed (window): %m");
1216
1217         (void)execv(sp->se_window_argv[0], sp->se_window_argv);
1218         stall("can't exec window system `%s' for port `%s': %m",
1219             sp->se_window_argv[0], sp->se_device);
1220         _exit(6);
1221 }
1222
1223 /*
1224  * Start a login session running.
1225  */
1226 pid_t
1227 start_getty(session_t *sp)
1228 {
1229         pid_t pid;
1230         sigset_t mask;
1231         time_t current_time = time(NULL);
1232
1233         /*
1234          * fork(), not vfork() -- we can't afford to block.
1235          */
1236         if ((pid = fork()) == -1) {
1237                 emergency("can't fork for getty on port `%s': %m",
1238                     sp->se_device);
1239                 return -1;
1240         }
1241
1242         if (pid)
1243                 return pid;
1244
1245 #ifdef CHROOT
1246         /* If /etc/rc did proceed inside chroot, we have to try as well. */
1247         if (did_multiuser_chroot)
1248                 if (chroot(rootdir) != 0) {
1249                         stall("can't chroot getty `%s' inside `%s': %m",
1250                             sp->se_getty_argv[0], rootdir);
1251                         _exit(7);
1252                 }
1253 #endif /* CHROOT */
1254
1255         if (current_time > sp->se_started.tv_sec &&
1256             current_time - sp->se_started.tv_sec < GETTY_SPACING) {
1257                 warning("getty repeating too quickly on port `%s', sleeping",
1258                     sp->se_device);
1259                 (void)sleep(GETTY_SLEEP);
1260         }
1261
1262         if (sp->se_window) {
1263                 start_window_system(sp);
1264                 (void)sleep(WINDOW_WAIT);
1265         }
1266
1267         (void)sigemptyset(&mask);
1268         (void)sigprocmask(SIG_SETMASK, &mask, (sigset_t *) 0);
1269
1270         (void)execv(sp->se_getty_argv[0], sp->se_getty_argv);
1271         stall("can't exec getty `%s' for port `%s': %m",
1272             sp->se_getty_argv[0], sp->se_device);
1273         _exit(8);
1274         /*NOTREACHED*/
1275 }
1276 #ifdef SUPPORT_UTMPX
1277 static void
1278 session_utmpx(const session_t *sp, int add)
1279 {
1280         const char *name = sp->se_getty ? sp->se_getty :
1281             (sp->se_window ? sp->se_window : "");
1282         const char *line = sp->se_device + sizeof(_PATH_DEV) - 1;
1283
1284         make_utmpx(name, line, add ? LOGIN_PROCESS : DEAD_PROCESS,
1285             sp->se_process, &sp->se_started, sp->se_index);
1286 }
1287
1288 static void
1289 make_utmpx(const char *name, const char *line, int type, pid_t pid,
1290     const struct timeval *tv, int session)
1291 {
1292         struct utmpx ut;
1293         const char *eline;
1294
1295         (void)memset(&ut, 0, sizeof(ut));
1296         (void)strlcpy(ut.ut_name, name, sizeof(ut.ut_name));
1297         ut.ut_type = type;
1298         (void)strlcpy(ut.ut_line, line, sizeof(ut.ut_line));
1299         ut.ut_pid = pid;
1300         if (tv)
1301                 ut.ut_tv = *tv;
1302         else
1303                 (void)gettimeofday(&ut.ut_tv, NULL);
1304         ut.ut_session = session;
1305
1306         eline = line + strlen(line);
1307         if ((size_t)(eline - line) >= sizeof(ut.ut_id))
1308                 line = eline - sizeof(ut.ut_id);
1309         (void)strncpy(ut.ut_id, line, sizeof(ut.ut_id));
1310
1311         if (pututxline(&ut) == NULL)
1312                 warning("can't add utmpx record for `%s': %m", ut.ut_line);
1313         endutxent();
1314 }
1315
1316 static char
1317 get_runlevel(const state_t s)
1318 {
1319         if (s == (state_t)single_user)
1320                 return SINGLE_USER;
1321         if (s == (state_t)runcom)
1322                 return RUNCOM;
1323         if (s == (state_t)read_ttys)
1324                 return READ_TTYS;
1325         if (s == (state_t)multi_user)
1326                 return MULTI_USER;
1327         if (s == (state_t)clean_ttys)
1328                 return CLEAN_TTYS;
1329         if (s == (state_t)catatonia)
1330                 return CATATONIA;
1331         return DEATH;
1332 }
1333
1334 static void
1335 utmpx_set_runlevel(char old, char new)
1336 {
1337         struct utmpx ut;
1338
1339         /*
1340          * Don't record any transitions until we did the first transition
1341          * to read ttys, which is when we are guaranteed to have a read-write
1342          * /var. Perhaps use a different variable for this?
1343          */
1344         if (sessions == NULL)
1345                 return;
1346
1347         (void)memset(&ut, 0, sizeof(ut));
1348         (void)snprintf(ut.ut_line, sizeof(ut.ut_line), RUNLVL_MSG, new);
1349         ut.ut_type = RUN_LVL;
1350         (void)gettimeofday(&ut.ut_tv, NULL);
1351         ut.ut_exit.e_exit = old;
1352         ut.ut_exit.e_termination = new;
1353         if (pututxline(&ut) == NULL)
1354                 warning("can't add utmpx record for `runlevel': %m");
1355         endutxent();
1356 }
1357 #endif /* SUPPORT_UTMPX */
1358
1359 #endif /* LETS_GET_SMALL */
1360
1361 /*
1362  * Collect exit status for a child.
1363  * If an exiting login, start a new login running.
1364  */
1365 void
1366 collect_child(pid_t pid, int status)
1367 {
1368 #ifndef LETS_GET_SMALL
1369         session_t *sp, *sprev, *snext;
1370
1371         if (! sessions)
1372                 return;
1373
1374         if ((sp = find_session(pid)) == NULL)
1375                 return;
1376
1377         clear_session_logs(sp, status);
1378         del_session(sp);
1379         sp->se_process = 0;
1380
1381         if (sp->se_flags & SE_SHUTDOWN) {
1382                 if ((sprev = sp->se_prev) != NULL)
1383                         sprev->se_next = sp->se_next;
1384                 else
1385                         sessions = sp->se_next;
1386                 if ((snext = sp->se_next) != NULL)
1387                         snext->se_prev = sp->se_prev;
1388                 free_session(sp);
1389                 return;
1390         }
1391
1392         if ((pid = start_getty(sp)) == -1) {
1393                 /* serious trouble */
1394                 requested_transition = clean_ttys;
1395                 return;
1396         }
1397
1398         sp->se_process = pid;
1399         (void)gettimeofday(&sp->se_started, NULL);
1400         add_session(sp);
1401 #endif /* LETS_GET_SMALL */
1402 }
1403
1404 /*
1405  * Catch a signal and request a state transition.
1406  */
1407 void
1408 transition_handler(int sig)
1409 {
1410
1411         switch (sig) {
1412 #ifndef LETS_GET_SMALL
1413         case SIGHUP:
1414                 requested_transition = clean_ttys;
1415                 break;
1416         case SIGTERM:
1417                 requested_transition = death;
1418                 break;
1419         case SIGTSTP:
1420                 requested_transition = catatonia;
1421                 break;
1422 #endif /* LETS_GET_SMALL */
1423         default:
1424                 requested_transition = 0;
1425                 break;
1426         }
1427 }
1428
1429 #ifndef LETS_GET_SMALL
1430 /*
1431  * Take the system multiuser.
1432  */
1433 state_func_t
1434 multi_user(void)
1435 {
1436         pid_t pid;
1437         int status;
1438         session_t *sp;
1439
1440         requested_transition = 0;
1441
1442         /*
1443          * If the administrator has not set the security level to -1
1444          * to indicate that the kernel should not run multiuser in secure
1445          * mode, and the run script has not set a higher level of security
1446          * than level 1, then put the kernel into secure mode.
1447          */
1448         if (getsecuritylevel() == 0)
1449                 setsecuritylevel(1);
1450
1451         for (sp = sessions; sp; sp = sp->se_next) {
1452                 if (sp->se_process)
1453                         continue;
1454                 if ((pid = start_getty(sp)) == -1) {
1455                         /* serious trouble */
1456                         requested_transition = clean_ttys;
1457                         break;
1458                 }
1459                 sp->se_process = pid;
1460                 (void)gettimeofday(&sp->se_started, NULL);
1461                 add_session(sp);
1462         }
1463
1464         while (!requested_transition)
1465                 if ((pid = waitpid(-1, &status, 0)) != -1)
1466                         collect_child(pid, status);
1467
1468         return (state_func_t)requested_transition;
1469 }
1470
1471 /*
1472  * This is an n-squared algorithm.  We hope it isn't run often...
1473  */
1474 state_func_t
1475 clean_ttys(void)
1476 {
1477         session_t *sp, *sprev;
1478         struct ttyent *typ;
1479         int session_index = 0;
1480         int devlen;
1481
1482         for (sp = sessions; sp; sp = sp->se_next)
1483                 sp->se_flags &= ~SE_PRESENT;
1484
1485         (void)do_setttyent();
1486
1487         devlen = sizeof(_PATH_DEV) - 1;
1488         while ((typ = getttyent()) != NULL) {
1489                 ++session_index;
1490
1491                 for (sprev = 0, sp = sessions; sp; sprev = sp, sp = sp->se_next)
1492                         if (strcmp(typ->ty_name, sp->se_device + devlen) == 0)
1493                                 break;
1494
1495                 if (sp) {
1496                         sp->se_flags |= SE_PRESENT;
1497                         if (sp->se_index != session_index) {
1498                                 warning("port `%s' changed utmp index from "
1499                                     "%d to %d", sp->se_device, sp->se_index,
1500                                     session_index);
1501                                 sp->se_index = session_index;
1502                         }
1503                         if ((typ->ty_status & TTY_ON) == 0 ||
1504                             typ->ty_getty == 0) {
1505                                 sp->se_flags |= SE_SHUTDOWN;
1506                                 if (sp->se_process != 0)
1507                                         (void)kill(sp->se_process, SIGHUP);
1508                                 continue;
1509                         }
1510                         sp->se_flags &= ~SE_SHUTDOWN;
1511                         if (setupargv(sp, typ) == 0) {
1512                                 warning("can't parse getty for port `%s'",
1513                                     sp->se_device);
1514                                 sp->se_flags |= SE_SHUTDOWN;
1515                                 if (sp->se_process != 0)
1516                                         (void)kill(sp->se_process, SIGHUP);
1517                         }
1518                         continue;
1519                 }
1520
1521                 (void)new_session(sprev, session_index, typ);
1522         }
1523
1524         (void)endttyent();
1525
1526         for (sp = sessions; sp; sp = sp->se_next)
1527                 if ((sp->se_flags & SE_PRESENT) == 0) {
1528                         sp->se_flags |= SE_SHUTDOWN;
1529                         if (sp->se_process != 0)
1530                                 (void)kill(sp->se_process, SIGHUP);
1531                 }
1532
1533         return (state_func_t)multi_user;
1534 }
1535
1536 /*
1537  * Block further logins.
1538  */
1539 state_func_t
1540 catatonia(void)
1541 {
1542         session_t *sp;
1543
1544         for (sp = sessions; sp; sp = sp->se_next)
1545                 sp->se_flags |= SE_SHUTDOWN;
1546
1547         return (state_func_t)multi_user;
1548 }
1549 #endif /* LETS_GET_SMALL */
1550
1551 /*
1552  * Note SIGALRM.
1553  */
1554 void
1555 /*ARGSUSED*/
1556 alrm_handler(int sig)
1557 {
1558
1559         clang = 1;
1560 }
1561
1562 #ifndef LETS_GET_SMALL
1563 /*
1564  * Bring the system down to single user.
1565  */
1566 state_func_t
1567 death(void)
1568 {
1569         session_t *sp;
1570         int i, status;
1571         pid_t pid;
1572         static const int death_sigs[3] = { SIGHUP, SIGTERM, SIGKILL };
1573
1574         for (sp = sessions; sp; sp = sp->se_next)
1575                 sp->se_flags |= SE_SHUTDOWN;
1576
1577         /* NB: should send a message to the session logger to avoid blocking. */
1578 #ifdef SUPPORT_UTMPX
1579         logwtmpx("~", "shutdown", "", 0, INIT_PROCESS);
1580 #endif
1581 #ifdef SUPPORT_UTMP
1582         logwtmp("~", "shutdown", "");
1583 #endif
1584
1585         for (i = 0; i < 3; ++i) {
1586                 if (kill(-1, death_sigs[i]) == -1 && errno == ESRCH)
1587                         return (state_func_t)single_user;
1588
1589                 clang = 0;
1590                 (void)alarm(DEATH_WATCH);
1591                 do
1592                         if ((pid = waitpid(-1, &status, 0)) != -1)
1593                                 collect_child(pid, status);
1594                 while (clang == 0 && errno != ECHILD);
1595
1596                 if (errno == ECHILD)
1597                         return (state_func_t)single_user;
1598         }
1599
1600         warning("some processes would not die; ps axl advised");
1601
1602         return (state_func_t)single_user;
1603 }
1604 #endif /* LETS_GET_SMALL */
1605
1606 #ifdef MFS_DEV_IF_NO_CONSOLE
1607
1608 static int
1609 mfs_dev(void)
1610 {
1611         /*
1612          * We cannot print errors so we bail out silently...
1613          */
1614         pid_t pid;
1615         int status;
1616
1617         /* If we have /dev/console, assume all is OK  */
1618         if (access(_PATH_CONSOLE, F_OK) == 0)
1619                 return 0;
1620
1621 #if 0   /* Useful for testing MAKEDEV */
1622         /* Mount an mfs over /mnt so we can create a console entry */
1623         switch ((pid = fork())) {
1624         case 0:
1625                 (void)execl(INIT_MOUNT_MFS, "mount_mfs",
1626                     "-b", "4096", "-f", "512",
1627                     "-s", 64, "-n", 10,
1628                     "-p", "0755",
1629                     "swap", "/mnt", NULL);
1630                 _exit(9);
1631                 /*NOTREACHED*/
1632
1633         case -1:
1634                 return(-1);
1635
1636         default:
1637                 if (waitpid(pid, &status, 0) == -1)
1638                         return(-1);
1639                 if (status != 0)
1640                         return(-1);
1641                 break;
1642         }
1643
1644         {
1645                 dev_t dev;
1646 #ifdef CPU_CONSDEV
1647                 static int name[2] = { CTL_MACHDEP, CPU_CONSDEV };
1648                 size_t olen;
1649                 olen = sizeof(dev);
1650                 if (sysctl(name, sizeof(name) / sizeof(name[0]), &dev, &olen,
1651                     NULL, 0) == -1)
1652 #endif
1653                         dev = makedev(0, 0);
1654
1655                 /* Make a console for us, so we can see things happening */
1656                 if (mknod("/mnt/console", 0666 | S_IFCHR, dev) == -1)
1657                         return(-1);
1658                 (void)freopen("/mnt/console", "a", stderr);
1659         }
1660
1661 #endif
1662
1663         /* Run the makedev script to create devices */
1664         switch ((pid = fork())) {
1665         case 0:
1666                 (void)dup2(2, 1);       /* Give the script stdout */
1667                 if (chdir("/dev") == 0)
1668                         (void)execl(INIT_BSHELL, "sh",
1669                             access("./MAKEDEV", X_OK) == 0
1670                                 ? "./MAKEDEV" : "/etc/MAKEDEV",
1671                             "-MM", "init", NULL);
1672                 _exit(10);
1673                 /* NOTREACHED */
1674
1675         case -1:
1676                 break;
1677
1678         default:
1679                 if (waitpid(pid, &status, 0) == -1)
1680                         break;
1681                 if (status != 0)
1682                         warn("MAKEDEV exit status %d\n", status);
1683                 /*
1684                  * If /dev/console got created, then return 0
1685                  * regardless of MAKEDEV exit status.
1686                  */
1687                 if (access(_PATH_CONSOLE, F_OK) == 0)
1688                         return 0;
1689                 _exit(11);
1690         }
1691         warn("Unable to run MAKEDEV");
1692         _exit(12);
1693 }
1694 #endif
1695
1696 int
1697 do_setttyent(void)
1698 {
1699         (void)endttyent();
1700 #ifdef CHROOT
1701         if (did_multiuser_chroot) {
1702                 char path[PATH_MAX];
1703
1704                 (void)snprintf(path, sizeof(path), "%s/%s", rootdir, _PATH_TTYS);
1705
1706                 return setttyentpath(path);
1707         } else
1708 #endif /* CHROOT */
1709                 return setttyent();
1710 }
1711
1712 #if !defined(LETS_GET_SMALL) && defined(CHROOT)
1713
1714 int
1715 createsysctlnode()
1716 {
1717         struct sysctlnode node;
1718         int mib[2];
1719         size_t len;
1720
1721         /*
1722          * Create top-level dynamic sysctl node.  Its child nodes will only
1723          * be readable by the superuser, since regular mortals should not
1724          * care ("Sssh, it's a secret!").
1725          */
1726         len = sizeof(struct sysctlnode);
1727         mib[0] = CTL_CREATE;
1728
1729         (void)memset(&node, 0, len);
1730         node.sysctl_flags = SYSCTL_VERSION | CTLFLAG_READWRITE |
1731             CTLFLAG_PRIVATE | CTLTYPE_NODE;
1732         node.sysctl_num = CTL_CREATE;
1733         (void)snprintf(node.sysctl_name, SYSCTL_NAMELEN, "init");
1734         if (sysctl(&mib[0], 1, &node, &len, &node, len) == -1) {
1735                 warning("could not create init node: %m");
1736                 return -1;
1737         }
1738
1739         /*
1740          * Create second level dynamic node capable of holding pathname.
1741          * Provide "/" as the default value.
1742          */
1743         len = sizeof(struct sysctlnode);
1744         mib[0] = node.sysctl_num;
1745         mib[1] = CTL_CREATE;
1746
1747         (void)memset(&node, 0, len);
1748         node.sysctl_flags = SYSCTL_VERSION | CTLFLAG_READWRITE |
1749             CTLTYPE_STRING | CTLFLAG_OWNDATA;
1750         node.sysctl_size = _POSIX_PATH_MAX;
1751         node.sysctl_data = __UNCONST("/");
1752         node.sysctl_num = CTL_CREATE;
1753         (void)snprintf(node.sysctl_name, SYSCTL_NAMELEN, "root");
1754         if (sysctl(&mib[0], 2, NULL, NULL, &node, len) == -1) {
1755                 warning("could not create init.root node: %m");
1756                 return -1;
1757         }
1758
1759         return 0;
1760 }
1761
1762 int
1763 shouldchroot()
1764 {
1765         struct sysctlnode node;
1766         size_t len, cnt;
1767         int mib;
1768
1769         len = sizeof(struct sysctlnode);
1770
1771         if (sysctlbyname("init.root", rootdir, &len, NULL, 0) == -1) {
1772                 warning("could not read init.root: %m");
1773
1774                 /* Child killed our node. Recreate it. */
1775                 if (errno == ENOENT) {
1776                         /* Destroy whatever is left, recreate from scratch. */
1777                         if (sysctlnametomib("init", &mib, &cnt) != -1) {
1778                                 (void)memset(&node, 0, sizeof(node));
1779                                 node.sysctl_flags = SYSCTL_VERSION;
1780                                 node.sysctl_num = mib;
1781                                 mib = CTL_DESTROY;
1782
1783                                 (void)sysctl(&mib, 1, NULL, NULL, &node,
1784                                     sizeof(node));
1785                         }
1786
1787                         (void)createsysctlnode();
1788                 }
1789
1790                 /* We certainly won't chroot. */
1791                 return 0;
1792         }
1793
1794         if (rootdir[len] != '\0' || strlen(rootdir) != len - 1) {
1795                 warning("init.root is not a string");
1796                 return 0;
1797         }
1798
1799         if (strcmp(rootdir, "/") == 0)
1800                 return 0;
1801
1802         return 1;
1803 }
1804
1805 #endif /* !LETS_GET_SMALL && CHROOT */