BSD 4_4_Lite2 release

[unix-history] / usr / src / sbin / init / init.c

diff --git a/usr/src/sbin/init/init.c b/usr/src/sbin/init/init.c
index 37bf502..316aa93 100644 (file)
--- a/usr/src/sbin/init/init.c
+++ b/usr/src/sbin/init/init.c
@@ -1,579 +1,1297 @@
-/*
- * Copyright (c) 1980,1986 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+/*-
+ * Copyright (c) 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Donn Seeley at Berkeley Software Design, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.

  */
 
 #ifndef lint
  */
 
 #ifndef lint

-static char sccsid[] = "@(#)init.c     5.17 (Berkeley) %G%";
-#endif not lint
-
-#include <sys/types.h>
-#include <sys/file.h>
-#include <sys/signal.h>
-#include <sys/reboot.h>
-#include <sys/syslog.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <setjmp.h>
-#include <utmp.h>
+static char copyright[] =
+"@(#) Copyright (c) 1991, 1993\n\
+       The Regents of the University of California.  All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+static char sccsid[] = "@(#)init.c     8.2 (Berkeley) 4/28/95";
+#endif /* not lint */
+
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#include <sys/wait.h>
+
+#include <db.h>

 #include <errno.h>
 #include <errno.h>

+#include <fcntl.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <time.h>

 #include <ttyent.h>
 #include <ttyent.h>

+#include <unistd.h>
+
+#ifdef __STDC__
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+#ifdef SECURE
+#include <pwd.h>
+#endif
+

 #include "pathnames.h"
 
 #include "pathnames.h"
 

-#define        CMDSIZ  200     /* max string length for getty or window command*/
-#define        ALL     p = itab; p ; p = p->next
-#define        EVER    ;;
-#define SCPYN(a, b)    strncpy(a, b, sizeof(a))
-#define SCMPN(a, b)    strncmp(a, b, sizeof(a))
-
-char   shell[] = _PATH_BSHELL;
-char   minus[] = "-";
-char   runc[]  = _PATH_RC;
-char   ctty[]  = _PATH_CONSOLE;
-
-struct tab
-{
-       char    line[UT_LINESIZE];
-       char    comn[CMDSIZ];
-       char    xflag;
-       int     pid;
-       int     wpid;           /* window system pid for SIGHUP */
-       char    wcmd[CMDSIZ];   /* command to start window system process */
-       time_t  gettytime;
-       int     gettycnt;
-       time_t  windtime;
-       int     windcnt;
-       struct  tab *next;
-} *itab;
-
-int    fi;
-int    mergflag;
-char   tty[20];
-jmp_buf        sjbuf, shutpass;
-
-char   *strcpy(), *strcat();
-long   lseek();
-void   idle(), merge(), reset();
-
-struct sigvec rvec = { reset, sigmask(SIGHUP), 0 };
+/*
+ * Until the mythical util.h arrives...
+ */
+extern int login_tty __P((int));
+extern int logout __P((const char *));
+extern void logwtmp __P((const char *, const char *, const char *));
+
+/*
+ * Sleep times; used to prevent thrashing.
+ */
+#define        GETTY_SPACING            5      /* N secs minimum getty spacing */
+#define        GETTY_SLEEP             30      /* sleep N secs after spacing problem */
+#define        WINDOW_WAIT              3      /* wait N secs after starting window */
+#define        STALL_TIMEOUT           30      /* wait N secs after warning */
+#define        DEATH_WATCH             10      /* wait N secs for procs to die */
+
+void handle __P((sig_t, ...));
+void delset __P((sigset_t *, ...));
+
+void stall __P((char *, ...));
+void warning __P((char *, ...));
+void emergency __P((char *, ...));
+void disaster __P((int));
+void badsys __P((int));
+
+/*
+ * We really need a recursive typedef...
+ * The following at least guarantees that the return type of (*state_t)()
+ * is sufficiently wide to hold a function pointer.
+ */
+typedef long (*state_func_t) __P((void));
+typedef state_func_t (*state_t) __P((void));
+
+state_func_t single_user __P((void));
+state_func_t runcom __P((void));
+state_func_t read_ttys __P((void));
+state_func_t multi_user __P((void));
+state_func_t clean_ttys __P((void));
+state_func_t catatonia __P((void));
+state_func_t death __P((void));
+
+enum { AUTOBOOT, FASTBOOT } runcom_mode = AUTOBOOT;
+
+void transition __P((state_t));
+state_t requested_transition = runcom;
+
+void setctty __P((char *));
+
+typedef struct init_session {
+       int     se_index;               /* index of entry in ttys file */
+       pid_t   se_process;             /* controlling process */
+       time_t  se_started;             /* used to avoid thrashing */
+       int     se_flags;               /* status of session */
+#define        SE_SHUTDOWN     0x1             /* session won't be restarted */
+       char    *se_device;             /* filename of port */
+       char    *se_getty;              /* what to run on that port */
+       char    **se_getty_argv;        /* pre-parsed argument array */
+       char    *se_window;             /* window system (started only once) */
+       char    **se_window_argv;       /* pre-parsed argument array */
+       struct  init_session *se_prev;
+       struct  init_session *se_next;
+} session_t;

 
 

+void free_session __P((session_t *));
+session_t *new_session __P((session_t *, int, struct ttyent *));
+session_t *sessions;
+
+char **construct_argv __P((char *));
+void start_window_system __P((session_t *));
+void collect_child __P((pid_t));
+pid_t start_getty __P((session_t *));
+void transition_handler __P((int));
+void alrm_handler __P((int));
+void setsecuritylevel __P((int));
+int getsecuritylevel __P((void));
+int setupargv __P((session_t *, struct ttyent *));
+int clang;
+
+void clear_session_logs __P((session_t *));
+
+int start_session_db __P((void));
+void add_session __P((session_t *));
+void del_session __P((session_t *));
+session_t *find_session __P((pid_t));
+DB *session_db;
+
+/*
+ * The mother of all processes.
+ */
+int

 main(argc, argv)
 main(argc, argv)

+       int argc;

        char **argv;
 {
        char **argv;
 {

-#if defined(tahoe)
-       register int r12;               /* make sure r11 gets bootflags */
-#endif
-#if defined(vax) || defined(tahoe) || defined(hp300)
-       register int r11;               /* passed thru from boot */
-#endif
-#ifdef __GNUC__
-       /* insure proper semantics for setjmp/longjmp */
-       static
-#endif
-       int howto, oldhowto, started = 0;
+       int c;
+       struct sigaction sa;
+       sigset_t mask;

 
 

-#if defined(vax) || defined(tahoe) || defined(hp300)
-       /* howto passed in high-order register XXX */
-#ifdef __GNUC__
-#ifdef hp300
-       asm("movl d7,%0" : "=rm" (howto));
-#else
-       asm("movl r11,%0" : "=rm" (howto));
-#endif
-#else
-       howto = r11;
-#endif /* __GNUC__ */
-#else  /* defined(vax) || defined(tahoe) || defined(hp300) */
-       /* howto passed as argument */
-       if (argc > 1 && argv[1][0] == '-') {
-               char *cp;
-
-               howto = 0;
-               cp = &argv[1][1];
-               while (*cp) switch (*cp++) {
-               case 'a':
-                       howto |= RB_ASKNAME;
-                       break;
+
+       /* Dispose of random users. */
+       if (getuid() != 0) {
+               (void)fprintf(stderr, "init: %s\n", strerror(EPERM));
+               exit (1);
+       }
+
+       /* System V users like to reexec init. */
+       if (getpid() != 1) {
+               (void)fprintf(stderr, "init: already running\n");
+               exit (1);
+       }
+
+       /*
+        * Note that this does NOT open a file...
+        * Does 'init' deserve its own facility number?
+        */
+       openlog("init", LOG_CONS|LOG_ODELAY, LOG_AUTH);
+
+       /*
+        * Create an initial session.
+        */
+       if (setsid() < 0)
+               warning("initial setsid() failed: %m");
+
+       /*
+        * Establish an initial user so that programs running
+        * single user do not freak out and die (like passwd).
+        */
+       if (setlogin("root") < 0)
+               warning("setlogin() failed: %m");
+
+       /*
+        * This code assumes that we always get arguments through flags,
+        * never through bits set in some random machine register.
+        */
+       while ((c = getopt(argc, argv, "sf")) != -1)
+               switch (c) {

                case 's':
                case 's':

-                       howto |= RB_SINGLE;
+                       requested_transition = single_user;
+                       break;
+               case 'f':
+                       runcom_mode = FASTBOOT;
+                       break;
+               default:
+                       warning("unrecognized flag '-%c'", c);

                        break;
                }
                        break;
                }

-       } else
-               howto = RB_SINGLE;
+
+       if (optind != argc)
+               warning("ignoring excess arguments");
+
+       /*
+        * We catch or block signals rather than ignore them,
+        * so that they get reset on exec.
+        */
+       handle(badsys, SIGSYS, 0);
+       handle(disaster, SIGABRT, SIGFPE, SIGILL, SIGSEGV,
+              SIGBUS, SIGXCPU, SIGXFSZ, 0);
+       handle(transition_handler, SIGHUP, SIGTERM, SIGTSTP, 0);
+       handle(alrm_handler, SIGALRM, 0);
+       sigfillset(&mask);
+       delset(&mask, SIGABRT, SIGFPE, SIGILL, SIGSEGV, SIGBUS, SIGSYS,
+               SIGXCPU, SIGXFSZ, SIGHUP, SIGTERM, SIGTSTP, SIGALRM, 0);
+       sigprocmask(SIG_SETMASK, &mask, (sigset_t *) 0);
+       sigemptyset(&sa.sa_mask);
+       sa.sa_flags = 0;
+       sa.sa_handler = SIG_IGN;
+       (void) sigaction(SIGTTIN, &sa, (struct sigaction *)0);
+       (void) sigaction(SIGTTOU, &sa, (struct sigaction *)0);
+
+       /*
+        * Paranoia.
+        */
+       close(0);
+       close(1);
+       close(2);
+
+       /*
+        * Start the state machine.
+        */
+       transition(requested_transition);
+
+       /*
+        * Should never reach here.
+        */
+       return 1;
+}
+
+/*
+ * Associate a function with a signal handler.
+ */
+void
+#ifdef __STDC__
+handle(sig_t handler, ...)
+#else
+handle(va_alist)
+       va_dcl

 #endif
 #endif

-       if (getuid() != 0)
-               exit(1);
-       openlog("init", LOG_CONS|LOG_ODELAY, LOG_AUTH);
-       if (setsid() < 0)
-               syslog(LOG_ERR, "setsid failed (initial) %m");
-       sigvec(SIGTERM, &rvec, (struct sigvec *)0);
-       signal(SIGTSTP, idle);
-       signal(SIGSTOP, SIG_IGN);
-       signal(SIGTTIN, SIG_IGN);
-       signal(SIGTTOU, SIG_IGN);
-       (void) setjmp(sjbuf);
-       for (; ; ) {
-               oldhowto = howto;
-               howto = RB_SINGLE;
-               if (started && setjmp(shutpass) == 0)
-                       shutdown();
-               started = 1;
-               if (oldhowto & RB_SINGLE)
-                       single();
-               if (runcom(oldhowto) == 0) 
-                       continue;
-               merge();
-               multiple();
+{
+       int sig;
+       struct sigaction sa;
+       int mask_everything;
+       va_list ap;
+#ifndef __STDC__
+       sig_t handler;
+
+       va_start(ap);
+       handler = va_arg(ap, sig_t);
+#else
+       va_start(ap, handler);
+#endif
+
+       sa.sa_handler = handler;
+       sigfillset(&mask_everything);
+
+       while (sig = va_arg(ap, int)) {
+               sa.sa_mask = mask_everything;
+               /* XXX SA_RESTART? */
+               sa.sa_flags = sig == SIGCHLD ? SA_NOCLDSTOP : 0;
+               sigaction(sig, &sa, (struct sigaction *) 0);

        }
        }

+       va_end(ap);

 }
 
 }
 

-void   shutreset();
+/*
+ * Delete a set of signals from a mask.
+ */
+void
+#ifdef __STDC__
+delset(sigset_t *maskp, ...)
+#else
+delset(va_alist)
+       va_dcl
+#endif
+{
+       int sig;
+       va_list ap;
+#ifndef __STDC__
+       sigset_t *maskp;
+
+       va_start(ap);
+       maskp = va_arg(ap, sigset_t *);
+#else
+       va_start(ap, maskp);
+#endif
+
+       while (sig = va_arg(ap, int))
+               sigdelset(maskp, sig);
+       va_end(ap);
+}

 
 

-shutdown()
+/*
+ * Log a message and sleep for a while (to give someone an opportunity
+ * to read it and to save log or hardcopy output if the problem is chronic).
+ * NB: should send a message to the session logger to avoid blocking.
+ */
+void
+#ifdef __STDC__
+stall(char *message, ...)
+#else
+stall(va_alist)
+       va_dcl
+#endif

 {
 {

-       register i;
-       register struct tab *p, *p1;
+       va_list ap;
+#ifndef __STDC__
+       char *message;

 
 

-       signal(SIGHUP, SIG_IGN);
-       for (p = itab; p ; ) {
-               term(p);
-               p1 = p->next;
-               free(p);
-               p = p1;
-       }
-       itab = (struct tab *)0;
-       signal(SIGALRM, shutreset);
-       (void) kill(-1, SIGTERM);       /* one chance to catch it */
-       sleep(5);
-       alarm(30);
-       for (i = 0; i < 5; i++)
-               kill(-1, SIGKILL);
-       while (wait((int *)0) != -1)
-               ;
-       alarm(0);
-       shutend();
+       va_start(ap);
+       message = va_arg(ap, char *);
+#else
+       va_start(ap, message);
+#endif
+
+       vsyslog(LOG_ALERT, message, ap);
+       va_end(ap);
+       sleep(STALL_TIMEOUT);

 }
 
 }
 

-char shutfailm[] = "init: WARNING: something is hung (won't die); ps axl advised\n";
+/*
+ * Like stall(), but doesn't sleep.
+ * If cpp had variadic macros, the two functions could be #defines for another.
+ * NB: should send a message to the session logger to avoid blocking.
+ */
+void
+#ifdef __STDC__
+warning(char *message, ...)
+#else
+warning(va_alist)
+       va_dcl
+#endif
+{
+       va_list ap;
+#ifndef __STDC__
+       char *message;
+
+       va_start(ap);
+       message = va_arg(ap, char *);
+#else
+       va_start(ap, message);
+#endif
+
+       vsyslog(LOG_ALERT, message, ap);
+       va_end(ap);
+}

 
 

+/*
+ * Log an emergency message.
+ * NB: should send a message to the session logger to avoid blocking.
+ */

 void
 void

-shutreset()
+#ifdef __STDC__
+emergency(char *message, ...)
+#else
+emergency(va_alist)
+       va_dcl
+#endif

 {
 {

-       int status;
+       va_list ap;
+#ifndef __STDC__
+       char *message;

 
 

-       if (fork() == 0) {
-               int ct = open(ctty, 1);
-               write(ct, shutfailm, sizeof (shutfailm));
-               sleep(5);
-               exit(1);
-       }
-       sleep(5);
-       shutend();
-       longjmp(shutpass, 1);
+       va_start(ap);
+       message = va_arg(ap, char *);
+#else
+       va_start(ap, message);
+#endif
+
+       vsyslog(LOG_EMERG, message, ap);
+       va_end(ap);

 }
 
 }
 

-shutend()
+/*
+ * Catch a SIGSYS signal.
+ *
+ * These may arise if a system does not support sysctl.
+ * We tolerate up to 25 of these, then throw in the towel.
+ */
+void
+badsys(sig)
+       int sig;

 {
 {

-       register i;
+       static int badcount = 0;

 
 

-       acct(0);
-       signal(SIGALRM, SIG_DFL);
-       for (i = 0; i < 10; i++)
-               close(i);
-       logwtmp("~", "shutdown", "");
+       if (badcount++ < 25)
+               return;
+       disaster(sig);

 }
 
 }
 

-single()
+/*
+ * Catch an unexpected signal.
+ */
+void
+disaster(sig)
+       int sig;

 {
 {

-       register pid;
-       register xpid;
-       int fd;
-       extern int errno;
+       emergency("fatal signal: %s",
+               sig < (unsigned) NSIG ? sys_siglist[sig] : "unknown signal");

 
 

-       do {
-               pid = fork();
-               if (pid == 0) {
-                       signal(SIGTERM, SIG_DFL);
-                       signal(SIGHUP, SIG_DFL);
-                       signal(SIGALRM, SIG_DFL);
-                       signal(SIGTSTP, SIG_IGN);
-                       if (setsid() < 0)
-                               syslog(LOG_ERR, "setsid failed (single): %m");
-                       (void) revoke(ctty);
-                       if ((fd = open(ctty, O_RDWR)) < 0) {
-                               syslog(LOG_ERR, "open %s: %m", ctty);
-                               exit(1);
-                       }
-                       if (ioctl(fd, TIOCSCTTY, 0) < 0)
-                               syslog(LOG_ERR, "TIOCSCTTY failed: %m");
-                       dup2(fd, 0);
-                       dup2(fd, 1);
-                       dup2(fd, 2);
-                       if (fd > 2)
-                               close(fd);
-                       execl(shell, minus, (char *)0);
-                       perror(shell);
-                       exit(0);
-               }
-               while ((xpid = wait((int *)0)) != pid)
-                       if (xpid == -1 && errno == ECHILD)
-                               break;
-       } while (xpid == -1);
+       sleep(STALL_TIMEOUT);
+       _exit(sig);             /* reboot */

 }
 
 }
 

-runcom(oldhowto)
-       int oldhowto;
+/*
+ * Get the security level of the kernel.
+ */
+int
+getsecuritylevel()

 {
 {

-       register pid;
-       int status;
+#ifdef KERN_SECURELVL
+       int name[2], curlevel;
+       size_t len;
+       extern int errno;

 
 

-       pid = fork();
-       if (pid == 0) {
-               (void) open(ctty, O_RDONLY);
-               dup2(0, 1);
-               dup2(0, 2);
-               if (setsid() < 0)
-                       syslog(LOG_ERR, "setsid failed (runcom) %m");
-               if (ioctl(0, TIOCSCTTY, 0) < 0) 
-                       syslog(LOG_ERR, "TIOCSCTTY failed (runcom) %m");
-               if (oldhowto & RB_SINGLE)
-                       execl(shell, shell, runc, (char *)0);
-               else
-                       execl(shell, shell, runc, "autoboot", (char *)0);
-               exit(1);
+       name[0] = CTL_KERN;
+       name[1] = KERN_SECURELVL;
+       len = sizeof curlevel;
+       if (sysctl(name, 2, &curlevel, &len, NULL, 0) == -1) {
+               emergency("cannot get kernel security level: %s",
+                   strerror(errno));
+               return (-1);

        }
        }

-       while (wait(&status) != pid)
-               ;
-       if (status)
-               return (0);
-       logwtmp("~", "reboot", "");
-       return (1);
+       return (curlevel);
+#else
+       return (-1);
+#endif

 }
 
 }
 

-struct sigvec  mvec = { merge, sigmask(SIGTERM), 0 };

 /*
 /*

- * Multi-user.  Listen for users leaving, SIGHUP's
- * which indicate ttys has changed, and SIGTERM's which
- * are used to shutdown the system.
+ * Set the security level of the kernel.

  */
  */

-multiple()
+void
+setsecuritylevel(newlevel)
+       int newlevel;

 {
 {

+#ifdef KERN_SECURELVL
+       int name[2], curlevel;

        extern int errno;
        extern int errno;

-       register struct tab *p;
-       register pid;
-       int omask;
-
-       sigvec(SIGHUP, &mvec, (struct sigvec *)0);
-       for (EVER) {
-               pid = wait((int *)0);
-/* SHOULD FIX THIS IN THE KERNEL */
-               if (pid == -1 && errno != EINTR)
-                       return;
-               omask = sigblock(sigmask(SIGHUP));
-               for (ALL) {
-                       /* must restart window system BEFORE emulator */
-                       if (p->wpid == pid || p->wpid == -1)
-                               wstart(p);
-                       if (p->pid == pid || p->pid == -1) {
-                               /* disown the window system */
-                               if (p->wpid)
-                                       kill(p->wpid, SIGHUP);
-                               cleanutmp(p);
-                               dfork(p);
-                       }
-               }
-               sigsetmask(omask);
+
+       curlevel = getsecuritylevel();
+       if (newlevel == curlevel)
+               return;
+       name[0] = CTL_KERN;
+       name[1] = KERN_SECURELVL;
+       if (sysctl(name, 2, NULL, NULL, &newlevel, sizeof newlevel) == -1) {
+               emergency(
+                   "cannot change kernel security level from %d to %d: %s",
+                   curlevel, newlevel, strerror(errno));
+               return;

        }
        }

+#ifdef SECURE
+       warning("kernel security level changed from %d to %d",
+           curlevel, newlevel);
+#endif
+#endif

 }
 
 /*
 }
 
 /*

- * Merge current contents of ttys file
- * into in-core table of configured tty lines.
- * Entered as signal handler for SIGHUP.
+ * Change states in the finite state machine.
+ * The initial state is passed as an argument.

  */
  */

-#define        FOUND   1
-#define        CHANGE  2
-#define WCHANGE 4
+void
+transition(s)
+       state_t s;
+{
+       for (;;)
+               s = (state_t) (*s)();
+}

 
 

+/*
+ * Close out the accounting files for a login session.
+ * NB: should send a message to the session logger to avoid blocking.
+ */

 void
 void

-merge()
+clear_session_logs(sp)
+       session_t *sp;

 {
 {

-       register struct tab *p;
-       register struct ttyent *t;
-       register struct tab *p1;
+       char *line = sp->se_device + sizeof(_PATH_DEV) - 1;

 
 

-       for (ALL)
-               p->xflag = 0;
-       setttyent();
-       while (t = getttyent()) {
-               if ((t->ty_status & TTY_ON) == 0)
-                       continue;
-               for (ALL) {
-                       if (SCMPN(p->line, t->ty_name))
-                               continue;
-                       p->xflag |= FOUND;
-                       if (SCMPN(p->comn, t->ty_getty)) {
-                               p->xflag |= CHANGE;
-                               SCPYN(p->comn, t->ty_getty);
-                       }
-                       if (SCMPN(p->wcmd, t->ty_window ? t->ty_window : "")) {
-                               p->xflag |= WCHANGE|CHANGE;
-                               SCPYN(p->wcmd, t->ty_window);
+       if (logout(line))
+               logwtmp(line, "", "");
+}
+
+/*
+ * Start a session and allocate a controlling terminal.
+ * Only called by children of init after forking.
+ */
+void
+setctty(name)
+       char *name;
+{
+       int fd;
+
+       (void) revoke(name);
+       sleep (2);                      /* leave DTR low */
+       if ((fd = open(name, O_RDWR)) == -1) {
+               stall("can't open %s: %m", name);
+               _exit(1);
+       }
+       if (login_tty(fd) == -1) {
+               stall("can't get %s for controlling terminal: %m", name);
+               _exit(1);
+       }
+}
+
+/*
+ * Bring the system up single user.
+ */
+state_func_t
+single_user()
+{
+       pid_t pid, wpid;
+       int status;
+       sigset_t mask;
+       char *shell = _PATH_BSHELL;
+       char *argv[2];
+#ifdef SECURE
+       struct ttyent *typ;
+       struct passwd *pp;
+       static const char banner[] =
+               "Enter root password, or ^D to go multi-user\n";
+       char *clear, *password;
+#endif
+
+       /*
+        * If the kernel is in secure mode, downgrade it to insecure mode.
+        */
+       if (getsecuritylevel() > 0)
+               setsecuritylevel(0);
+
+       if ((pid = fork()) == 0) {
+               /*
+                * Start the single user session.
+                */
+               setctty(_PATH_CONSOLE);
+
+#ifdef SECURE
+               /*
+                * Check the root password.
+                * We don't care if the console is 'on' by default;
+                * it's the only tty that can be 'off' and 'secure'.
+                */
+               typ = getttynam("console");
+               pp = getpwnam("root");
+               if (typ && (typ->ty_status & TTY_SECURE) == 0 && pp) {
+                       write(2, banner, sizeof banner - 1);
+                       for (;;) {
+                               clear = getpass("Password:");
+                               if (clear == 0 || *clear == '\0')
+                                       _exit(0);
+                               password = crypt(clear, pp->pw_passwd);
+                               memset(clear, 0, _PASSWORD_LEN);
+                               if (strcmp(password, pp->pw_passwd) == 0)
+                                       break;
+                               warning("single-user login failed\n");

                        }
                        }

-                       goto contin1;

                }
                }

+               endttyent();
+               endpwent();
+#endif /* SECURE */
+
+#ifdef DEBUGSHELL
+               {
+                       char altshell[128], *cp = altshell;
+                       int num;
+
+#define        SHREQUEST \
+       "Enter pathname of shell or RETURN for sh: "
+                       (void)write(STDERR_FILENO,
+                           SHREQUEST, sizeof(SHREQUEST) - 1);
+                       while ((num = read(STDIN_FILENO, cp, 1)) != -1 &&
+                           num != 0 && *cp != '\n' && cp < &altshell[127])
+                                       cp++;
+                       *cp = '\0';
+                       if (altshell[0] != '\0')
+                               shell = altshell;
+               }
+#endif /* DEBUGSHELL */

 
                /*
 
                /*

-                * Make space for a new one
+                * Unblock signals.
+                * We catch all the interesting ones,
+                * and those are reset to SIG_DFL on exec.

                 */
                 */

-               p1 = (struct tab *)calloc(1, sizeof(*p1));
-               if (!p1) {
-                       syslog(LOG_ERR, "no space for '%s' !?!", t->ty_name);
-                       goto contin1;
-               }
+               sigemptyset(&mask);
+               sigprocmask(SIG_SETMASK, &mask, (sigset_t *) 0);
+

                /*
                /*

-                * Put new terminal at the end of the linked list.
+                * Fire off a shell.
+                * If the default one doesn't work, try the Bourne shell.

                 */
                 */

-               if (itab) {
-                       for (p = itab; p->next ; p = p->next)
-                               ;
-                       p->next = p1;
-               } else
-                       itab = p1;
-
-               p = p1;
-               SCPYN(p->line, t->ty_name);
-               p->xflag |= FOUND|CHANGE;
-               SCPYN(p->comn, t->ty_getty);
-               if (t->ty_window && strcmp(t->ty_window, "") != 0) {
-                       p->xflag |= WCHANGE;
-                       SCPYN(p->wcmd, t->ty_window);
-               }
-       contin1:
-               ;
+               argv[0] = "-sh";
+               argv[1] = 0;
+               execv(shell, argv);
+               emergency("can't exec %s for single user: %m", shell);
+               execv(_PATH_BSHELL, argv);
+               emergency("can't exec %s for single user: %m", _PATH_BSHELL);
+               sleep(STALL_TIMEOUT);
+               _exit(1);

        }
        }

-       endttyent();
-       p1 = (struct tab *)0;
-       for (ALL) {
-               if ((p->xflag&FOUND) == 0) {
-                       term(p);
-                       wterm(p);
-                       if (p1)
-                               p1->next = p->next;
-                       else
-                               itab = p->next;
-                       free(p);
-                       p = p1 ? p1 : itab;
-               } else {
-                       /* window system should be started first */
-                       if (p->xflag&WCHANGE) {
-                               wterm(p);
-                               wstart(p);
-                       }
-                       if (p->xflag&CHANGE) {
-                               term(p);
-                               dfork(p);
-                       }
-               }
-               p1 = p;
+
+       if (pid == -1) {
+               /*
+                * We are seriously hosed.  Do our best.
+                */
+               emergency("can't fork single-user shell, trying again");
+               while (waitpid(-1, (int *) 0, WNOHANG) > 0)
+                       continue;
+               return (state_func_t) single_user;

        }
        }

-}

 
 

-term(p)
-       register struct tab *p;
-{
+       requested_transition = 0;
+       do {
+               if ((wpid = waitpid(-1, &status, WUNTRACED)) != -1)
+                       collect_child(wpid);
+               if (wpid == -1) {
+                       if (errno == EINTR)
+                               continue;
+                       warning("wait for single-user shell failed: %m; restarting");
+                       return (state_func_t) single_user;
+               }
+               if (wpid == pid && WIFSTOPPED(status)) {
+                       warning("init: shell stopped, restarting\n");
+                       kill(pid, SIGCONT);
+                       wpid = -1;
+               }
+       } while (wpid != pid && !requested_transition);
+
+       if (requested_transition)
+               return (state_func_t) requested_transition;

 
 

-       if (p->pid != 0) {
-               cleanutmp(p);
-               kill(p->pid, SIGKILL);
+       if (!WIFEXITED(status)) {
+               if (WTERMSIG(status) == SIGKILL) { 
+                       /* 
+                        *  reboot(8) killed shell? 
+                        */
+                       warning("single user shell terminated.");
+                       sleep(STALL_TIMEOUT);
+                       _exit(0);
+               } else {        
+                       warning("single user shell terminated, restarting");
+                       return (state_func_t) single_user;
+               }

        }
        }

-       p->pid = 0;
-       /* send SIGHUP to get rid of connections */
-       if (p->wpid > 0)
-               kill(p->wpid, SIGHUP);
+
+       runcom_mode = FASTBOOT;
+       return (state_func_t) runcom;

 }
 
 }
 

-dfork(p)
-       struct tab *p;
+/*
+ * Run the system startup script.
+ */
+state_func_t
+runcom()

 {
 {

-       register pid;
-       time_t t;
-       int dowait = 0;
+       pid_t pid, wpid;
+       int status;
+       char *argv[4];
+       struct sigaction sa;
+
+       if ((pid = fork()) == 0) {
+               sigemptyset(&sa.sa_mask);
+               sa.sa_flags = 0;
+               sa.sa_handler = SIG_IGN;
+               (void) sigaction(SIGTSTP, &sa, (struct sigaction *)0);
+               (void) sigaction(SIGHUP, &sa, (struct sigaction *)0);
+
+               setctty(_PATH_CONSOLE);

 
 

-       time(&t);
-       p->gettycnt++;
-       if ((t - p->gettytime) >= 60) {
-               p->gettytime = t;
-               p->gettycnt = 1;
-       } else if (p->gettycnt >= 5) {
-               dowait = 1;
-               p->gettytime = t;
-               p->gettycnt = 1;
+               argv[0] = "sh";
+               argv[1] = _PATH_RUNCOM;
+               argv[2] = runcom_mode == AUTOBOOT ? "autoboot" : 0;
+               argv[3] = 0;
+
+               sigprocmask(SIG_SETMASK, &sa.sa_mask, (sigset_t *) 0);
+
+               execv(_PATH_BSHELL, argv);
+               stall("can't exec %s for %s: %m", _PATH_BSHELL, _PATH_RUNCOM);
+               _exit(1);       /* force single user mode */

        }
        }

-       pid = fork();
-       if (pid == 0) {
-               signal(SIGTERM, SIG_DFL);
-               signal(SIGHUP, SIG_IGN);
-               sigsetmask(0);  /* since can be called from masked code */
-               if (dowait) {
-                       syslog(LOG_ERR, "'%s %s' failing, sleeping", p->comn, p->line);
-                       closelog();
-                       sleep(30);
+
+       if (pid == -1) {
+               emergency("can't fork for %s on %s: %m",
+                       _PATH_BSHELL, _PATH_RUNCOM);
+               while (waitpid(-1, (int *) 0, WNOHANG) > 0)
+                       continue;
+               sleep(STALL_TIMEOUT);
+               return (state_func_t) single_user;
+       }
+
+       /*
+        * Copied from single_user().  This is a bit paranoid.
+        */
+       do {
+               if ((wpid = waitpid(-1, &status, WUNTRACED)) != -1)
+                       collect_child(wpid);
+               if (wpid == -1) {
+                       if (errno == EINTR)
+                               continue;
+                       warning("wait for %s on %s failed: %m; going to single user mode",
+                               _PATH_BSHELL, _PATH_RUNCOM);
+                       return (state_func_t) single_user;

                }
                }

-               if (setsid() < 0)
-                       syslog(LOG_ERR, "setsid failed(dfork) %m");
-               execit(p->comn, p->line);
-               exit(0);
+               if (wpid == pid && WIFSTOPPED(status)) {
+                       warning("init: %s on %s stopped, restarting\n",
+                               _PATH_BSHELL, _PATH_RUNCOM);
+                       kill(pid, SIGCONT);
+                       wpid = -1;
+               }
+       } while (wpid != pid);
+
+       if (WIFSIGNALED(status) && WTERMSIG(status) == SIGTERM &&
+           requested_transition == catatonia) {
+               /* /etc/rc executed /sbin/reboot; wait for the end quietly */
+               sigset_t s;
+
+               sigfillset(&s);
+               for (;;)
+                       sigsuspend(&s);

        }
        }

-       p->pid = pid;
+
+       if (!WIFEXITED(status)) {
+               warning("%s on %s terminated abnormally, going to single user mode",
+                       _PATH_BSHELL, _PATH_RUNCOM);
+               return (state_func_t) single_user;
+       }
+
+       if (WEXITSTATUS(status))
+               return (state_func_t) single_user;
+
+       runcom_mode = AUTOBOOT;         /* the default */
+       /* NB: should send a message to the session logger to avoid blocking. */
+       logwtmp("~", "reboot", "");
+       return (state_func_t) read_ttys;

 }
 
 }
 

-cleanutmp(p)
-       register struct tab *p;
+/*
+ * Open the session database.
+ *
+ * NB: We could pass in the size here; is it necessary?
+ */
+int
+start_session_db()

 {
 {

-       if (logout(p->line)) {
-               logwtmp(p->line, "", "");
-               /*
-                * After a proper login force reset
-                * of error detection code in dfork.
-                */
-               p->gettytime = 0;
-               p->windtime = 0;
+       if (session_db && (*session_db->close)(session_db))
+               emergency("session database close: %s", strerror(errno));
+       if ((session_db = dbopen(NULL, O_RDWR, 0, DB_HASH, NULL)) == 0) {
+               emergency("session database open: %s", strerror(errno));
+               return (1);

        }
        }

+       return (0);
+               

 }
 
 }
 

+/*
+ * Add a new login session.
+ */

 void
 void

-reset()
+add_session(sp)
+       session_t *sp;

 {
 {

-       longjmp(sjbuf, 1);
-}
+       DBT key;
+       DBT data;
+
+       key.data = &sp->se_process;
+       key.size = sizeof sp->se_process;
+       data.data = &sp;
+       data.size = sizeof sp;

 
 

-jmp_buf        idlebuf;
+       if ((*session_db->put)(session_db, &key, &data, 0))
+               emergency("insert %d: %s", sp->se_process, strerror(errno));
+}

 
 

+/*
+ * Delete an old login session.
+ */

 void
 void

-idlehup()
+del_session(sp)
+       session_t *sp;

 {
 {

-       longjmp(idlebuf, 1);
+       DBT key;
+
+       key.data = &sp->se_process;
+       key.size = sizeof sp->se_process;
+
+       if ((*session_db->del)(session_db, &key, 0))
+               emergency("delete %d: %s", sp->se_process, strerror(errno));
+}
+
+/*
+ * Look up a login session by pid.
+ */
+session_t *
+#ifdef __STDC__
+find_session(pid_t pid)
+#else
+find_session(pid)
+       pid_t pid;
+#endif
+{
+       DBT key;
+       DBT data;
+       session_t *ret;
+
+       key.data = &pid;
+       key.size = sizeof pid;
+       if ((*session_db->get)(session_db, &key, &data, 0) != 0)
+               return 0;
+       memmove(&ret, data.data, sizeof(ret));
+       return ret;

 }
 
 }
 

+/*
+ * Construct an argument vector from a command line.
+ */
+char **
+construct_argv(command)
+       char *command;
+{
+       register int argc = 0;
+       register char **argv = (char **) malloc(((strlen(command) + 1) / 2 + 1)
+                                               * sizeof (char *));
+       static const char separators[] = " \t";
+
+       if ((argv[argc++] = strtok(command, separators)) == 0)
+               return 0;
+       while (argv[argc++] = strtok((char *) 0, separators))
+               continue;
+       return argv;
+}
+
+/*
+ * Deallocate a session descriptor.
+ */

 void
 void

-idle()
-{
-       register struct tab *p;
-       register pid;
-
-       signal(SIGHUP, idlehup);
-       for (EVER) {
-               if (setjmp(idlebuf))
-                       return;
-               pid = wait((int *) 0);
-               if (pid == -1) {
-                       sigpause(0);
-                       continue;
-               }
-               for (ALL) {
-                       /* if window system dies, mark it for restart */
-                       if (p->wpid == pid)
-                               p->wpid = -1;
-                       if (p->pid == pid) {
-                               cleanutmp(p);
-                               p->pid = -1;
-                       }
+free_session(sp)
+       register session_t *sp;
+{
+       free(sp->se_device);
+       if (sp->se_getty) {
+               free(sp->se_getty);
+               free(sp->se_getty_argv);
+       }
+       if (sp->se_window) {
+               free(sp->se_window);
+               free(sp->se_window_argv);
+       }
+       free(sp);
+}
+
+/*
+ * Allocate a new session descriptor.
+ */
+session_t *
+new_session(sprev, session_index, typ)
+       session_t *sprev;
+       int session_index;
+       register struct ttyent *typ;
+{
+       register session_t *sp;
+
+       if ((typ->ty_status & TTY_ON) == 0 ||
+           typ->ty_name == 0 ||
+           typ->ty_getty == 0)
+               return 0;
+
+       sp = (session_t *) malloc(sizeof (session_t));
+       memset(sp, 0, sizeof *sp);
+
+       sp->se_index = session_index;
+
+       sp->se_device = malloc(sizeof(_PATH_DEV) + strlen(typ->ty_name));
+       (void) sprintf(sp->se_device, "%s%s", _PATH_DEV, typ->ty_name);
+
+       if (setupargv(sp, typ) == 0) {
+               free_session(sp);
+               return (0);
+       }
+
+       sp->se_next = 0;
+       if (sprev == 0) {
+               sessions = sp;
+               sp->se_prev = 0;
+       } else {
+               sprev->se_next = sp;
+               sp->se_prev = sprev;
+       }
+
+       return sp;
+}
+
+/*
+ * Calculate getty and if useful window argv vectors.
+ */
+int
+setupargv(sp, typ)
+       session_t *sp;
+       struct ttyent *typ;
+{
+
+       if (sp->se_getty) {
+               free(sp->se_getty);
+               free(sp->se_getty_argv);
+       }
+       sp->se_getty = malloc(strlen(typ->ty_getty) + strlen(typ->ty_name) + 2);
+       (void) sprintf(sp->se_getty, "%s %s", typ->ty_getty, typ->ty_name);
+       sp->se_getty_argv = construct_argv(sp->se_getty);
+       if (sp->se_getty_argv == 0) {
+               warning("can't parse getty for port %s", sp->se_device);
+               free(sp->se_getty);
+               sp->se_getty = 0;
+               return (0);
+       }
+       if (typ->ty_window) {
+               if (sp->se_window)
+                       free(sp->se_window);
+               sp->se_window = strdup(typ->ty_window);
+               sp->se_window_argv = construct_argv(sp->se_window);
+               if (sp->se_window_argv == 0) {
+                       warning("can't parse window for port %s",
+                               sp->se_device);
+                       free(sp->se_window);
+                       sp->se_window = 0;
+                       return (0);

                }
        }
                }
        }

+       return (1);

 }
 
 }
 

-wterm(p)
-       register struct tab *p;
+/*
+ * Walk the list of ttys and create sessions for each active line.
+ */
+state_func_t
+read_ttys()

 {
 {

-       if (p->wpid != 0) {
-               kill(p->wpid, SIGKILL);
+       int session_index = 0;
+       register session_t *sp, *snext;
+       register struct ttyent *typ;
+
+       /*
+        * Destroy any previous session state.
+        * There shouldn't be any, but just in case...
+        */
+       for (sp = sessions; sp; sp = snext) {
+               if (sp->se_process)
+                       clear_session_logs(sp);
+               snext = sp->se_next;
+               free_session(sp);

        }
        }

-       p->wpid = 0;
+       sessions = 0;
+       if (start_session_db())
+               return (state_func_t) single_user;
+
+       /*
+        * Allocate a session entry for each active port.
+        * Note that sp starts at 0.
+        */
+       while (typ = getttyent())
+               if (snext = new_session(sp, ++session_index, typ))
+                       sp = snext;
+
+       endttyent();
+
+       return (state_func_t) multi_user;

 }
 
 }
 

-wstart(p)
-       register struct tab *p;
+/*
+ * Start a window system running.
+ */
+void
+start_window_system(sp)
+       session_t *sp;

 {
 {

-       register pid;
-       time_t t;
-       int dowait = 0;
+       pid_t pid;
+       sigset_t mask;

 
 

-       time(&t);
-       p->windcnt++;
-       if ((t - p->windtime) >= 60) {
-               p->windtime = t;
-               p->windcnt = 1;
-       } else if (p->windcnt >= 5) {
-               dowait = 1;
-               p->windtime = t;
-               p->windcnt = 1;
+       if ((pid = fork()) == -1) {
+               emergency("can't fork for window system on port %s: %m",
+                       sp->se_device);
+               /* hope that getty fails and we can try again */
+               return;

        }
 
        }
 

-       pid = fork();
+       if (pid)
+               return;

 
 

-       if (pid == 0) {
-               signal(SIGTERM, SIG_DFL);
-               signal(SIGHUP,  SIG_IGN);
-               sigsetmask(0);  /* since can be called from masked code */
-               if (dowait) {
-                       syslog(LOG_ERR, "'%s %s' failing, sleeping", p->wcmd, p->line);
-                       closelog();
-                       sleep(30);
-               }
-               if (setsid() < 0)
-                       syslog(LOG_ERR, "setsid failed (window) %m");
-               execit(p->wcmd, p->line);
-               exit(0);
+       sigemptyset(&mask);
+       sigprocmask(SIG_SETMASK, &mask, (sigset_t *) 0);
+
+       if (setsid() < 0)
+               emergency("setsid failed (window) %m");
+
+       execv(sp->se_window_argv[0], sp->se_window_argv);
+       stall("can't exec window system '%s' for port %s: %m",
+               sp->se_window_argv[0], sp->se_device);
+       _exit(1);
+}
+
+/*
+ * Start a login session running.
+ */
+pid_t
+start_getty(sp)
+       session_t *sp;
+{
+       pid_t pid;
+       sigset_t mask;
+       time_t current_time = time((time_t *) 0);
+
+       /*
+        * fork(), not vfork() -- we can't afford to block.
+        */
+       if ((pid = fork()) == -1) {
+               emergency("can't fork for getty on port %s: %m", sp->se_device);
+               return -1;
+       }
+
+       if (pid)
+               return pid;
+
+       if (current_time > sp->se_started &&
+           current_time - sp->se_started < GETTY_SPACING) {
+               warning("getty repeating too quickly on port %s, sleeping",
+                       sp->se_device);
+               sleep((unsigned) GETTY_SLEEP);

        }
        }

-       p->wpid = pid;
+
+       if (sp->se_window) {
+               start_window_system(sp);
+               sleep(WINDOW_WAIT);
+       }
+
+       sigemptyset(&mask);
+       sigprocmask(SIG_SETMASK, &mask, (sigset_t *) 0);
+
+       execv(sp->se_getty_argv[0], sp->se_getty_argv);
+       stall("can't exec getty '%s' for port %s: %m",
+               sp->se_getty_argv[0], sp->se_device);
+       _exit(1);

 }
 
 }
 

-#define NARGS  20      /* must be at least 4 */
-#define ARGLEN 512     /* total size for all the argument strings */
+/*
+ * Collect exit status for a child.
+ * If an exiting login, start a new login running.
+ */
+void
+#ifdef __STDC__
+collect_child(pid_t pid)
+#else
+collect_child(pid)
+       pid_t pid;
+#endif
+{
+       register session_t *sp, *sprev, *snext;
+
+       if (! sessions)
+               return;
+
+       if (! (sp = find_session(pid)))
+               return;
+
+       clear_session_logs(sp);
+       del_session(sp);
+       sp->se_process = 0;
+
+       if (sp->se_flags & SE_SHUTDOWN) {
+               if (sprev = sp->se_prev)
+                       sprev->se_next = sp->se_next;
+               else
+                       sessions = sp->se_next;
+               if (snext = sp->se_next)
+                       snext->se_prev = sp->se_prev;
+               free_session(sp);
+               return;
+       }

 
 

-execit(s, arg)
-       char *s;
-       char *arg;      /* last argument on line */
+       if ((pid = start_getty(sp)) == -1) {
+               /* serious trouble */
+               requested_transition = clean_ttys;
+               return;
+       }
+
+       sp->se_process = pid;
+       sp->se_started = time((time_t *) 0);
+       add_session(sp);
+}
+
+/*
+ * Catch a signal and request a state transition.
+ */
+void
+transition_handler(sig)
+       int sig;

 {
 {

-       char *argv[NARGS], args[ARGLEN], *envp[1];
-       register char *sp = s;
-       register char *ap = args;
-       register char c;
-       register int i;
+
+       switch (sig) {
+       case SIGHUP:
+               requested_transition = clean_ttys;
+               break;
+       case SIGTERM:
+               requested_transition = death;
+               break;
+       case SIGTSTP:
+               requested_transition = catatonia;
+               break;
+       default:
+               requested_transition = 0;
+               break;
+       }
+}
+
+/*
+ * Take the system multiuser.
+ */
+state_func_t
+multi_user()
+{
+       pid_t pid;
+       register session_t *sp;
+
+       requested_transition = 0;

 
        /*
 
        /*

-        * First we have to set up the argument vector.
-        * "prog arg1 arg2" maps to exec("prog", "-", "arg1", "arg2"). 
+        * If the administrator has not set the security level to -1
+        * to indicate that the kernel should not run multiuser in secure
+        * mode, and the run script has not set a higher level of security 
+        * than level 1, then put the kernel into secure mode.

         */
         */

-       for (i = 1; i < NARGS - 2; i++) {
-               argv[i] = ap;
-               for (EVER) {
-                       if ((c = *sp++) == '\0' || ap >= &args[ARGLEN-1]) {
-                               *ap = '\0';
-                               goto done;
-                       }
-                       if (c == ' ') {
-                               *ap++ = '\0';
-                               while (*sp == ' ')
-                                       sp++;
-                               if (*sp == '\0')
-                                       goto done;
+       if (getsecuritylevel() == 0)
+               setsecuritylevel(1);
+
+       for (sp = sessions; sp; sp = sp->se_next) {
+               if (sp->se_process)
+                       continue;
+               if ((pid = start_getty(sp)) == -1) {
+                       /* serious trouble */
+                       requested_transition = clean_ttys;
+                       break;
+               }
+               sp->se_process = pid;
+               sp->se_started = time((time_t *) 0);
+               add_session(sp);
+       }
+
+       while (!requested_transition)
+               if ((pid = waitpid(-1, (int *) 0, 0)) != -1)
+                       collect_child(pid);
+
+       return (state_func_t) requested_transition;
+}
+
+/*
+ * This is an n-squared algorithm.  We hope it isn't run often...
+ */
+state_func_t
+clean_ttys()
+{
+       register session_t *sp, *sprev;
+       register struct ttyent *typ;
+       register int session_index = 0;
+       register int devlen;
+
+       if (! sessions)
+               return (state_func_t) multi_user;
+
+       devlen = sizeof(_PATH_DEV) - 1;
+       while (typ = getttyent()) {
+               ++session_index;
+
+               for (sprev = 0, sp = sessions; sp; sprev = sp, sp = sp->se_next)
+                       if (strcmp(typ->ty_name, sp->se_device + devlen) == 0)

                                break;
                                break;

+
+               if (sp) {
+                       if (sp->se_index != session_index) {
+                               warning("port %s changed utmp index from %d to %d",
+                                      sp->se_device, sp->se_index,
+                                      session_index);
+                               sp->se_index = session_index;
+                       }
+                       if ((typ->ty_status & TTY_ON) == 0 ||
+                           typ->ty_getty == 0) {
+                               sp->se_flags |= SE_SHUTDOWN;
+                               kill(sp->se_process, SIGHUP);
+                               continue;

                        }
                        }

-                       *ap++ = c;
+                       sp->se_flags &= ~SE_SHUTDOWN;
+                       if (setupargv(sp, typ) == 0) {
+                               warning("can't parse getty for port %s",
+                                       sp->se_device);
+                               sp->se_flags |= SE_SHUTDOWN;
+                               kill(sp->se_process, SIGHUP);
+                       }
+                       continue;

                }
                }

+
+               new_session(sprev, session_index, typ);

        }
        }

-done:
-       argv[0] = argv[1];
-       argv[1] = "-";
-       argv[i+1] = arg;
-       argv[i+2] = 0;
-       envp[0] = 0;
-       execve(argv[0], &argv[1], envp);
-       /* report failure of exec */
-       syslog(LOG_ERR, "%s: %m", argv[0]);
-       closelog();
-       sleep(10);      /* prevent failures from eating machine */
+
+       endttyent();
+
+       return (state_func_t) multi_user;
+}
+
+/*
+ * Block further logins.
+ */
+state_func_t
+catatonia()
+{
+       register session_t *sp;
+
+       for (sp = sessions; sp; sp = sp->se_next)
+               sp->se_flags |= SE_SHUTDOWN;
+
+       return (state_func_t) multi_user;
+}
+
+/*
+ * Note SIGALRM.
+ */
+void
+alrm_handler(sig)
+       int sig;
+{
+       clang = 1;
+}
+
+/*
+ * Bring the system down to single user.
+ */
+state_func_t
+death()
+{
+       register session_t *sp;
+       register int i;
+       pid_t pid;
+       static const int death_sigs[3] = { SIGHUP, SIGTERM, SIGKILL };
+
+       for (sp = sessions; sp; sp = sp->se_next)
+               sp->se_flags |= SE_SHUTDOWN;
+
+       /* NB: should send a message to the session logger to avoid blocking. */
+       logwtmp("~", "shutdown", "");
+
+       for (i = 0; i < 3; ++i) {
+               if (kill(-1, death_sigs[i]) == -1 && errno == ESRCH)
+                       return (state_func_t) single_user;
+
+               clang = 0;
+               alarm(DEATH_WATCH);
+               do
+                       if ((pid = waitpid(-1, (int *)0, 0)) != -1)
+                               collect_child(pid);
+               while (clang == 0 && errno != ECHILD);
+
+               if (errno == ECHILD)
+                       return (state_func_t) single_user;
+       }
+
+       warning("some processes would not die; ps axl advised");
+
+       return (state_func_t) single_user;

 }
 }