[unix-history] / usr / src / cmd / uucp / cico.c

#include "uucp.h"
#include "uucpdefs.h"
#include <signal.h>
#include <sgtty.h>
#include <setjmp.h>

jmp_buf Sjbuf;
	/*  call fail text  */
char *Stattext[] = {
	"",
	"BAD SYSTEM",
	"WRONG TIME",
	"SYSTEM LOCKED",
	"NO DEVICE",
	"DIAL FAILED",
	"LOGIN FAILED",
	"BAD SEQUENCE"
	};

int Role = 0;

	/*  call fail codes  */
int Stattype[] = {0, 0, 0, 0,
	SS_NODEVICE, SS_FAIL, SS_FAIL, SS_BADSEQ
	};


int Errorrate = 0;
struct sgttyb Savettyb;

/*******
 *	cico - this program is used  to place a call to a
 *	remote machine, login, and copy files between the two machines.
 */

main(argc, argv)
char *argv[];
{
	int ret, seq;
	int onesys = 0;
	char wkpre[NAMESIZE], file[NAMESIZE];
	char msg[BUFSIZ], *p, *q;
	extern onintr(), timeout();
	extern intrINT();
	extern intrHUP();
	extern intrQUIT();
	extern intrTERM();
	extern intrEXIT();
	extern char *pskip();
	char rflags[30];
	char *ttyn;
	char *ttyname();

	signal(SIGILL, intrEXIT);
	signal(SIGTRAP, intrEXIT);
	signal(SIGIOT, intrEXIT);
	signal(SIGEMT, intrEXIT);
	signal(SIGFPE, intrEXIT);
	signal(SIGBUS, intrEXIT);
	signal(SIGSEGV, intrEXIT);
	signal(SIGSYS, intrEXIT);
	signal(SIGINT, intrINT);
	signal(SIGHUP, intrHUP);
	signal(SIGQUIT, intrQUIT);
	signal(SIGTERM, intrTERM);
	ret = guinfo(getuid(), User, msg);
	strcpy(Loginuser, User);
	ASSERT(ret == 0, "BAD UID ret %d", ret);

	rflags[0] = '\0';
	strcpy(Rmtname, MYNAME);
	Ifn = Ofn = -1;
	while(argc>1 && argv[1][0] == '-'){
		switch(argv[1][1]){
		case 'd':
			Spool = &argv[1][2];
			break;
/*
*		case 'E':
*			Errorrate = atoi(&argv[1][2]);
*			if (Errorrate <= 0)
*				Errorrate = 100;
*			break;
*		case 'g':
*			Pkdrvon = 1;
*			break;
*		case 'G':
*			Pkdrvon = 1;
*			strcat(rflags, " -g ");
*			break;
*/
		case 'r':
			Role = atoi(&argv[1][2]);
			break;
		case 's':
			sprintf(Rmtname, "%.7s", &argv[1][2]);
			if (Rmtname[0] != '\0')
				onesys = 1;
			break;
		case 'x':
			Debug = atoi(&argv[1][2]);
			if (Debug <= 0)
				Debug = 1;
			strcat(rflags, argv[1]);
			break;
		default:
			printf("unknown flag %s\n", argv[1]);
			break;
		}
		--argc;  argv++;
	}

	chdir(Spool);
	strcpy(Wrkdir, Spool);

	if (Role == SLAVE) {
		/* initial handshake */
		onesys = 1;
		ret = ioctl(0, TIOCGETP, &Savettyb);
		Savettyb.sg_flags |= ECHO;
		Savettyb.sg_flags &= ~RAW;
		Ifn = 0;
		Ofn = 1;
		fixmode(Ifn);
		fclose(stderr);
		fopen(RMTDEBUG, "w");
		chmod(RMTDEBUG, 0666);
		omsg('S', "here", Ofn);
		signal(SIGALRM, timeout);
		alarm(MAXMSGTIME);
		if (setjmp(Sjbuf)) {
			/* timed out */
			ret = ioctl(0, TIOCSETP, &Savettyb);
			exit(0);
		}
		for (;;) {
			ret = imsg(msg, Ifn);
			if (ret != 0) {
				alarm(0);
				ret = ioctl(0, TIOCSETP, &Savettyb);
				exit(0);
			}
			if (msg[0] == 'S')
				break;
		}
		alarm(0);
		DEBUG(4, "msg-%s,", msg);
		q = &msg[1];
		p = pskip(q);
		sprintf(Rmtname, "%.7s", q);
		DEBUG(4, "sys-%s\n", Rmtname);
		if (mlock(Rmtname)) {
			omsg('R', "LCK", Ofn);
			cleanup(0);
		}
		else if (callback(Loginuser)) {
			signal(SIGINT, SIG_IGN);
			signal(SIGHUP, SIG_IGN);
			omsg('R', "CB", Ofn);
			DEBUG(4, "CALLBACK Role %d\n", Role);
			logent("CALLBACK", "REQUIRED");
			/*  set up for call back  */
			systat(Rmtname, SS_CALLBACK, "CALL BACK");
			gename(CMDPRE, Rmtname, 'C', file);
			close(creat(file, 0666));
			chmod(file, 0666);
			xuucico(Rmtname);
			cleanup(0);
		}
		seq = 0;
		while (*p == '-') {
			q = pskip(p);
			switch(*(++p)) {
			case 'g':
				Pkdrvon = 1;
				break;
			case 'x':
				Debug = atoi(++p);
				if (Debug <= 0)
					Debug = 1;
				break;
			case 'Q':
				seq = atoi(++p);
				break;
			default:
				break;
			}
			p = q;
		}
		if (callok(Rmtname) == SS_BADSEQ) {
			logent("BADSEQ", "PREVIOUS");
			omsg('R', "BADSEQ", Ofn);
			cleanup(0);
		}
		if ((ret = gnxseq(Rmtname)) == seq) {
			omsg('R', "OK", Ofn);
			cmtseq();
		}
		else {
			systat(Rmtname, Stattype[7], Stattext[7]);
			logent("BAD SEQ", "HANDSHAKE FAILED");
			ulkseq();
			omsg('R', "BADSEQ", Ofn);
			cleanup(0);
		}
	}
loop:
	if (!onesys) {
		ret = gnsys(Rmtname, Spool, CMDPRE);
		if (ret == FAIL)
			cleanup(100);
		if (ret == 0)
			cleanup(0);
	}
	else if (Role == MASTER && callok(Rmtname) != 0) {
		logent("SYSTEM STATUS", "CAN NOT CALL");
		cleanup(0);
	}

	sprintf(wkpre, "%c.%.7s", CMDPRE, Rmtname);

	if (Role == MASTER) {
		/*  master part */
		signal(SIGINT, SIG_IGN);
		signal(SIGHUP, SIG_IGN);
		signal(SIGQUIT, SIG_IGN);
		if (!iswrk(file, "chk", Spool, wkpre) && !onesys) {
			logent(Rmtname, "NO WORK");
			cleanup(0);
		}
		if (Ifn != -1 && Role == MASTER) {
			write(Ofn, EOTMSG, strlen(EOTMSG));
			close(Ofn);
			close(Ifn);
			Ifn = Ofn = -1;
			rmlock(NULL);
			clsacu();
			sleep(3);
		}
		sprintf(msg, "call to %s ", Rmtname);
		if (mlock(Rmtname) != 0) {
			logent(msg, "LOCKED");
			goto next;
		}
		Ofn = Ifn = conn(Rmtname);
		if (Ofn < 0) {
			logent(msg, "FAILED");
			systat(Rmtname, Stattype[-Ofn],
				Stattext[-Ofn]);
			goto next;
		}
		else {
			logent(msg, "SUCCEEDED");
		}
	
		if (setjmp(Sjbuf))
			goto next;
		signal(SIGALRM, timeout);
		alarm(2 * MAXMSGTIME);
		for (;;) {
			ret = imsg(msg, Ifn);
			if (ret != 0) {
				alarm(0);
				goto next;
			}
			if (msg[0] == 'S')
				break;
		}
		alarm(MAXMSGTIME);
		seq = gnxseq(Rmtname);
		sprintf(msg, "%.7s -Q%d %s", Myname, seq, rflags);
		omsg('S', msg, Ofn);
		for (;;) {
			ret = imsg(msg, Ifn);
			DEBUG(4, "msg-%s\n", msg);
			if (ret != 0) {
				alarm(0);
				ulkseq();
				goto next;
			}
			if (msg[0] == 'R')
				break;
		}
		alarm(0);
		if (msg[1] == 'B') {
			/* bad sequence */
			logent("BAD SEQ", "HANDSHAKE FAILED");
			systat(Rmtname, Stattype[7], Stattext[7]);
			ulkseq();
			goto next;
		}
		if (strcmp(&msg[1], "OK") != SAME)  {
			logent(&msg[1], "HANDSHAKE FAILED");
			ulkseq();
			goto next;
		}
		cmtseq();
	}
	ttyn = ttyname(Ifn);
	if (ttyn != NULL)
		chmod(ttyn, 0600);
	DEBUG(1, " Rmtname %s, ", Rmtname);
	DEBUG(1, "my Role %s,  ", Role ? "MASTER" : "SLAVE");
	DEBUG(1, "Spool - %s\n", Spool);
	DEBUG(1, "Ifn - %d, ", Ifn);
	DEBUG(1, "Ofn - %d, ", Ofn);
	DEBUG(1, "Loginuser - %s\n", Loginuser);

	ret = startup(Role);
	if (ret != SUCCESS) {
		logent("startup", "FAILED");
		systat(Rmtname, SS_FAIL, "STARTUP");
		goto next;
	}
	else {
		systat(Rmtname, SS_INPROGRESS, "TALKING");
		ret = cntrl(Role, wkpre);
		DEBUG(1, "ret from cntrl - %d\n", ret);
		signal(SIGINT, SIG_IGN);
		signal(SIGHUP, SIG_IGN);
		signal(SIGALRM, timeout);
		if (ret == 0)
			rmstat(Rmtname);

		else
			systat(Rmtname, SS_FAIL, "CONVERSATION");
		alarm(MAXMSGTIME);
		omsg('O', "OOOOO", Ofn);
		DEBUG(4, "send OO %d,", ret);
		if (!setjmp(Sjbuf)) {
			for (;;) {
				omsg('O', "OOOOO", Ofn);
				ret = imsg(msg, Ifn);
				if (ret != 0)
					break;
				if (msg[0] == 'O')
					break;
			}
		}
		alarm(0);
	}
next:
	if (!onesys) {
		goto loop;
	}
	cleanup(0);
}


int Hupvec[] = {0, 0, 1};

/***
 *	cleanup(code)	cleanup and exit with "code" status
 *	int code;
 */

cleanup(code)
int code;
{
	int ret;

	signal(SIGINT, SIG_IGN);
	signal(SIGHUP, SIG_IGN);
	rmlock(NULL);
	clsacu();
	logcls();
	if (Role == SLAVE) {
		ret = ioctl(0, TIOCSETP, &Savettyb);
		DEBUG(4, "\nIfn - %d, ", Ifn);
		DEBUG(4, "ret ioctl - %d\n", ret);
		DEBUG(4, "tty.flags %o,", Savettyb.sg_flags);
		DEBUG(4, "tty.ispeed %d, ", Savettyb.sg_ispeed);
		DEBUG(4, "tty.ospeed %d, ", Savettyb.sg_ospeed);
		ret = ioctl(0, TIOCSETP, Hupvec);
		DEBUG(4, "ret ioctl - %d\n", ret);
	}
	if (Ofn != -1) {
		if (Role == MASTER)
			write(Ofn, EOTMSG, strlen(EOTMSG));
		close(Ifn);
		close(Ofn);
	}
	DEBUG(1, "exit code %d\n", code);
	if (code == 0)
		xuuxqt();
	exit(code);
}

/***
 *	onintr(inter)	interrupt - remove locks and exit
 */

onintr(inter)
int inter;
{
	char str[30];
	signal(inter, SIG_IGN);
	sprintf(str, "SIGNAL %d", inter);
	logent(str, "CAUGHT");
	cleanup(inter);
}

intrINT() { onintr(SIGINT);}
intrHUP() { onintr(SIGHUP);}
intrQUIT() { onintr(SIGQUIT);}
intrTERM() { onintr(SIGTERM);}
intrEXIT() {_exit(77);}

/***
 *	fixmode(tty)	fix kill/echo/raw on line
 *
 *	return codes:  none
 */

fixmode(tty)
int tty;
{
	struct sgttyb ttbuf;
	int ret;

	ioctl(tty, TIOCGETP, &ttbuf);
	ttbuf.sg_flags |= (ANYP | RAW);
	ttbuf.sg_flags &= ~(ECHO | ALLDELAY);
	ret = ioctl(tty, TIOCSETP, &ttbuf);
	ASSERT(ret >= 0, "RETURN FROM STTY %d", ret);
	ioctl(tty, TIOCEXCL, 0);
	return;
}


/***
 *	timeout()	catch SIGALRM routine
 */

timeout()
{
	longjmp(Sjbuf, 1);
}

static char *
pskip(p)
register char *p;
{
	while( *p && *p != ' ' )
		++p;
	if( *p ) *p++ = 0;
	return(p);
}
Commit	Line	Data
808bd6eb N	1	#include "uucp.h"
	2	#include "uucpdefs.h"
	3	#include <signal.h>
	4	#include <sgtty.h>
	5	#include <setjmp.h>
	6
	7	jmp_buf Sjbuf;
	8	/* call fail text */
	9	char *Stattext[] = {
	10	"",
	11	"BAD SYSTEM",
	12	"WRONG TIME",
	13	"SYSTEM LOCKED",
	14	"NO DEVICE",
	15	"DIAL FAILED",
	16	"LOGIN FAILED",
	17	"BAD SEQUENCE"
	18	};
	19
	20	int Role = 0;
	21
	22	/* call fail codes */
	23	int Stattype[] = {0, 0, 0, 0,
	24	SS_NODEVICE, SS_FAIL, SS_FAIL, SS_BADSEQ
	25	};
	26
	27
	28	int Errorrate = 0;
	29	struct sgttyb Savettyb;
	30
	31	/*******
	32	* cico - this program is used to place a call to a
	33	* remote machine, login, and copy files between the two machines.
	34	*/
	35
	36	main(argc, argv)
	37	char *argv[];
	38	{
	39	int ret, seq;
	40	int onesys = 0;
	41	char wkpre[NAMESIZE], file[NAMESIZE];
	42	char msg[BUFSIZ], p, q;
	43	extern onintr(), timeout();
	44	extern intrINT();
	45	extern intrHUP();
	46	extern intrQUIT();
	47	extern intrTERM();
	48	extern intrEXIT();
	49	extern char *pskip();
	50	char rflags[30];
	51	char *ttyn;
	52	char *ttyname();
	53
	54	signal(SIGILL, intrEXIT);
	55	signal(SIGTRAP, intrEXIT);
	56	signal(SIGIOT, intrEXIT);
	57	signal(SIGEMT, intrEXIT);
	58	signal(SIGFPE, intrEXIT);
	59	signal(SIGBUS, intrEXIT);
	60	signal(SIGSEGV, intrEXIT);
	61	signal(SIGSYS, intrEXIT);
	62	signal(SIGINT, intrINT);
	63	signal(SIGHUP, intrHUP);
	64	signal(SIGQUIT, intrQUIT);
65	signal(SIGTERM, intrTERM);
66	ret = guinfo(getuid(), User, msg);
67	strcpy(Loginuser, User);
68	ASSERT(ret == 0, "BAD UID ret %d", ret);
69
70	rflags[0] = '\0';
71	strcpy(Rmtname, MYNAME);
72	Ifn = Ofn = -1;
73	while(argc>1 && argv[1][0] == '-'){
74	switch(argv[1][1]){
75	case 'd':
76	Spool = &argv[1][2];
77	break;
78	/*
79	* case 'E':
80	* Errorrate = atoi(&argv[1][2]);
81	* if (Errorrate <= 0)
82	* Errorrate = 100;
83	* break;
84	* case 'g':
85	* Pkdrvon = 1;
86	* break;
87	* case 'G':
88	* Pkdrvon = 1;
89	* strcat(rflags, " -g ");
90	* break;
91	*/
92	case 'r':
93	Role = atoi(&argv[1][2]);
94	break;
95	case 's':
96	sprintf(Rmtname, "%.7s", &argv[1][2]);
97	if (Rmtname[0] != '\0')
98	onesys = 1;
99	break;
100	case 'x':
101	Debug = atoi(&argv[1][2]);
102	if (Debug <= 0)
103	Debug = 1;
104	strcat(rflags, argv[1]);
105	break;
106	default:
107	printf("unknown flag %s\n", argv[1]);
108	break;
109	}
110	--argc; argv++;
111	}
112
113	chdir(Spool);
114	strcpy(Wrkdir, Spool);
115
116	if (Role == SLAVE) {
117	/* initial handshake */
118	onesys = 1;
119	ret = ioctl(0, TIOCGETP, &Savettyb);
120	Savettyb.sg_flags \|= ECHO;
121	Savettyb.sg_flags &= ~RAW;
122	Ifn = 0;
123	Ofn = 1;
124	fixmode(Ifn);
125	fclose(stderr);
126	fopen(RMTDEBUG, "w");
127	chmod(RMTDEBUG, 0666);
128	omsg('S', "here", Ofn);
129	signal(SIGALRM, timeout);
130	alarm(MAXMSGTIME);
131	if (setjmp(Sjbuf)) {
132	/* timed out */
133	ret = ioctl(0, TIOCSETP, &Savettyb);
134	exit(0);
135	}
136	for (;;) {
137	ret = imsg(msg, Ifn);
138	if (ret != 0) {
139	alarm(0);
140	ret = ioctl(0, TIOCSETP, &Savettyb);
141	exit(0);
142	}
143	if (msg[0] == 'S')
144	break;
145	}
146	alarm(0);
147	DEBUG(4, "msg-%s,", msg);
148	q = &msg[1];
149	p = pskip(q);
150	sprintf(Rmtname, "%.7s", q);
151	DEBUG(4, "sys-%s\n", Rmtname);
152	if (mlock(Rmtname)) {
153	omsg('R', "LCK", Ofn);
154	cleanup(0);
155	}
156	else if (callback(Loginuser)) {
157	signal(SIGINT, SIG_IGN);
158	signal(SIGHUP, SIG_IGN);
159	omsg('R', "CB", Ofn);
160	DEBUG(4, "CALLBACK Role %d\n", Role);
161	logent("CALLBACK", "REQUIRED");
162	/* set up for call back */
163	systat(Rmtname, SS_CALLBACK, "CALL BACK");
164	gename(CMDPRE, Rmtname, 'C', file);
165	close(creat(file, 0666));
166	chmod(file, 0666);
167	xuucico(Rmtname);
168	cleanup(0);
169	}
170	seq = 0;
171	while (*p == '-') {
172	q = pskip(p);
173	switch(*(++p)) {
174	case 'g':
175	Pkdrvon = 1;
176	break;
177	case 'x':
178	Debug = atoi(++p);
179	if (Debug <= 0)
180	Debug = 1;
181	break;
182	case 'Q':
183	seq = atoi(++p);
184	break;
185	default:
186	break;
187	}
188	p = q;
189	}
190	if (callok(Rmtname) == SS_BADSEQ) {
191	logent("BADSEQ", "PREVIOUS");
192	omsg('R', "BADSEQ", Ofn);
193	cleanup(0);
194	}
195	if ((ret = gnxseq(Rmtname)) == seq) {
196	omsg('R', "OK", Ofn);
197	cmtseq();
198	}
199	else {
200	systat(Rmtname, Stattype[7], Stattext[7]);
201	logent("BAD SEQ", "HANDSHAKE FAILED");
202	ulkseq();
203	omsg('R', "BADSEQ", Ofn);
204	cleanup(0);
205	}
206	}
207	loop:
208	if (!onesys) {
209	ret = gnsys(Rmtname, Spool, CMDPRE);
210	if (ret == FAIL)
211	cleanup(100);
212	if (ret == 0)
213	cleanup(0);
214	}
215	else if (Role == MASTER && callok(Rmtname) != 0) {
216	logent("SYSTEM STATUS", "CAN NOT CALL");
217	cleanup(0);
218	}
219
220	sprintf(wkpre, "%c.%.7s", CMDPRE, Rmtname);
221
222	if (Role == MASTER) {
223	/* master part */
224	signal(SIGINT, SIG_IGN);
225	signal(SIGHUP, SIG_IGN);
226	signal(SIGQUIT, SIG_IGN);
227	if (!iswrk(file, "chk", Spool, wkpre) && !onesys) {
228	logent(Rmtname, "NO WORK");
229	cleanup(0);
230	}
231	if (Ifn != -1 && Role == MASTER) {
232	write(Ofn, EOTMSG, strlen(EOTMSG));
233	close(Ofn);
234	close(Ifn);
235	Ifn = Ofn = -1;
236	rmlock(NULL);
237	clsacu();
238	sleep(3);
239	}
240	sprintf(msg, "call to %s ", Rmtname);
241	if (mlock(Rmtname) != 0) {
242	logent(msg, "LOCKED");
243	goto next;
244	}
245	Ofn = Ifn = conn(Rmtname);
246	if (Ofn < 0) {
247	logent(msg, "FAILED");
248	systat(Rmtname, Stattype[-Ofn],
249	Stattext[-Ofn]);
250	goto next;
251	}
252	else {
253	logent(msg, "SUCCEEDED");
254	}
255
256	if (setjmp(Sjbuf))
257	goto next;
258	signal(SIGALRM, timeout);
259	alarm(2 * MAXMSGTIME);
260	for (;;) {
261	ret = imsg(msg, Ifn);
262	if (ret != 0) {
263	alarm(0);
264	goto next;
265	}
266	if (msg[0] == 'S')
267	break;
268	}
269	alarm(MAXMSGTIME);
270	seq = gnxseq(Rmtname);
271	sprintf(msg, "%.7s -Q%d %s", Myname, seq, rflags);
272	omsg('S', msg, Ofn);
273	for (;;) {
274	ret = imsg(msg, Ifn);
275	DEBUG(4, "msg-%s\n", msg);
276	if (ret != 0) {
277	alarm(0);
278	ulkseq();
279	goto next;
280	}
281	if (msg[0] == 'R')
282	break;
283	}
284	alarm(0);
285	if (msg[1] == 'B') {
286	/* bad sequence */
287	logent("BAD SEQ", "HANDSHAKE FAILED");
288	systat(Rmtname, Stattype[7], Stattext[7]);
289	ulkseq();
290	goto next;
291	}
292	if (strcmp(&msg[1], "OK") != SAME) {
293	logent(&msg[1], "HANDSHAKE FAILED");
294	ulkseq();
295	goto next;
296	}
297	cmtseq();
298	}
299	ttyn = ttyname(Ifn);
300	if (ttyn != NULL)
301	chmod(ttyn, 0600);
302	DEBUG(1, " Rmtname %s, ", Rmtname);
303	DEBUG(1, "my Role %s, ", Role ? "MASTER" : "SLAVE");
304	DEBUG(1, "Spool - %s\n", Spool);
305	DEBUG(1, "Ifn - %d, ", Ifn);
306	DEBUG(1, "Ofn - %d, ", Ofn);
307	DEBUG(1, "Loginuser - %s\n", Loginuser);
308
309	ret = startup(Role);
310	if (ret != SUCCESS) {
311	logent("startup", "FAILED");
312	systat(Rmtname, SS_FAIL, "STARTUP");
313	goto next;
314	}
315	else {
316	systat(Rmtname, SS_INPROGRESS, "TALKING");
317	ret = cntrl(Role, wkpre);
318	DEBUG(1, "ret from cntrl - %d\n", ret);
319	signal(SIGINT, SIG_IGN);
320	signal(SIGHUP, SIG_IGN);
321	signal(SIGALRM, timeout);
322	if (ret == 0)
323	rmstat(Rmtname);
324
325	else
326	systat(Rmtname, SS_FAIL, "CONVERSATION");
327	alarm(MAXMSGTIME);
328	omsg('O', "OOOOO", Ofn);
329	DEBUG(4, "send OO %d,", ret);
330	if (!setjmp(Sjbuf)) {
331	for (;;) {
332	omsg('O', "OOOOO", Ofn);
333	ret = imsg(msg, Ifn);
334	if (ret != 0)
335	break;
336	if (msg[0] == 'O')
337	break;
338	}
339	}
340	alarm(0);
341	}
342	next:
343	if (!onesys) {
344	goto loop;
345	}
346	cleanup(0);
347	}
348
349
350	int Hupvec[] = {0, 0, 1};
351
352	/***
353	* cleanup(code) cleanup and exit with "code" status
354	* int code;
355	*/
356
357	cleanup(code)
358	int code;
359	{
360	int ret;
361
362	signal(SIGINT, SIG_IGN);
363	signal(SIGHUP, SIG_IGN);
364	rmlock(NULL);
365	clsacu();
366	logcls();
367	if (Role == SLAVE) {
368	ret = ioctl(0, TIOCSETP, &Savettyb);
369	DEBUG(4, "\nIfn - %d, ", Ifn);
370	DEBUG(4, "ret ioctl - %d\n", ret);
371	DEBUG(4, "tty.flags %o,", Savettyb.sg_flags);
372	DEBUG(4, "tty.ispeed %d, ", Savettyb.sg_ispeed);
373	DEBUG(4, "tty.ospeed %d, ", Savettyb.sg_ospeed);
374	ret = ioctl(0, TIOCSETP, Hupvec);
375	DEBUG(4, "ret ioctl - %d\n", ret);
376	}
377	if (Ofn != -1) {
378	if (Role == MASTER)
379	write(Ofn, EOTMSG, strlen(EOTMSG));
380	close(Ifn);
381	close(Ofn);
382	}
383	DEBUG(1, "exit code %d\n", code);
384	if (code == 0)
385	xuuxqt();
386	exit(code);
387	}
388
389	/***
390	* onintr(inter) interrupt - remove locks and exit
391	*/
392
393	onintr(inter)
394	int inter;
395	{
396	char str[30];
397	signal(inter, SIG_IGN);
398	sprintf(str, "SIGNAL %d", inter);
399	logent(str, "CAUGHT");
400	cleanup(inter);
401	}
402
403	intrINT() { onintr(SIGINT);}
404	intrHUP() { onintr(SIGHUP);}
405	intrQUIT() { onintr(SIGQUIT);}
406	intrTERM() { onintr(SIGTERM);}
407	intrEXIT() {_exit(77);}
408
409	/***
410	* fixmode(tty) fix kill/echo/raw on line
411	*
412	* return codes: none
413	*/
414
415	fixmode(tty)
416	int tty;
417	{
418	struct sgttyb ttbuf;
419	int ret;
420
421	ioctl(tty, TIOCGETP, &ttbuf);
422	ttbuf.sg_flags \|= (ANYP \| RAW);
423	ttbuf.sg_flags &= ~(ECHO \| ALLDELAY);
424	ret = ioctl(tty, TIOCSETP, &ttbuf);
425	ASSERT(ret >= 0, "RETURN FROM STTY %d", ret);
426	ioctl(tty, TIOCEXCL, 0);
427	return;
428	}
429
430
431	/***
432	* timeout() catch SIGALRM routine
433	*/
434
435	timeout()
436	{
437	longjmp(Sjbuf, 1);
438	}
439
440	static char *
441	pskip(p)
442	register char *p;
443	{
444	while( p && p != ' ' )
445	++p;
446	if( p ) p++ = 0;
447	return(p);
448	}