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

/*
 * 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.
 */

#ifndef lint
static char sccsid[] = "@(#)init.c	5.8 (Berkeley) %G%";
#endif not lint

#include <signal.h>
#include <sys/types.h>
#include <utmp.h>
#include <setjmp.h>
#include <sys/reboot.h>
#include <errno.h>
#include <sys/file.h>
#include <ttyent.h>
#include <sys/syslog.h>
#include <sys/stat.h>

#define	LINSIZ	sizeof(wtmp.ut_line)
#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[]	= "/bin/sh";
char	minus[]	= "-";
char	runc[]	= "/etc/rc";
char	utmpf[]	= "/etc/utmp";
char	wtmpf[]	= "/usr/adm/wtmp";
char	ctty[]	= "/dev/console";

struct utmp wtmp;
struct	tab
{
	char	line[LINSIZ];
	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;
time_t	time0;

int	reset();
int	idle();
char	*strcpy(), *strcat();
long	lseek();

struct	sigvec rvec = { reset, sigmask(SIGHUP), 0 };


#if defined(vax) || defined(tahoe)
main()
{
#if defined(tahoe)
	register int r12;		/* make sure r11 gets bootflags */
#endif
	register int r11;		/* passed thru from boot */
#else
main(argc, argv)
	char **argv;
{
#endif
	int howto, oldhowto;

	time0 = time(0);
#if defined(vax) || defined(tahoe)
	howto = r11;
#else
	if (argc > 1 && argv[1][0] == '-') {
		char *cp;

		howto = 0;
		cp = &argv[1][1];
		while (*cp) switch (*cp++) {
		case 'a':
			howto |= RB_ASKNAME;
			break;
		case 's':
			howto |= RB_SINGLE;
			break;
		}
	} else {
		howto = RB_SINGLE;
	}
#endif
	openlog("init", LOG_CONS|LOG_ODELAY, LOG_AUTH);
	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 (EVER) {
		oldhowto = howto;
		howto = RB_SINGLE;
		if (setjmp(shutpass) == 0)
			shutdown();
		if (oldhowto & RB_SINGLE)
			single();
		if (runcom(oldhowto) == 0) 
			continue;
		merge();
		multiple();
	}
}

int	shutreset();

shutdown()
{
	register i;
	register struct tab *p, *p1;

	close(creat(utmpf, 0644));
	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();
}

char shutfailm[] = "WARNING: Something is hung (won't die); ps axl advised\n";

shutreset()
{
	int status;

	if (fork() == 0) {
		int ct = open(ctty, 1);
		write(ct, shutfailm, sizeof (shutfailm));
		sleep(5);
		exit(1);
	}
	sleep(5);
	shutend();
	longjmp(shutpass, 1);
}

shutend()
{
	register i, f;

	acct(0);
	signal(SIGALRM, SIG_DFL);
	for (i = 0; i < 10; i++)
		close(i);
	f = open(wtmpf, O_WRONLY|O_APPEND);
	if (f >= 0) {
		SCPYN(wtmp.ut_line, "~");
		SCPYN(wtmp.ut_name, "shutdown");
		SCPYN(wtmp.ut_host, "");
		time(&wtmp.ut_time);
		write(f, (char *)&wtmp, sizeof(wtmp));
		close(f);
	}
	return (1);
}

single()
{
	register pid;
	register xpid;
	extern	errno;

	do {
		pid = fork();
		if (pid == 0) {
			signal(SIGTERM, SIG_DFL);
			signal(SIGHUP, SIG_DFL);
			signal(SIGALRM, SIG_DFL);
			signal(SIGTSTP, SIG_IGN);
			(void) open(ctty, O_RDWR);
			dup2(0, 1);
			dup2(0, 2);
			execl(shell, minus, (char *)0);
			perror(shell);
			exit(0);
		}
		while ((xpid = wait((int *)0)) != pid)
			if (xpid == -1 && errno == ECHILD)
				break;
	} while (xpid == -1);
}

runcom(oldhowto)
	int oldhowto;
{
	register pid, f;
	int status;

	pid = fork();
	if (pid == 0) {
		(void) open("/", O_RDONLY);
		dup2(0, 1);
		dup2(0, 2);
		if (oldhowto & RB_SINGLE)
			execl(shell, shell, runc, (char *)0);
		else
			execl(shell, shell, runc, "autoboot", (char *)0);
		exit(1);
	}
	while (wait(&status) != pid)
		;
	if (status)
		return (0);
	f = open(wtmpf, O_WRONLY|O_APPEND);
	if (f >= 0) {
		SCPYN(wtmp.ut_line, "~");
		SCPYN(wtmp.ut_name, "reboot");
		SCPYN(wtmp.ut_host, "");
		if (time0) {
			wtmp.ut_time = time0;
			time0 = 0;
		} else
			time(&wtmp.ut_time);
		write(f, (char *)&wtmp, sizeof(wtmp));
		close(f);
	}
	return (1);
}

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.
 */
multiple()
{
	register struct tab *p;
	register pid;
	int omask;

	sigvec(SIGHUP, &mvec, (struct sigvec *)0);
	for (EVER) {
		pid = wait((int *)0);
		if (pid == -1)
			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);
				rmut(p);
				dfork(p);
			}
		}
		sigsetmask(omask);
	}
}

/*
 * Merge current contents of ttys file
 * into in-core table of configured tty lines.
 * Entered as signal handler for SIGHUP.
 */
#define	FOUND	1
#define	CHANGE	2
#define WCHANGE 4

merge()
{
	register struct tab *p;
	register struct ttyent *t;
	register struct tab *p1;

	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);
			}
			goto contin1;
		}

		/*
		 * Make space for a new one
		 */
		p1 = (struct tab *)calloc(1, sizeof(*p1));
		if (!p1) {
			syslog(LOG_ERR, "no space for '%s' !?!", t->ty_name);
			goto contin1;
		}
		/*
		 * Put new terminal at the end of the linked list.
		 */
		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:
		;
	}
	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;
	}
}

term(p)
	register struct tab *p;
{

	if (p->pid != 0) {
		rmut(p);
		kill(p->pid, SIGKILL);
	}
	p->pid = 0;
	/* send SIGHUP to get rid of connections */
	if (p->wpid > 0)
		kill(p->wpid, SIGHUP);
}

dfork(p)
	struct tab *p;
{
	register pid;
	time_t t;
	int dowait = 0;

	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;
	}
	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);
		}
		execit(p->comn, p->line);
		exit(0);
	}
	p->pid = pid;
}

/*
 * Remove utmp entry.
 */
rmut(p)
	register struct tab *p;
{
	register f;
	int found = 0;
	static unsigned utmpsize;
	static struct utmp *utmp;
	register struct utmp *u;
	int nutmp;
	struct stat statbf;

	f = open(utmpf, O_RDWR);
	if (f >= 0) {
		fstat(f, &statbf);
		if (utmpsize < statbf.st_size) {
			utmpsize = statbf.st_size + 10 * sizeof(struct utmp);
			if (utmp)
				utmp = (struct utmp *)realloc(utmp, utmpsize);
			else
				utmp = (struct utmp *)malloc(utmpsize);
			if (!utmp)
				syslog(LOG_ERR, "utmp malloc failed");
		}
		if (statbf.st_size && utmp) {
			nutmp = read(f, utmp, statbf.st_size);
			nutmp /= sizeof(struct utmp);
			for (u = utmp ; u < &utmp[nutmp] ; u++) {
				if (SCMPN(u->ut_line, p->line) ||
				    u->ut_name[0]==0)
					continue;
				lseek(f, ((long)u)-((long)utmp), L_SET);
				SCPYN(u->ut_name, "");
				SCPYN(u->ut_host, "");
				time(&u->ut_time);
				write(f, (char *)u, sizeof(*u));
				found++;
			}
		}
		close(f);
	}
	if (found) {
		f = open(wtmpf, O_WRONLY|O_APPEND);
		if (f >= 0) {
			SCPYN(wtmp.ut_line, p->line);
			SCPYN(wtmp.ut_name, "");
			SCPYN(wtmp.ut_host, "");
			time(&wtmp.ut_time);
			write(f, (char *)&wtmp, sizeof(wtmp));
			close(f);
		}
		/*
		 * After a proper login force reset
		 * of error detection code in dfork.
		 */
		p->gettytime = 0;
		p->windtime = 0;
	}
}

reset()
{

	longjmp(sjbuf, 1);
}

jmp_buf	idlebuf;

idlehup()
{

	longjmp(idlebuf, 1);
}

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) {
				rmut(p);
				p->pid = -1;
			}
		}
	}
}

wterm(p)
	register struct tab *p;
{
	if (p->wpid != 0) {
		kill(p->wpid, SIGKILL);
	}
	p->wpid = 0;
}

wstart(p)
	register struct tab *p;
{
	register pid;
	time_t t;
	int dowait = 0;

	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;
	}

	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->wcmd, p->line);
			closelog();
			sleep(30);
		}
		execit(p->wcmd, p->line);
		exit(0);
	}
	p->wpid = pid;
}

#define NARGS	20	/* must be at least 4 */
#define ARGLEN	512	/* total size for all the argument strings */

execit(s, arg)
	char *s;
	char *arg;	/* last argument on line */
{
	char *argv[NARGS], args[ARGLEN], *envp[1];
	register char *sp = s;
	register char *ap = args;
	register char c;
	register int i;

	/*
	 * First we have to set up the argument vector.
	 * "prog arg1 arg2" maps to exec("prog", "-", "arg1", "arg2"). 
	 */
	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;
				break;
			}
			*ap++ = c;
		}
	}
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 */
}
Commit	Line	Data
528b0614	1	/*
b0af3d20	2	* Copyright (c) 1980,1986 Regents of the University of California.
528b0614 DF	3	* All rights reserved. The Berkeley software License Agreement
	4	* specifies the terms and conditions for redistribution.
	5	*/
	6
37c640e2	7	#ifndef lint
381dc986	8	static char sccsid[] = "@(#)init.c 5.8 (Berkeley) %G%";
528b0614	9	#endif not lint
37c640e2	10
7c8ab0e6 BJ	11	#include <signal.h>
	12	#include <sys/types.h>
	13	#include <utmp.h>
	14	#include <setjmp.h>
215943cc	15	#include <sys/reboot.h>
f570e1ff	16	#include <errno.h>
d0ca48ff	17	#include <sys/file.h>
9479aa87	18	#include <ttyent.h>
b0af3d20	19	#include <sys/syslog.h>
25efc242	20	#include <sys/stat.h>
7c8ab0e6 BJ	21
7c8ab0e6 BJ	22	#define LINSIZ sizeof(wtmp.ut_line)
0dfaf495	23	#define CMDSIZ 200 /* max string length for getty or window command*/
25efc242	24	#define ALL p = itab; p ; p = p->next
7c8ab0e6 BJ	25	#define EVER ;;
	26	#define SCPYN(a, b) strncpy(a, b, sizeof(a))
	27	#define SCMPN(a, b) strncmp(a, b, sizeof(a))
	28
	29	char shell[] = "/bin/sh";
7c8ab0e6 BJ	30	char minus[] = "-";
7c8ab0e6 BJ	31	char runc[] = "/etc/rc";
25efc242	32	char utmpf[] = "/etc/utmp";
7c8ab0e6 BJ	33	char wtmpf[] = "/usr/adm/wtmp";
7c8ab0e6 BJ	34	char ctty[] = "/dev/console";
7c8ab0e6 BJ	35
7c8ab0e6 BJ	36	struct utmp wtmp;
7c8ab0e6 BJ	37	struct tab
	38	{
	39	char line[LINSIZ];
068e4187	40	char comn[CMDSIZ];
7c8ab0e6 BJ	41	char xflag;
7c8ab0e6 BJ	42	int pid;
068e4187 RC	43	int wpid; /* window system pid for SIGHUP */
068e4187 RC	44	char wcmd[CMDSIZ]; /* command to start window system process */
43236707 BJ	45	time_t gettytime;
43236707 BJ	46	int gettycnt;
a936c74e MK	47	time_t windtime;
a936c74e MK	48	int windcnt;
25efc242 JB	49	struct tab *next;
25efc242 JB	50	} *itab;
7c8ab0e6 BJ	51
	52	int fi;
	53	int mergflag;
	54	char tty[20];
abf0db3c	55	jmp_buf sjbuf, shutpass;
f570e1ff	56	time_t time0;
7c8ab0e6 BJ	57
7c8ab0e6 BJ	58	int reset();
f570e1ff	59	int idle();
7c8ab0e6 BJ	60	char strcpy(), strcat();
	61	long lseek();
	62
068e4187	63	struct sigvec rvec = { reset, sigmask(SIGHUP), 0 };
d0ca48ff	64
25efc242	65
e618cb0b	66	#if defined(vax) \|\| defined(tahoe)
7c8ab0e6 BJ	67	main()
7c8ab0e6 BJ	68	{
e618cb0b SL	69	#if defined(tahoe)
	70	register int r12; /* make sure r11 gets bootflags */
	71	#endif
215943cc	72	register int r11; /* passed thru from boot */
d0ca48ff	73	#else
8d3a6b89 TL	74	main(argc, argv)
	75	char **argv;
	76	{
d0ca48ff	77	#endif
215943cc BJ	78	int howto, oldhowto;
215943cc BJ	79
f570e1ff	80	time0 = time(0);
e618cb0b	81	#if defined(vax) \|\| defined(tahoe)
215943cc	82	howto = r11;
d0ca48ff	83	#else
8d3a6b89 TL	84	if (argc > 1 && argv[1][0] == '-') {
	85	char *cp;
	86
	87	howto = 0;
	88	cp = &argv[1][1];
	89	while (cp) switch (cp++) {
	90	case 'a':
	91	howto \|= RB_ASKNAME;
	92	break;
	93	case 's':
	94	howto \|= RB_SINGLE;
	95	break;
	96	}
	97	} else {
	98	howto = RB_SINGLE;
	99	}
d0ca48ff	100	#endif
076ae92c	101	openlog("init", LOG_CONS\|LOG_ODELAY, LOG_AUTH);
d0ca48ff	102	sigvec(SIGTERM, &rvec, (struct sigvec *)0);
f570e1ff	103	signal(SIGTSTP, idle);
7c8ab0e6	104	signal(SIGSTOP, SIG_IGN);
7c8ab0e6 BJ	105	signal(SIGTTIN, SIG_IGN);
7c8ab0e6 BJ	106	signal(SIGTTOU, SIG_IGN);
d0ca48ff SL	107	(void) setjmp(sjbuf);
d0ca48ff SL	108	for (EVER) {
215943cc BJ	109	oldhowto = howto;
215943cc BJ	110	howto = RB_SINGLE;
abf0db3c BJ	111	if (setjmp(shutpass) == 0)
abf0db3c BJ	112	shutdown();
215943cc BJ	113	if (oldhowto & RB_SINGLE)
	114	single();
	115	if (runcom(oldhowto) == 0)
	116	continue;
7c8ab0e6 BJ	117	merge();
	118	multiple();
	119	}
	120	}
	121
abf0db3c BJ	122	int shutreset();
abf0db3c BJ	123
7c8ab0e6 BJ	124	shutdown()
	125	{
	126	register i;
25efc242	127	register struct tab p, p1;
7c8ab0e6	128
25efc242	129	close(creat(utmpf, 0644));
7c8ab0e6	130	signal(SIGHUP, SIG_IGN);
25efc242	131	for (p = itab; p ; ) {
7c8ab0e6	132	term(p);
25efc242 JB	133	p1 = p->next;
	134	free(p);
	135	p = p1;
7c8ab0e6	136	}
25efc242	137	itab = (struct tab *)0;
abf0db3c	138	signal(SIGALRM, shutreset);
b0af3d20 MK	139	(void) kill(-1, SIGTERM); /* one chance to catch it */
b0af3d20 MK	140	sleep(5);
abf0db3c	141	alarm(30);
d0ca48ff	142	for (i = 0; i < 5; i++)
7c8ab0e6	143	kill(-1, SIGKILL);
d0ca48ff	144	while (wait((int *)0) != -1)
7c8ab0e6 BJ	145	;
7c8ab0e6 BJ	146	alarm(0);
abf0db3c BJ	147	shutend();
	148	}
	149
381dc986	150	char shutfailm[] = "WARNING: Something is hung (won't die); ps axl advised\n";
abf0db3c BJ	151
	152	shutreset()
	153	{
	154	int status;
	155
	156	if (fork() == 0) {
	157	int ct = open(ctty, 1);
	158	write(ct, shutfailm, sizeof (shutfailm));
	159	sleep(5);
	160	exit(1);
	161	}
	162	sleep(5);
	163	shutend();
	164	longjmp(shutpass, 1);
	165	}
	166
	167	shutend()
	168	{
f570e1ff	169	register i, f;
abf0db3c	170
f570e1ff	171	acct(0);
7c8ab0e6	172	signal(SIGALRM, SIG_DFL);
d0ca48ff	173	for (i = 0; i < 10; i++)
7c8ab0e6	174	close(i);
d0ca48ff	175	f = open(wtmpf, O_WRONLY\|O_APPEND);
f570e1ff	176	if (f >= 0) {
f570e1ff BJ	177	SCPYN(wtmp.ut_line, "~");
f570e1ff BJ	178	SCPYN(wtmp.ut_name, "shutdown");
37c640e2	179	SCPYN(wtmp.ut_host, "");
f570e1ff BJ	180	time(&wtmp.ut_time);
	181	write(f, (char *)&wtmp, sizeof(wtmp));
	182	close(f);
	183	}
d0ca48ff	184	return (1);
7c8ab0e6 BJ	185	}
	186
	187	single()
	188	{
	189	register pid;
f570e1ff BJ	190	register xpid;
f570e1ff BJ	191	extern errno;
7c8ab0e6	192
d0ca48ff SL	193	do {
	194	pid = fork();
	195	if (pid == 0) {
	196	signal(SIGTERM, SIG_DFL);
	197	signal(SIGHUP, SIG_DFL);
	198	signal(SIGALRM, SIG_DFL);
9479aa87	199	signal(SIGTSTP, SIG_IGN);
d0ca48ff SL	200	(void) open(ctty, O_RDWR);
	201	dup2(0, 1);
	202	dup2(0, 2);
	203	execl(shell, minus, (char *)0);
381dc986	204	perror(shell);
d0ca48ff SL	205	exit(0);
	206	}
	207	while ((xpid = wait((int *)0)) != pid)
	208	if (xpid == -1 && errno == ECHILD)
	209	break;
	210	} while (xpid == -1);
7c8ab0e6 BJ	211	}
7c8ab0e6 BJ	212
215943cc BJ	213	runcom(oldhowto)
215943cc BJ	214	int oldhowto;
7c8ab0e6 BJ	215	{
7c8ab0e6 BJ	216	register pid, f;
215943cc	217	int status;
7c8ab0e6 BJ	218
7c8ab0e6 BJ	219	pid = fork();
d0ca48ff SL	220	if (pid == 0) {
	221	(void) open("/", O_RDONLY);
	222	dup2(0, 1);
	223	dup2(0, 2);
215943cc BJ	224	if (oldhowto & RB_SINGLE)
	225	execl(shell, shell, runc, (char *)0);
	226	else
	227	execl(shell, shell, runc, "autoboot", (char *)0);
	228	exit(1);
7c8ab0e6	229	}
d0ca48ff	230	while (wait(&status) != pid)
7c8ab0e6	231	;
d0ca48ff SL	232	if (status)
	233	return (0);
	234	f = open(wtmpf, O_WRONLY\|O_APPEND);
7c8ab0e6	235	if (f >= 0) {
7c8ab0e6 BJ	236	SCPYN(wtmp.ut_line, "~");
7c8ab0e6 BJ	237	SCPYN(wtmp.ut_name, "reboot");
37c640e2	238	SCPYN(wtmp.ut_host, "");
f570e1ff BJ	239	if (time0) {
	240	wtmp.ut_time = time0;
	241	time0 = 0;
	242	} else
	243	time(&wtmp.ut_time);
7c8ab0e6 BJ	244	write(f, (char *)&wtmp, sizeof(wtmp));
	245	close(f);
	246	}
d0ca48ff	247	return (1);
7c8ab0e6 BJ	248	}
7c8ab0e6 BJ	249
068e4187	250	struct sigvec mvec = { merge, sigmask(SIGTERM), 0 };
d0ca48ff SL	251	/*
	252	* Multi-user. Listen for users leaving, SIGHUP's
	253	* which indicate ttys has changed, and SIGTERM's which
	254	* are used to shutdown the system.
	255	*/
7c8ab0e6 BJ	256	multiple()
	257	{
	258	register struct tab *p;
	259	register pid;
25efc242	260	int omask;
7c8ab0e6	261
d0ca48ff SL	262	sigvec(SIGHUP, &mvec, (struct sigvec *)0);
d0ca48ff SL	263	for (EVER) {
7c8ab0e6	264	pid = wait((int *)0);
d0ca48ff	265	if (pid == -1)
7c8ab0e6	266	return;
381dc986	267	omask = sigblock(sigmask(SIGHUP));
068e4187 RC	268	for (ALL) {
	269	/* must restart window system BEFORE emulator */
	270	if (p->wpid == pid \|\| p->wpid == -1)
	271	wstart(p);
d0ca48ff	272	if (p->pid == pid \|\| p->pid == -1) {
068e4187 RC	273	/* disown the window system */
	274	if (p->wpid)
	275	kill(p->wpid, SIGHUP);
7c8ab0e6 BJ	276	rmut(p);
	277	dfork(p);
	278	}
068e4187	279	}
25efc242	280	sigsetmask(omask);
7c8ab0e6 BJ	281	}
	282	}
	283
d0ca48ff SL	284	/*
	285	* Merge current contents of ttys file
	286	* into in-core table of configured tty lines.
	287	* Entered as signal handler for SIGHUP.
	288	*/
	289	#define FOUND 1
	290	#define CHANGE 2
068e4187	291	#define WCHANGE 4
d0ca48ff SL	292
	293	merge()
	294	{
	295	register struct tab *p;
9479aa87	296	register struct ttyent *t;
25efc242	297	register struct tab *p1;
d0ca48ff	298
d0ca48ff SL	299	for (ALL)
d0ca48ff SL	300	p->xflag = 0;
9479aa87 BJ	301	setttyent();
	302	while (t = getttyent()) {
	303	if ((t->ty_status & TTY_ON) == 0)
	304	continue;
d0ca48ff	305	for (ALL) {
9479aa87	306	if (SCMPN(p->line, t->ty_name))
d0ca48ff SL	307	continue;
d0ca48ff SL	308	p->xflag \|= FOUND;
9479aa87	309	if (SCMPN(p->comn, t->ty_getty)) {
d0ca48ff	310	p->xflag \|= CHANGE;
9479aa87	311	SCPYN(p->comn, t->ty_getty);
d0ca48ff	312	}
381dc986	313	if (SCMPN(p->wcmd, t->ty_window ? t->ty_window : "")) {
068e4187 RC	314	p->xflag \|= WCHANGE\|CHANGE;
	315	SCPYN(p->wcmd, t->ty_window);
	316	}
d0ca48ff SL	317	goto contin1;
d0ca48ff SL	318	}
068e4187	319
25efc242 JB	320	/*
	321	* Make space for a new one
	322	*/
	323	p1 = (struct tab )calloc(1, sizeof(p1));
	324	if (!p1) {
	325	syslog(LOG_ERR, "no space for '%s' !?!", t->ty_name);
d0ca48ff SL	326	goto contin1;
d0ca48ff SL	327	}
25efc242 JB	328	/*
	329	* Put new terminal at the end of the linked list.
	330	*/
	331	if (itab) {
	332	for (p = itab; p->next ; p = p->next)
	333	;
	334	p->next = p1;
	335	} else
	336	itab = p1;
	337
	338	p = p1;
	339	SCPYN(p->line, t->ty_name);
	340	p->xflag \|= FOUND\|CHANGE;
	341	SCPYN(p->comn, t->ty_getty);
381dc986	342	if (t->ty_window && strcmp(t->ty_window, "") != 0) {
25efc242 JB	343	p->xflag \|= WCHANGE;
	344	SCPYN(p->wcmd, t->ty_window);
	345	}
d0ca48ff SL	346	contin1:
	347	;
	348	}
9479aa87	349	endttyent();
25efc242	350	p1 = (struct tab *)0;
d0ca48ff SL	351	for (ALL) {
	352	if ((p->xflag&FOUND) == 0) {
	353	term(p);
068e4187	354	wterm(p);
25efc242 JB	355	if (p1)
	356	p1->next = p->next;
	357	else
	358	itab = p->next;
	359	free(p);
	360	p = p1 ? p1 : itab;
	361	} else {
	362	/* window system should be started first */
	363	if (p->xflag&WCHANGE) {
	364	wterm(p);
	365	wstart(p);
	366	}
	367	if (p->xflag&CHANGE) {
	368	term(p);
	369	dfork(p);
	370	}
d0ca48ff	371	}
25efc242	372	p1 = p;
d0ca48ff SL	373	}
	374	}
	375
7c8ab0e6	376	term(p)
d0ca48ff	377	register struct tab *p;
7c8ab0e6 BJ	378	{
7c8ab0e6 BJ	379
d0ca48ff	380	if (p->pid != 0) {
7c8ab0e6 BJ	381	rmut(p);
	382	kill(p->pid, SIGKILL);
	383	}
	384	p->pid = 0;
068e4187 RC	385	/* send SIGHUP to get rid of connections */
	386	if (p->wpid > 0)
	387	kill(p->wpid, SIGHUP);
7c8ab0e6 BJ	388	}
7c8ab0e6 BJ	389
7c8ab0e6	390	dfork(p)
d0ca48ff	391	struct tab *p;
7c8ab0e6 BJ	392	{
7c8ab0e6 BJ	393	register pid;
43236707 BJ	394	time_t t;
	395	int dowait = 0;
	396
	397	time(&t);
	398	p->gettycnt++;
	399	if ((t - p->gettytime) >= 60) {
	400	p->gettytime = t;
	401	p->gettycnt = 1;
068e4187 RC	402	} else if (p->gettycnt >= 5) {
	403	dowait = 1;
	404	p->gettytime = t;
	405	p->gettycnt = 1;
43236707	406	}
7c8ab0e6	407	pid = fork();
d0ca48ff	408	if (pid == 0) {
30e1f894 SL	409	signal(SIGTERM, SIG_DFL);
30e1f894 SL	410	signal(SIGHUP, SIG_IGN);
a936c74e	411	sigsetmask(0); /* since can be called from masked code */
43236707	412	if (dowait) {
068e4187 RC	413	syslog(LOG_ERR, "'%s %s' failing, sleeping", p->comn, p->line);
068e4187 RC	414	closelog();
43236707	415	sleep(30);
ef9abb5f	416	}
068e4187	417	execit(p->comn, p->line);
7c8ab0e6 BJ	418	exit(0);
	419	}
	420	p->pid = pid;
	421	}
	422
d0ca48ff SL	423	/*
	424	* Remove utmp entry.
	425	*/
7c8ab0e6	426	rmut(p)
d0ca48ff	427	register struct tab *p;
7c8ab0e6 BJ	428	{
7c8ab0e6 BJ	429	register f;
ef9abb5f	430	int found = 0;
25efc242 JB	431	static unsigned utmpsize;
	432	static struct utmp *utmp;
	433	register struct utmp *u;
	434	int nutmp;
	435	struct stat statbf;
7c8ab0e6	436
25efc242	437	f = open(utmpf, O_RDWR);
d0ca48ff	438	if (f >= 0) {
25efc242 JB	439	fstat(f, &statbf);
	440	if (utmpsize < statbf.st_size) {
	441	utmpsize = statbf.st_size + 10 * sizeof(struct utmp);
	442	if (utmp)
	443	utmp = (struct utmp *)realloc(utmp, utmpsize);
	444	else
	445	utmp = (struct utmp *)malloc(utmpsize);
	446	if (!utmp)
	447	syslog(LOG_ERR, "utmp malloc failed");
	448	}
	449	if (statbf.st_size && utmp) {
	450	nutmp = read(f, utmp, statbf.st_size);
	451	nutmp /= sizeof(struct utmp);
	452	for (u = utmp ; u < &utmp[nutmp] ; u++) {
	453	if (SCMPN(u->ut_line, p->line) \|\|
	454	u->ut_name[0]==0)
	455	continue;
	456	lseek(f, ((long)u)-((long)utmp), L_SET);
	457	SCPYN(u->ut_name, "");
	458	SCPYN(u->ut_host, "");
	459	time(&u->ut_time);
	460	write(f, (char )u, sizeof(u));
	461	found++;
	462	}
7c8ab0e6 BJ	463	}
	464	close(f);
	465	}
ef9abb5f	466	if (found) {
d0ca48ff	467	f = open(wtmpf, O_WRONLY\|O_APPEND);
ef9abb5f BJ	468	if (f >= 0) {
	469	SCPYN(wtmp.ut_line, p->line);
	470	SCPYN(wtmp.ut_name, "");
37c640e2	471	SCPYN(wtmp.ut_host, "");
ef9abb5f	472	time(&wtmp.ut_time);
ef9abb5f BJ	473	write(f, (char *)&wtmp, sizeof(wtmp));
	474	close(f);
	475	}
13408cfa SL	476	/*
	477	* After a proper login force reset
	478	* of error detection code in dfork.
	479	*/
	480	p->gettytime = 0;
a936c74e	481	p->windtime = 0;
7c8ab0e6 BJ	482	}
	483	}
	484
	485	reset()
	486	{
d0ca48ff	487
7c8ab0e6 BJ	488	longjmp(sjbuf, 1);
7c8ab0e6 BJ	489	}
f570e1ff	490
d0ca48ff SL	491	jmp_buf idlebuf;
	492
	493	idlehup()
	494	{
	495
	496	longjmp(idlebuf, 1);
	497	}
	498
f570e1ff BJ	499	idle()
	500	{
	501	register struct tab *p;
	502	register pid;
	503
d0ca48ff	504	signal(SIGHUP, idlehup);
068e4187	505	for (EVER) {
d0ca48ff	506	if (setjmp(idlebuf))
f570e1ff	507	return;
d0ca48ff SL	508	pid = wait((int *) 0);
	509	if (pid == -1) {
	510	sigpause(0);
	511	continue;
f570e1ff	512	}
068e4187 RC	513	for (ALL) {
	514	/* if window system dies, mark it for restart */
	515	if (p->wpid == pid)
	516	p->wpid = -1;
d0ca48ff SL	517	if (p->pid == pid) {
	518	rmut(p);
	519	p->pid = -1;
	520	}
068e4187 RC	521	}
	522	}
	523	}
	524
	525	wterm(p)
	526	register struct tab *p;
	527	{
	528	if (p->wpid != 0) {
	529	kill(p->wpid, SIGKILL);
	530	}
	531	p->wpid = 0;
	532	}
	533
	534	wstart(p)
	535	register struct tab *p;
	536	{
a936c74e MK	537	register pid;
	538	time_t t;
	539	int dowait = 0;
068e4187	540
a936c74e MK	541	time(&t);
	542	p->windcnt++;
	543	if ((t - p->windtime) >= 60) {
	544	p->windtime = t;
	545	p->windcnt = 1;
	546	} else if (p->windcnt >= 5) {
	547	dowait = 1;
	548	p->windtime = t;
	549	p->windcnt = 1;
	550	}
	551
	552	pid = fork();
	553
	554	if (pid == 0) {
068e4187	555	signal(SIGTERM, SIG_DFL);
a936c74e MK	556	signal(SIGHUP, SIG_IGN);
	557	sigsetmask(0); /* since can be called from masked code */
	558	if (dowait) {
	559	syslog(LOG_ERR, "'%s %s' failing, sleeping", p->wcmd, p->line);
	560	closelog();
	561	sleep(30);
	562	}
068e4187 RC	563	execit(p->wcmd, p->line);
	564	exit(0);
	565	}
a936c74e	566	p->wpid = pid;
068e4187 RC	567	}
068e4187 RC	568
a936c74e	569	#define NARGS 20 /* must be at least 4 */
068e4187 RC	570	#define ARGLEN 512 /* total size for all the argument strings */
	571
	572	execit(s, arg)
	573	char *s;
	574	char arg; / last argument on line */
	575	{
	576	char argv[NARGS], args[ARGLEN], envp[1];
	577	register char *sp = s;
	578	register char *ap = args;
	579	register char c;
	580	register int i;
	581
	582	/*
	583	* First we have to set up the argument vector.
	584	* "prog arg1 arg2" maps to exec("prog", "-", "arg1", "arg2").
	585	*/
	586	for (i = 1; i < NARGS - 2; i++) {
	587	argv[i] = ap;
	588	for (EVER) {
	589	if ((c = *sp++) == '\0' \|\| ap >= &args[ARGLEN-1]) {
	590	*ap = '\0';
	591	goto done;
	592	}
	593	if (c == ' ') {
	594	*ap++ = '\0';
	595	while (*sp == ' ')
	596	sp++;
	597	if (*sp == '\0')
	598	goto done;
	599	break;
	600	}
	601	*ap++ = c;
	602	}
f570e1ff	603	}
068e4187 RC	604	done:
	605	argv[0] = argv[1];
	606	argv[1] = "-";
	607	argv[i+1] = arg;
	608	argv[i+2] = 0;
	609	envp[0] = 0;
	610	execve(argv[0], &argv[1], envp);
	611	/* report failure of exec */
	612	syslog(LOG_ERR, "%s: %m", argv[0]);
	613	closelog();
	614	sleep(10); /* prevent failures from eating machine */
f570e1ff	615	}