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