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

/*
 * Copyright (c) 1986, 1987, 1992 Daniel D. Lanciani.
 * All rights reserved.
 *
 * 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
 *	Daniel D. Lanciani.
 * 4. The name of the author may not
 *    be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY Daniel D. Lanciani ``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 Daniel D. Lanciani 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.
 */


#include <sys/types.h>
#include <sys/errno.h>
#include <sys/signal.h>
#include <sys/wait.h>
#include <setjmp.h>
#include <ttyent.h>
#include <unistd.h>

#define NTTY 32			/* max ttys */
#define NARG 16			/* max args to login/getty */

/* internal flags */
#define TTY_SEEN 0x8000
#define TTY_DIFF 0x4000
#define TTY_LOGIN 0x2000

/* non-standard tty_logout: rerun login/getty with -o switch to clean line */
#ifndef	TTY_LOGOUT
#define TTY_LOGOUT 0x1000
#endif

/* non-standard tty_open: open device for login/getty */
#ifndef	TTY_OPEN
#define TTY_OPEN 0x0800
#endif

#define isspace(c) ((c) == ' ' || (c) == '\t')

struct ttytab {
	char *tt_name;
	char *tt_getty;
	char *tt_type;
	int tt_status;
	int tt_pid;
} ttytab[NTTY], *ttytabend = ttytab;
int drain, sflag;
char arg[128], nam[64], term[64], *env[] = { term, 0 };
jmp_buf single, reread;
char *Reboot = "autoboot";

char *newstring(), *malloc();
extern int errno;

/* signal state of child process */
#define	SIGNALSFORCHILD	 \
	signal(SIGHUP, SIG_DFL); signal(SIGINT, SIG_DFL); \
	signal(SIGTERM, SIG_DFL); signal(SIGALRM, SIG_DFL); \
	signal(SIGTSTP, SIG_DFL); signal(SIGCHLD, SIG_DFL); \
	signal(SIGTTIN, SIG_DFL); signal(SIGTTOU, SIG_DFL);

/* SIGHUP: reread /etc/ttys */
void
shup(sig)
{
	longjmp(reread, 1);
}

/* SIGALRM: abort wait and go single user */
void
salrm(sig)
{
	signal(SIGALRM, SIG_DFL);
	warn("process hung");
	longjmp(single, 1);
}

/* SIGTERM: go single user */
void
sterm(sig)
{
	register struct ttytab *tt;

	if (!Reboot) {
		for(tt = ttytab; tt < ttytabend; tt++) {
			free(tt->tt_name);
			free(tt->tt_getty);
			free(tt->tt_type);
		}
		ttytabend = ttytab;
		kill(-1, SIGKILL);
		kill(-1, SIGCONT);
		signal(SIGALRM, salrm);
		alarm(30);
		while(wait((int *)0) > 0);
		alarm(0);
		signal(SIGALRM, SIG_DFL);
		longjmp(single, 1);
	}
}

/* SIGTSTP: drain system */
void
ststp(sig)
{
	drain = 1;
}

/* init [-s] [-f] */

main(argc, argv)
char **argv;
{
	register int pid;
	register struct ttytab *tt;
	struct ttyent *ty;
	int status;
	long mask = sigblock(sigmask(SIGHUP) | sigmask(SIGTERM));

	/* did some idiot try to run us? */
	if(getpid() != 1) {
		writes(2,"init: sorry, system daemon, runnable only by system\n");
		exit(0xff);
	}

	/* allocate a session for init */
	(void) setsid();

	/* protect against signals, listen for outside requests */
	signal(SIGHUP, shup);
	signal(SIGTSTP, ststp);

	signal (SIGTTIN, SIG_IGN);
	signal (SIGTTOU, SIG_IGN);
	signal (SIGCHLD, SIG_IGN);
	signal (SIGINT, SIG_IGN);

	/* handle arguments, if any */
	if(argc > 1)
		if(!strcmp(argv[1], "-s"))
			sflag++;
		else if(!strcmp(argv[1], "-f"))
			Reboot = 0;
top:
	/* Single user mode? */
	if(sflag) {
		sflag = 0;
		status = 1;
	} else {
		/* otherwise, execute /etc/rc */
		if (access("/etc/rc", F_OK)  == 0) {
			
			signal(SIGTERM, SIG_IGN);	/* XXX */
			if((pid = fork()) < 0)
				fatal("fork");
			else if(!pid) {
				/* signals, to default state */
				SIGNALSFORCHILD;

				/* clean off console */
				revoke("/dev/console");

				/* create a shell */
				login_tty(open("/dev/console", 2));
				execl("/bin/sh", "sh", "/etc/rc", Reboot, (char *)0);
				_exit(127);
			}
			while(wait(&status) != pid);

			/* if we are about to be rebooted, then wait for it */
			if (WIFSIGNALED(status) && WTERMSIG(status) == SIGKILL)
				pause();
		} else	{ status = 1;  sflag = 1; goto top; }
	}
	signal(SIGTERM, sterm);
	Reboot = 0;

	/* do single user shell on console */
	if (setjmp(single) || status) {
		if((pid = fork()) < 0)
			fatal("fork");
		else if(!pid) {
			/* signals, to default state */
			SIGNALSFORCHILD;

			/* clean off console */
			revoke("/dev/console");

			/* do open and configuration of console */
			login_tty(open("/dev/console", 2));
			execl("/bin/sh", "-", (char *)0);
			_exit(127);
		}
		while(wait(&status) != pid)
		goto top;
	}

	/* multiuser mode, traipse through table */
	setttyent();
	for(tt = ttytab; (ty = getttyent()) && tt < &ttytab[NTTY]; tt++) {
		tt->tt_name = newstring(ty->ty_name);
		tt->tt_getty = newstring(ty->ty_getty);
		tt->tt_type = newstring(ty->ty_type);
		tt->tt_status = ty->ty_status;
	}
	ttytabend = tt;
	endttyent();
	for(tt = ttytab; tt < ttytabend; getty(tt++));

	/* if we receive a request to reread the table, come here */
	if(setjmp(reread)) {

		/* first pass. find and clean the entries that have changed */
		setttyent();
		while(ty = getttyent()) {
			for(tt = ttytab; tt < ttytabend; tt++)
			if(!strcmp(tt->tt_name, ty->ty_name)) {
				/* if a process present, mark */
				if((tt->tt_status & ~TTY_LOGIN) !=ty->ty_status)
					tt->tt_status = ty->ty_status |TTY_DIFF;
				if(strcmp(tt->tt_getty, ty->ty_getty)) {
					free(tt->tt_getty);
					tt->tt_getty = newstring(ty->ty_getty);
					tt->tt_status |= TTY_DIFF;
				}
				if(strcmp(tt->tt_type, ty->ty_type)) {
					free(tt->tt_type);
					tt->tt_type = newstring(ty->ty_type);
					tt->tt_status |= TTY_DIFF;
				}
				if(((tt->tt_status |= TTY_SEEN) & TTY_DIFF)
					&& tt->tt_pid > 1)
					kill(tt->tt_pid, 9);
				break;
			}
			if(tt == ttytabend && tt < &ttytab[NTTY]) {
				tt->tt_name = newstring(ty->ty_name);
				tt->tt_getty = newstring(ty->ty_getty);
				tt->tt_type = newstring(ty->ty_type);
				tt->tt_status = ty->ty_status |
					TTY_SEEN | TTY_DIFF;
				ttytabend++;
			}
		}
		endttyent();
		/* second pass. offer gettys on previously cleaned entries,
		   and garbage collect "dead" entries */
		for(tt = ttytab; tt < ttytabend; tt++)
			if(tt->tt_status & TTY_SEEN) {
				tt->tt_status &= ~TTY_SEEN;
				if(tt->tt_status & TTY_DIFF) {
					tt->tt_status &= ~TTY_DIFF;
					getty(tt);
				}
			}
			else {
				if(tt->tt_pid > 1)
					kill(tt->tt_pid, 9);
				free(tt->tt_name);
				free(tt->tt_getty);
				free(tt->tt_type);
				pid = tt - ttytab;
				for(tt++; tt < ttytabend; tt++)
					tt[-1] = *tt;
				ttytabend--;
				tt = &ttytab[pid];
			}
	}
	drain = 0;

	/* listen for terminating gettys and sessions, and process them */
	while(1) {
		sigsetmask(mask);
		pid = wait(&status);
		sigblock(sigmask(SIGHUP) | sigmask(SIGTERM));
		if(pid < 0) {
			sleep(5);
			continue;
		}
		for(tt = ttytab; tt < ttytabend; tt++)
			if(pid == tt->tt_pid) {
				if(drain && !(tt->tt_status & TTY_LOGIN)) {
					free(tt->tt_name);
					free(tt->tt_getty);
					free(tt->tt_type);
					for(tt++; tt < ttytabend; tt++)
						tt[-1] = *tt;
					ttytabend--;
				}
				else
					getty(tt);
				break;
			}
	}
}

/* process a getty for a "line". N.B. by having getty do open, init
   is not limited by filedescriptors for number of possible users */
getty(tt)
struct ttytab *tt;
{
	char *sargv[NARG];
	register char *p = arg, **sp = sargv;

	if(!(tt->tt_status & TTY_ON)) {
		tt->tt_pid = -1;
		return;
	}
	if((tt->tt_pid = fork()) < 0)
		fatal("getty fork");
	else if(tt->tt_pid) {
		if(tt->tt_status & TTY_LOGOUT)
			tt->tt_status ^= TTY_LOGIN;
		return;
	}
	signal(SIGHUP, SIG_DFL);
	signal(SIGTERM, SIG_DFL);
	signal(SIGTSTP, SIG_DFL);
	sigsetmask(0);
	strcpy(p, tt->tt_getty);
	while(sp < &sargv[NARG - 2]) {
		while(isspace(*p))
			p++;
		if(!*p)
			break;
		*sp++ = p;
		while(!isspace(*p) && *p)
			p++;
		if(!*p)
			break;
		*p++ = 0;
	}
	strcpy(nam, tt->tt_name);
	*sp++ = nam;
	*sp = 0;
	p = *sargv;
	strcpy(term, "TERM=");
	strcat(term, tt->tt_type);
	execve(p, sargv, env);
bad:
	sleep(30);
	fatal(tt->tt_name);
}

char *
newstring(s)
register char *s;
{
	register char *n;

	if(!(n = malloc(strlen(s) + 1)))
		fatal("out of memory");
	strcpy(n, s);
	return(n);
}

warn(s)
char *s;
{
	register int pid;
	int fd;

	fd = open("/dev/console", 2);
	writes(fd, "init WARNING: ");
	writes(fd, s);
	write(fd, "\n", 1);
	close(fd);
}

fatal(s)
char *s;
{
	login_tty(open("/dev/console", 2));
	writes(2, "init FATAL error: ");
	perror(s);
	exit(1);
	/* panic: init died */
}

writes(n, s)
char *s;
{
	write(n, s, strlen(s));
}
Commit	Line	Data
4ef48614 WJ	1	/*
	2	* Copyright (c) 1986, 1987, 1992 Daniel D. Lanciani.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	* 3. All advertising materials mentioning features or use of this software
	14	* must display the following acknowledgement:
	15	* This product includes software developed by
	16	* Daniel D. Lanciani.
	17	* 4. The name of the author may not
	18	* be used to endorse or promote products derived from this software
	19	* without specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY Daniel D. Lanciani ``AS IS'' AND
	22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL Daniel D. Lanciani BE LIABLE
	25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	31	* SUCH DAMAGE.
	32	*/
	33
	34
	35	#include <sys/types.h>
	36	#include <sys/errno.h>
	37	#include <sys/signal.h>
	38	#include <sys/wait.h>
	39	#include <setjmp.h>
	40	#include <ttyent.h>
	41	#include <unistd.h>
	42
	43	#define NTTY 32 /* max ttys */
	44	#define NARG 16 /* max args to login/getty */
	45
	46	/* internal flags */
	47	#define TTY_SEEN 0x8000
	48	#define TTY_DIFF 0x4000
	49	#define TTY_LOGIN 0x2000
	50
	51	/* non-standard tty_logout: rerun login/getty with -o switch to clean line */
	52	#ifndef TTY_LOGOUT
	53	#define TTY_LOGOUT 0x1000
	54	#endif
	55
	56	/* non-standard tty_open: open device for login/getty */
	57	#ifndef TTY_OPEN
	58	#define TTY_OPEN 0x0800
	59	#endif
	60
	61	#define isspace(c) ((c) == ' ' \|\| (c) == '\t')
	62
	63	struct ttytab {
	64	char *tt_name;
65	char *tt_getty;
66	char *tt_type;
67	int tt_status;
68	int tt_pid;
69	} ttytab[NTTY], *ttytabend = ttytab;
70	int drain, sflag;
71	char arg[128], nam[64], term[64], *env[] = { term, 0 };
72	jmp_buf single, reread;
73	char *Reboot = "autoboot";
74
75	char newstring(), malloc();
76	extern int errno;
77
78	/* signal state of child process */
79	#define SIGNALSFORCHILD \
80	signal(SIGHUP, SIG_DFL); signal(SIGINT, SIG_DFL); \
81	signal(SIGTERM, SIG_DFL); signal(SIGALRM, SIG_DFL); \
82	signal(SIGTSTP, SIG_DFL); signal(SIGCHLD, SIG_DFL); \
83	signal(SIGTTIN, SIG_DFL); signal(SIGTTOU, SIG_DFL);
84
85	/* SIGHUP: reread /etc/ttys */
86	void
87	shup(sig)
88	{
89	longjmp(reread, 1);
90	}
91
92	/* SIGALRM: abort wait and go single user */
93	void
94	salrm(sig)
95	{
96	signal(SIGALRM, SIG_DFL);
97	warn("process hung");
98	longjmp(single, 1);
99	}
100
101	/* SIGTERM: go single user */
102	void
103	sterm(sig)
104	{
105	register struct ttytab *tt;
106
107	if (!Reboot) {
108	for(tt = ttytab; tt < ttytabend; tt++) {
109	free(tt->tt_name);
110	free(tt->tt_getty);
111	free(tt->tt_type);
112	}
113	ttytabend = ttytab;
114	kill(-1, SIGKILL);
115	kill(-1, SIGCONT);
116	signal(SIGALRM, salrm);
117	alarm(30);
118	while(wait((int *)0) > 0);
119	alarm(0);
120	signal(SIGALRM, SIG_DFL);
121	longjmp(single, 1);
122	}
123	}
124
125	/* SIGTSTP: drain system */
126	void
127	ststp(sig)
128	{
129	drain = 1;
130	}
131
132	/* init [-s] [-f] */
133
134	main(argc, argv)
135	char **argv;
136	{
137	register int pid;
138	register struct ttytab *tt;
139	struct ttyent *ty;
140	int status;
141	long mask = sigblock(sigmask(SIGHUP) \| sigmask(SIGTERM));
142
143	/* did some idiot try to run us? */
144	if(getpid() != 1) {
145	writes(2,"init: sorry, system daemon, runnable only by system\n");
146	exit(0xff);
147	}
148
149	/* allocate a session for init */
150	(void) setsid();
151
152	/* protect against signals, listen for outside requests */
153	signal(SIGHUP, shup);
154	signal(SIGTSTP, ststp);
155
156	signal (SIGTTIN, SIG_IGN);
157	signal (SIGTTOU, SIG_IGN);
158	signal (SIGCHLD, SIG_IGN);
159	signal (SIGINT, SIG_IGN);
160
161	/* handle arguments, if any */
162	if(argc > 1)
163	if(!strcmp(argv[1], "-s"))
164	sflag++;
165	else if(!strcmp(argv[1], "-f"))
166	Reboot = 0;
167	top:
168	/* Single user mode? */
169	if(sflag) {
170	sflag = 0;
171	status = 1;
172	} else {
173	/* otherwise, execute /etc/rc */
174	if (access("/etc/rc", F_OK) == 0) {
175
176	signal(SIGTERM, SIG_IGN); /* XXX */
177	if((pid = fork()) < 0)
178	fatal("fork");
179	else if(!pid) {
180	/* signals, to default state */
181	SIGNALSFORCHILD;
182
183	/* clean off console */
184	revoke("/dev/console");
185
186	/* create a shell */
187	login_tty(open("/dev/console", 2));
188	execl("/bin/sh", "sh", "/etc/rc", Reboot, (char *)0);
189	_exit(127);
190	}
191	while(wait(&status) != pid);
192
193	/* if we are about to be rebooted, then wait for it */
194	if (WIFSIGNALED(status) && WTERMSIG(status) == SIGKILL)
195	pause();
196	} else { status = 1; sflag = 1; goto top; }
197	}
198	signal(SIGTERM, sterm);
199	Reboot = 0;
200
201	/* do single user shell on console */
202	if (setjmp(single) \|\| status) {
203	if((pid = fork()) < 0)
204	fatal("fork");
205	else if(!pid) {
206	/* signals, to default state */
207	SIGNALSFORCHILD;
208
209	/* clean off console */
210	revoke("/dev/console");
211
212	/* do open and configuration of console */
213	login_tty(open("/dev/console", 2));
214	execl("/bin/sh", "-", (char *)0);
215	_exit(127);
216	}
217	while(wait(&status) != pid)
218	goto top;
219	}
220
221	/* multiuser mode, traipse through table */
222	setttyent();
223	for(tt = ttytab; (ty = getttyent()) && tt < &ttytab[NTTY]; tt++) {
224	tt->tt_name = newstring(ty->ty_name);
225	tt->tt_getty = newstring(ty->ty_getty);
226	tt->tt_type = newstring(ty->ty_type);
227	tt->tt_status = ty->ty_status;
228	}
229	ttytabend = tt;
230	endttyent();
231	for(tt = ttytab; tt < ttytabend; getty(tt++));
232
233	/* if we receive a request to reread the table, come here */
234	if(setjmp(reread)) {
235
236	/* first pass. find and clean the entries that have changed */
237	setttyent();
238	while(ty = getttyent()) {
239	for(tt = ttytab; tt < ttytabend; tt++)
240	if(!strcmp(tt->tt_name, ty->ty_name)) {
241	/* if a process present, mark */
242	if((tt->tt_status & ~TTY_LOGIN) !=ty->ty_status)
243	tt->tt_status = ty->ty_status \|TTY_DIFF;
244	if(strcmp(tt->tt_getty, ty->ty_getty)) {
245	free(tt->tt_getty);
246	tt->tt_getty = newstring(ty->ty_getty);
247	tt->tt_status \|= TTY_DIFF;
248	}
249	if(strcmp(tt->tt_type, ty->ty_type)) {
250	free(tt->tt_type);
251	tt->tt_type = newstring(ty->ty_type);
252	tt->tt_status \|= TTY_DIFF;
253	}
254	if(((tt->tt_status \|= TTY_SEEN) & TTY_DIFF)
255	&& tt->tt_pid > 1)
256	kill(tt->tt_pid, 9);
257	break;
258	}
259	if(tt == ttytabend && tt < &ttytab[NTTY]) {
260	tt->tt_name = newstring(ty->ty_name);
261	tt->tt_getty = newstring(ty->ty_getty);
262	tt->tt_type = newstring(ty->ty_type);
263	tt->tt_status = ty->ty_status \|
264	TTY_SEEN \| TTY_DIFF;
265	ttytabend++;
266	}
267	}
268	endttyent();
269	/* second pass. offer gettys on previously cleaned entries,
270	and garbage collect "dead" entries */
271	for(tt = ttytab; tt < ttytabend; tt++)
272	if(tt->tt_status & TTY_SEEN) {
273	tt->tt_status &= ~TTY_SEEN;
274	if(tt->tt_status & TTY_DIFF) {
275	tt->tt_status &= ~TTY_DIFF;
276	getty(tt);
277	}
278	}
279	else {
280	if(tt->tt_pid > 1)
281	kill(tt->tt_pid, 9);
282	free(tt->tt_name);
283	free(tt->tt_getty);
284	free(tt->tt_type);
285	pid = tt - ttytab;
286	for(tt++; tt < ttytabend; tt++)
287	tt[-1] = *tt;
288	ttytabend--;
289	tt = &ttytab[pid];
290	}
291	}
292	drain = 0;
293
294	/* listen for terminating gettys and sessions, and process them */
295	while(1) {
296	sigsetmask(mask);
297	pid = wait(&status);
298	sigblock(sigmask(SIGHUP) \| sigmask(SIGTERM));
299	if(pid < 0) {
300	sleep(5);
301	continue;
302	}
303	for(tt = ttytab; tt < ttytabend; tt++)
304	if(pid == tt->tt_pid) {
305	if(drain && !(tt->tt_status & TTY_LOGIN)) {
306	free(tt->tt_name);
307	free(tt->tt_getty);
308	free(tt->tt_type);
309	for(tt++; tt < ttytabend; tt++)
310	tt[-1] = *tt;
311	ttytabend--;
312	}
313	else
314	getty(tt);
315	break;
316	}
317	}
318	}
319
320	/* process a getty for a "line". N.B. by having getty do open, init
321	is not limited by filedescriptors for number of possible users */
322	getty(tt)
323	struct ttytab *tt;
324	{
325	char *sargv[NARG];
326	register char p = arg, *sp = sargv;
327
328	if(!(tt->tt_status & TTY_ON)) {
329	tt->tt_pid = -1;
330	return;
331	}
332	if((tt->tt_pid = fork()) < 0)
333	fatal("getty fork");
334	else if(tt->tt_pid) {
335	if(tt->tt_status & TTY_LOGOUT)
336	tt->tt_status ^= TTY_LOGIN;
337	return;
338	}
339	signal(SIGHUP, SIG_DFL);
340	signal(SIGTERM, SIG_DFL);
341	signal(SIGTSTP, SIG_DFL);
342	sigsetmask(0);
343	strcpy(p, tt->tt_getty);
344	while(sp < &sargv[NARG - 2]) {
345	while(isspace(*p))
346	p++;
347	if(!*p)
348	break;
349	*sp++ = p;
350	while(!isspace(p) && p)
351	p++;
352	if(!*p)
353	break;
354	*p++ = 0;
355	}
356	strcpy(nam, tt->tt_name);
357	*sp++ = nam;
358	*sp = 0;
359	p = *sargv;
360	strcpy(term, "TERM=");
361	strcat(term, tt->tt_type);
362	execve(p, sargv, env);
363	bad:
364	sleep(30);
365	fatal(tt->tt_name);
366	}
367
368	char *
369	newstring(s)
370	register char *s;
371	{
372	register char *n;
373
374	if(!(n = malloc(strlen(s) + 1)))
375	fatal("out of memory");
376	strcpy(n, s);
377	return(n);
378	}
379
380	warn(s)
381	char *s;
382	{
383	register int pid;
384	int fd;
385
386	fd = open("/dev/console", 2);
387	writes(fd, "init WARNING: ");
388	writes(fd, s);
389	write(fd, "\n", 1);
390	close(fd);
391	}
392
393	fatal(s)
394	char *s;
395	{
396	login_tty(open("/dev/console", 2));
397	writes(2, "init FATAL error: ");
398	perror(s);
399	exit(1);
400	/* panic: init died */
401	}
402
403	writes(n, s)
404	char *s;
405	{
406	write(n, s, strlen(s));
407	}