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