xref: /titanic_50/usr/src/cmd/bnu/uucico.c (revision 13237b7e1e5bd293e466307b2e06f8e0e2321a0a)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
27 /*	  All Rights Reserved  	*/
28 
29 
30 /*
31 
32  * uucp file transfer program:
33  * to place a call to a remote machine, login, and
34  * copy files between the two machines.
35 
36 */
37 /*
38  * Added check to limit the total number of uucicos as defined
39  * in the Limits file.
40  *
41  * Added -f flag to "force execution", ignoring the limit on the
42  * number of uucicos. This will be used when invoking uucico from
43  * Uutry.
44 */
45 
46 #include "uucp.h"
47 #include "log.h"
48 
49 #ifndef	V7
50 #include <sys/mkdev.h>
51 #endif /* V7 */
52 
53 #ifdef TLI
54 #include	<sys/tiuser.h>
55 #endif /* TLI */
56 
57 jmp_buf Sjbuf;
58 extern unsigned msgtime;
59 char	uuxqtarg[MAXBASENAME] = {'\0'};
60 int	uuxqtflag = 0;
61 
62 extern int	(*Setup)(), (*Teardown)();	/* defined in interface.c */
63 
64 #define USAGE	"Usage: %s [-x NUM] [-r [0|1]] -s SYSTEM -u USERID -d SPOOL -i INTERFACE [-f]\n"
65 extern void closedem();
66 void cleanup(), cleanTM();
67 
68 extern int sysaccess(), guinfo(), eaccess(), countProcs(), interface(),
69 	savline(), omsg(), restline(), imsg(), callok(), gnxseq(),
70 	cmtseq(), conn(), startup(), cntrl();
71 extern void setuucp(), fixline(), gename(), ulkseq(), pfEndfile();
72 
73 #ifdef	NOSTRANGERS
74 static void checkrmt();		/* See if we want to talk to remote. */
75 #endif /* NOSTRANGERS */
76 
77 extern char *Mytype;
78 
79 static char *pskip();
80 
81 int
82 main(argc, argv, envp)
83 int argc;
84 char *argv[];
85 char **envp;
86 {
87 
88 	extern void intrEXIT(), onintr(), timeout();
89 	extern void setservice();
90 #ifndef ATTSVR3
91 	void setTZ();
92 #endif /* ATTSVR3 */
93 	int ret, seq, exitcode;
94 	char file[NAMESIZE];
95 	char msg[BUFSIZ], *p, *q;
96 	char xflag[6];	/* -xN N is single digit */
97 	char *ttyn;
98 	char *iface;	/* interface name	*/
99 	char	cb[128];
100 	time_t	ts, tconv;
101 	char lockname[MAXFULLNAME];
102 	struct limits limitval;
103 	int maxnumb;
104 	int force = 0;	/* set to force execution, ignoring uucico limit */
105 	char gradedir[2*NAMESIZE];
106 
107 	/* Set locale environment variables local definitions */
108 	(void) setlocale(LC_ALL, "");
109 #if !defined(TEXT_DOMAIN)	/* Should be defined by cc -D */
110 #define	TEXT_DOMAIN "SYS_TEST"	/* Use this only if it wasn't */
111 #endif
112 	(void) textdomain(TEXT_DOMAIN);
113 
114 	Ulimit = ulimit(1,0L);
115 	Uid = getuid();
116 	Euid = geteuid();	/* this should be UUCPUID */
117 	if (Uid == 0)
118 	    setuid(UUCPUID);
119 	Env = envp;
120 	Role = SLAVE;
121 	strcpy(Logfile, LOGCICO);
122 	*Rmtname = NULLCHAR;
123 	Ifn = Ofn = -1;		/* must be set before signal handlers */
124 
125 	closedem();
126 	time(&Nstat.t_qtime);
127 	tconv = Nstat.t_start = Nstat.t_qtime;
128 	strcpy(Progname, "uucico");
129 	setservice(Progname);
130 	ret = sysaccess(EACCESS_SYSTEMS);
131 	ASSERT(ret == 0, Ct_OPEN, "Systems", ret);
132 	ret = sysaccess(EACCESS_DEVICES);
133 	ASSERT(ret == 0, Ct_OPEN, "Devices", ret);
134 	ret = sysaccess(EACCESS_DIALERS);
135 	ASSERT(ret == 0, Ct_OPEN, "Dialers", ret);
136 	Pchar = 'C';
137 	(void) signal(SIGILL, intrEXIT);
138 	(void) signal(SIGTRAP, intrEXIT);
139 	(void) signal(SIGIOT, intrEXIT);
140 	(void) signal(SIGEMT, intrEXIT);
141 	(void) signal(SIGFPE, intrEXIT);
142 	(void) signal(SIGBUS, intrEXIT);
143 	(void) signal(SIGSEGV, intrEXIT);
144 	(void) signal(SIGSYS, intrEXIT);
145 	if (signal(SIGPIPE, SIG_IGN) != SIG_IGN)	/* This for sockets */
146 		(void) signal(SIGPIPE, intrEXIT);
147 	(void) signal(SIGINT, onintr);
148 	(void) signal(SIGHUP, onintr);
149 	(void) signal(SIGQUIT, onintr);
150 	(void) signal(SIGTERM, onintr);
151 #ifdef SIGUSR1
152 	(void) signal(SIGUSR1, SIG_IGN);
153 #endif
154 #ifdef SIGUSR2
155 	(void) signal(SIGUSR2, SIG_IGN);
156 #endif
157 #ifdef BSD4_2
158 	(void) sigsetmask(sigblock(0) & ~(1 << (SIGALRM - 1)));
159 #endif /*BSD4_2*/
160 
161 	pfInit();
162 	scInit("xfer");
163 	ret = guinfo(Euid, User);
164 	ASSERT(ret == 0, "BAD UID ", "", ret);
165 	strncpy(Uucp, User, NAMESIZE);
166 
167 	setuucp(User);
168 
169 	*xflag = NULLCHAR;
170 	iface = "UNIX";
171 
172 	while ((ret = getopt(argc, argv, "fd:c:r:s:x:u:i:")) != EOF) {
173 		switch (ret) {
174 		case 'd':
175 			if ( eaccess(optarg, 01) != 0 ) {
176 				(void) fprintf(stderr, gettext("%s: cannot"
177 				    " access spool directory %s\n"),
178 					Progname, optarg);
179 				exit(1);
180 			}
181 			Spool = optarg;
182 			break;
183 		case 'c':
184 			Mytype = optarg;
185 			break;
186 		case 'f':
187 			++force;
188 			break;
189 		case 'r':
190 			if ( (Role = atoi(optarg)) != MASTER && Role != SLAVE ) {
191 				(void) fprintf(stderr, gettext("%s: bad value"
192 				    " '%s' for -r argument\n" USAGE),
193 					Progname, optarg, Progname);
194 				exit(1);
195 			}
196 			break;
197 		case 's':
198 			strncpy(Rmtname, optarg, MAXFULLNAME-1);
199 			if (versys(Rmtname)) {
200 			    (void) fprintf(stderr,
201 				gettext("%s: %s not in Systems file\n"),
202 				Progname, optarg);
203 			    cleanup(101);
204 			}
205 			/* set args for possible xuuxqt call */
206 			strcpy(uuxqtarg, Rmtname);
207 			/* if versys put a longer name in, truncate it again */
208 			Rmtname[MAXBASENAME] = '\0';
209 			break;
210 		case 'x':
211 			Debug = atoi(optarg);
212 			if (Debug <= 0)
213 				Debug = 1;
214 			if (Debug > 9)
215 				Debug = 9;
216 			(void) sprintf(xflag, "-x%d", Debug);
217 			break;
218 		case 'u':
219 			DEBUG(4, "Loginuser %s specified\n", optarg);
220 			strncpy(Loginuser, optarg, NAMESIZE);
221 			Loginuser[NAMESIZE - 1] = NULLCHAR;
222 			break;
223 		case 'i':
224 			/*	interface type		*/
225 			iface = optarg;
226 			break;
227 		default:
228 			(void) fprintf(stderr, gettext(USAGE), Progname);
229 			exit(1);
230 		}
231 	}
232 
233 	if (Role == MASTER || *Loginuser == NULLCHAR) {
234 	    ret = guinfo(Uid, Loginuser);
235 	    ASSERT(ret == 0, "BAD LOGIN_UID ", "", ret);
236 	}
237 
238 	/* limit the total number of uucicos */
239 	if (force) {
240 	    DEBUG(4, "force flag set (ignoring uucico limit)\n%s", "");
241 	} else if (scanlimit("uucico", &limitval) == FAIL) {
242 	    DEBUG(1, "No limits for uucico in %s\n", LIMITS);
243 	} else {
244 	    maxnumb = limitval.totalmax;
245 	    if (maxnumb < 0) {
246 		DEBUG(4, "Non-positive limit for uucico in %s\n", LIMITS);
247 		DEBUG(1, "No limits for uucico\n%s", "");
248 	    } else {
249 		DEBUG(4, "Uucico limit %d -- ", maxnumb);
250 		(void) sprintf(lockname, "%s.", LOCKPRE);
251 		if (countProcs(lockname, (maxnumb-1)) == FALSE) {
252 			DEBUG(4, "exiting\n%s", "");
253 			cleanup(101);
254 		}
255 		DEBUG(4, "continuing\n%s", "");
256 	    }
257 	}
258 
259 	pfStrtConn((Role == MASTER) ? 'M' : 'S');
260 	if (Role == MASTER) {
261 	    if (*Rmtname == NULLCHAR) {
262 		DEBUG(5, "No -s specified\n%s" , "");
263 		cleanup(101);
264 	    }
265 	    /* get Myname - it depends on who I'm calling--Rmtname */
266 	    (void) mchFind(Rmtname);
267 	    myName(Myname);
268 	    if (EQUALSN(Rmtname, Myname, MAXBASENAME)) {
269 		DEBUG(5, "This system specified: -sMyname: %s, ", Myname);
270 		cleanup(101);
271 	    }
272 	    acInit("xfer");
273 	}
274 
275 	ASSERT(chdir(Spool) == 0, Ct_CHDIR, Spool, errno);
276 	strcpy(Wrkdir, Spool);
277 
278 	scReqsys((Role == MASTER) ? Myname : Rmtname); /* log requestor system */
279 
280 	if (Role == SLAVE) {
281 
282 #ifndef ATTSVR3
283 		setTZ();
284 #endif /* ATTSVR3 */
285 
286 		if (freopen(RMTDEBUG, "a", stderr) == 0) {
287 			errent(Ct_OPEN, RMTDEBUG, errno, __FILE__, __LINE__);
288 			freopen("/dev/null", "w", stderr);
289 		}
290 		if ( interface(iface) ) {
291 			(void)fprintf(stderr,
292 			"%s: invalid interface %s\n", Progname, iface);
293 			cleanup(101);
294 		}
295 		/*master setup will be called from processdev()*/
296 		if ( (*Setup)( Role, &Ifn, &Ofn ) ) {
297 			DEBUG(5, "SLAVE Setup failed%s", "");
298 			cleanup(101);
299 		}
300 
301 		/*
302 		 * initial handshake
303 		 */
304 		(void) savline();
305 		fixline(Ifn, 0, D_ACU);
306 		/* get MyName - use logFind to check PERMISSIONS file */
307 		(void) logFind(Loginuser, "");
308 		myName(Myname);
309 
310 		DEBUG(4,"cico.c: Myname - %s\n",Myname);
311 		DEBUG(4,"cico.c: Loginuser - %s\n",Loginuser);
312 		fflush(stderr);
313 		Nstat.t_scall = times(&Nstat.t_tga);
314 		(void) sprintf(msg, "here=%s", Myname);
315 		omsg('S', msg, Ofn);
316 		(void) signal(SIGALRM, timeout);
317 		(void) alarm(msgtime); /* give slow machines a second chance */
318 		if (setjmp(Sjbuf)) {
319 
320 			/*
321 			 * timed out
322 			 */
323 			(void) restline();
324 			rmlock(CNULL);
325 			exit(0);
326 		}
327 		for (;;) {
328 			ret = imsg(msg, Ifn);
329 			if (ret != 0) {
330 				(void) alarm(0);
331 				(void) restline();
332 				rmlock(CNULL);
333 				exit(0);
334 			}
335 			if (msg[0] == 'S')
336 				break;
337 		}
338 		Nstat.t_ecall = times(&Nstat.t_tga);
339 		(void) alarm(0);
340 		q = &msg[1];
341 		p = pskip(q);
342 		strncpy(Rmtname, q, MAXBASENAME);
343 		Rmtname[MAXBASENAME] = '\0';
344 
345 		seq = 0;
346 		while (p && *p == '-') {
347 			q = pskip(p);
348 			switch(*(++p)) {
349 			case 'x':
350 				Debug = atoi(++p);
351 				if (Debug <= 0)
352 					Debug = 1;
353 				(void) sprintf(xflag, "-x%d", Debug);
354 				break;
355 			case 'Q':
356 				seq = atoi(++p);
357 				if (seq < 0)
358 					seq = 0;
359 				break;
360 #ifdef MAXGRADE
361 			case 'v':	/* version -- -vname=val or -vname */
362 				if (strncmp(++p, "grade=", 6) == 0 &&
363 				    isalnum(p[6]))
364 					MaxGrade = p[6];
365 				break;
366 #endif /* MAXGRADE */
367 			case 'R':
368 				Restart++;
369 				p++;
370 				break;
371 			case 'U':
372 				SizeCheck++;
373 				RemUlimit = strtol(++p, (char **) NULL,0);
374 				break;
375 			default:
376 				break;
377 			}
378 			p = q;
379 		}
380 		DEBUG(4, "sys-%s\n", Rmtname);
381 		if (strpbrk(Rmtname, Shchar) != NULL) {
382 			DEBUG(4, "Bad remote system name '%s'\n", Rmtname);
383 			logent(Rmtname, "BAD REMOTE SYSTEM NAME");
384 			omsg('R', "Bad remote system name", Ofn);
385 			cleanup(101);
386 		}
387 		if (Restart)
388 		    CDEBUG(1,"Checkpoint Restart enabled\n%s", "");
389 
390 #ifdef NOSTRANGERS
391 		checkrmt();	/* Do we know the remote system. */
392 #else
393 		(void) versys(Rmtname);	/* in case the real name is longer */
394 #endif /* NOSTRANGERS */
395 
396 		(void) sprintf(lockname, "%ld", (long) getpid());
397 		if (umlock(LOCKPRE, lockname)) {
398 			omsg('R', "LCK", Ofn);
399 			cleanup(101);
400 		}
401 
402 		/* validate login using PERMISSIONS file */
403 		if (logFind(Loginuser, Rmtname) == FAIL) {
404 			scWrite(); /* log security violation */
405 			Uerror = SS_BAD_LOG_MCH;
406 			logent(UERRORTEXT, "FAILED");
407 			systat(Rmtname, SS_BAD_LOG_MCH, UERRORTEXT,
408 			    Retrytime);
409 			omsg('R', "LOGIN", Ofn);
410 			cleanup(101);
411 		}
412 
413 		ret = callBack();
414 		DEBUG(4,"return from callcheck: %s",ret ? "TRUE" : "FALSE");
415 		if (ret==TRUE) {
416 			(void) signal(SIGINT, SIG_IGN);
417 			(void) signal(SIGHUP, SIG_IGN);
418 			omsg('R', "CB", Ofn);
419 			logent("CALLBACK", "REQUIRED");
420 			/*
421 			 * set up for call back
422 			 */
423 			chremdir(Rmtname);
424 			(void) sprintf(file, "%s/%c", Rmtname, D_QUEUE);
425 			chremdir(file);
426 			gename(CMDPRE, Rmtname, 'C', file);
427 			(void) close(creat(file, CFILEMODE));
428 			if (callok(Rmtname) == SS_CALLBACK_LOOP) {
429 			    systat(Rmtname, SS_CALLBACK_LOOP, "CALL BACK - LOOP", Retrytime);
430 			} else {
431 			    systat(Rmtname, SS_CALLBACK, "CALL BACK", Retrytime);
432 			    xuucico(Rmtname);
433 			}
434 			cleanup(101);
435 		}
436 
437 		if (callok(Rmtname) == SS_SEQBAD) {
438 			Uerror = SS_SEQBAD;
439 			logent(UERRORTEXT, "PREVIOUS");
440 			omsg('R', "BADSEQ", Ofn);
441 			cleanup(101);
442 		}
443 
444 		if (gnxseq(Rmtname) == seq) {
445 			if (Restart) {
446 			    if (SizeCheck)
447 				(void) sprintf (msg, "OK -R -U0x%lx %s",
448 					Ulimit, xflag);
449 			    else
450 				(void) sprintf (msg, "OK -R %s", xflag);
451 			    omsg('R', msg, Ofn);
452 			} else
453 			    omsg('R', "OK", Ofn);
454 			(void) cmtseq();
455 		} else {
456 			Uerror = SS_SEQBAD;
457 			systat(Rmtname, SS_SEQBAD, UERRORTEXT, Retrytime);
458 			logent(UERRORTEXT, "HANDSHAKE FAILED");
459 			ulkseq();
460 			omsg('R', "BADSEQ", Ofn);
461 			cleanup(101);
462 		}
463 		ttyn = ttyname(Ifn);
464 		if (ttyn != CNULL && *ttyn != NULLCHAR) {
465 			struct stat ttysbuf;
466 			if ( fstat(Ifn,&ttysbuf) == 0 )
467 				Dev_mode = ttysbuf.st_mode;
468 			else
469 				Dev_mode = R_DEVICEMODE;
470 			if ( EQUALSN(ttyn,"/dev/",5) )
471 			    strcpy(Dc, ttyn+5);
472 			else
473 			    strcpy(Dc, ttyn);
474 			chmod(ttyn, S_DEVICEMODE);
475 		} else
476 			strcpy(Dc, "notty");
477 		/* set args for possible xuuxqt call */
478 		strcpy(uuxqtarg, Rmtname);
479 	}
480 
481 	strcpy(User, Uucp);
482 /*
483  *  Ensure reasonable ulimit (MINULIMIT)
484  */
485 
486 #ifndef	V7
487 	{
488 	long 	minulimit;
489 	minulimit = ulimit(1, (long) 0);
490 	ASSERT(minulimit >= MINULIMIT, "ULIMIT TOO SMALL",
491 	    Loginuser, (int) minulimit);
492 	}
493 #endif
494 	if (Role == MASTER && callok(Rmtname) != 0) {
495 		logent("SYSTEM STATUS", "CAN NOT CALL");
496 		cleanup(101);
497 	}
498 
499 	chremdir(Rmtname);
500 
501 	(void) strcpy(Wrkdir, RemSpool);
502 	if (Role == MASTER) {
503 
504 		/*
505 		 * master part
506 		 */
507 		(void) signal(SIGINT, SIG_IGN);
508 		(void) signal(SIGHUP, SIG_IGN);
509 		(void) signal(SIGQUIT, SIG_IGN);
510 		if (Ifn != -1 && Role == MASTER) {
511 			(void) (*Write)(Ofn, EOTMSG, strlen(EOTMSG));
512 			(void) close(Ofn);
513 			(void) close(Ifn);
514 			Ifn = Ofn = -1;
515 			rmlock(CNULL);
516 			sleep(3);
517 		}
518 
519 		/*
520 		 * Find the highest priority job grade that has
521 		 * jobs to do. This is needed to form the lock name.
522 		 */
523 
524 		findgrade(RemSpool, JobGrade);
525 		DEBUG(4, "Job grade to process - %s\n", JobGrade);
526 
527 		/*
528 		 * Lock the job grade if there is one to process.
529 		 */
530 
531 		if (*JobGrade != NULLCHAR) {
532 			(void) sprintf(gradedir, "%s/%s", Rmtname, JobGrade);
533 			chremdir(gradedir);
534 
535 			(void) sprintf(lockname, "%.*s.%s", SYSNSIZE, Rmtname, JobGrade);
536 			(void) sprintf(msg, "call to %s - process job grade %s ",
537 			    Rmtname, JobGrade);
538 			if (umlock(LOCKPRE, lockname) != 0) {
539 				logent(msg, "LOCKED");
540 				CDEBUG(1, "Currently Talking With %s\n",
541 				    Rmtname);
542  				cleanup(100);
543 			}
544 		} else {
545 			(void) sprintf(msg, "call to %s - no work", Rmtname);
546 		}
547 
548 		Nstat.t_scall = times(&Nstat.t_tga);
549 		Ofn = Ifn = conn(Rmtname);
550 		Nstat.t_ecall = times(&Nstat.t_tga);
551 		if (Ofn < 0) {
552 			delock(LOCKPRE, lockname);
553 			logent(UERRORTEXT, "CONN FAILED");
554 			systat(Rmtname, Uerror, UERRORTEXT, Retrytime);
555 			cleanup(101);
556 		} else {
557 			logent(msg, "SUCCEEDED");
558 			ttyn = ttyname(Ifn);
559 			if (ttyn != CNULL && *ttyn != NULLCHAR) {
560 				struct stat ttysbuf;
561 				if ( fstat(Ifn,&ttysbuf) == 0 )
562 					Dev_mode = ttysbuf.st_mode;
563 				else
564 					Dev_mode = R_DEVICEMODE;
565 				chmod(ttyn, M_DEVICEMODE);
566 			}
567 		}
568 
569 		if (setjmp(Sjbuf)) {
570 			delock(LOCKPRE, lockname);
571 			Uerror = SS_LOGIN_FAILED;
572 			logent(Rmtname, UERRORTEXT);
573 			systat(Rmtname, SS_LOGIN_FAILED,
574 			    UERRORTEXT, Retrytime);
575 			DEBUG(4, "%s - failed\n", UERRORTEXT);
576 			cleanup(101);
577 		}
578 		(void) signal(SIGALRM, timeout);
579 		/* give slow guys lots of time to thrash */
580 		(void) alarm(2 * msgtime);
581 		for (;;) {
582 			ret = imsg(msg, Ifn);
583 			if (ret != 0) {
584 				continue; /* try again */
585 			}
586 			if (msg[0] == 'S')
587 				break;
588 		}
589 		(void) alarm(0);
590 		if(EQUALSN("here=", &msg[1], 5)){
591 			/* This may be a problem, we check up to MAXBASENAME
592 			 * characters now. The old comment was:
593 			 * this is a problem.  We'd like to compare with an
594 			 * untruncated Rmtname but we fear incompatability.
595 			 * So we'll look at most 6 chars (at most).
596 			 */
597 			(void) pskip(&msg[6]);
598 			if (!EQUALSN(&msg[6], Rmtname, MAXBASENAME)) {
599 				delock(LOCKPRE, lockname);
600 				Uerror = SS_WRONG_MCH;
601 				logent(&msg[6], UERRORTEXT);
602 				systat(Rmtname, SS_WRONG_MCH, UERRORTEXT,
603 				     Retrytime);
604 				DEBUG(4, "%s - failed\n", UERRORTEXT);
605 				cleanup(101);
606 			}
607 		}
608 		CDEBUG(1,"Login Successful: System=%s\n",&msg[6]);
609 		seq = gnxseq(Rmtname);
610 		(void) sprintf(msg, "%s -Q%d -R -U0x%lx %s",
611 			Myname, seq, Ulimit, xflag);
612 #ifdef MAXGRADE
613 		if (MaxGrade != NULLCHAR) {
614 			p = strchr(msg, NULLCHAR);
615 			sprintf(p, " -vgrade=%c", MaxGrade);
616 		}
617 #endif /* MAXGRADE */
618 		omsg('S', msg, Ofn);
619 		(void) alarm(msgtime);	/* give slow guys some thrash time */
620 		for (;;) {
621 			ret = imsg(msg, Ifn);
622 			DEBUG(4, "msg-%s\n", msg);
623 			if (ret != 0) {
624 				(void) alarm(0);
625 				delock(LOCKPRE, lockname);
626 				ulkseq();
627 				cleanup(101);
628 			}
629 			if (msg[0] == 'R')
630 				break;
631 		}
632 		(void) alarm(0);
633 
634 		/*  check for rejects from remote */
635 		Uerror = 0;
636 		if (EQUALS(&msg[1], "LCK"))
637 			Uerror = SS_RLOCKED;
638 		else if (EQUALS(&msg[1], "LOGIN"))
639 			Uerror = SS_RLOGIN;
640 		else if (EQUALS(&msg[1], "CB"))
641 			Uerror = (callBack() ? SS_CALLBACK_LOOP : SS_CALLBACK);
642 		else if (EQUALS(&msg[1], "You are unknown to me"))
643 			Uerror = SS_RUNKNOWN;
644 		else if (EQUALS(&msg[1], "BADSEQ"))
645 			Uerror = SS_SEQBAD;
646 		else if (!EQUALSN(&msg[1], "OK", 2))
647 			Uerror = SS_UNKNOWN_RESPONSE;
648 		if (Uerror)  {
649 			delock(LOCKPRE, lockname);
650 			systat(Rmtname, Uerror, UERRORTEXT, Retrytime);
651 			logent(UERRORTEXT, "HANDSHAKE FAILED");
652 			CDEBUG(1, "HANDSHAKE FAILED: %s\n", UERRORTEXT);
653 			ulkseq();
654 			cleanup(101);
655 		}
656 		(void) cmtseq();
657 
658 		/*
659 		 * See if we have any additional parameters on the OK
660 		 */
661 
662 		if (strlen(&msg[3])) {
663 			p = pskip(&msg[3]);
664 			while (p && *p == '-') {
665 				q = pskip(p);
666 				switch(*(++p)) {
667 				case 'R':
668 					Restart++;
669 					p++;
670 					break;
671 				case 'U':
672 					SizeCheck++;
673 					RemUlimit = strtol(++p, (char **) NULL, 0);
674 					break;
675 				case 'x':
676 					if (!Debug) {
677 						Debug = atoi(++p);
678 						if (Debug <= 0)
679 							Debug = 1;
680 					}
681 					break;
682 				default:
683 					break;
684 				}
685 				p = q;
686 			}
687 		}
688 
689 	}
690 	DEBUG(4, " Rmtname %s, ", Rmtname);
691 	DEBUG(4, " Restart %s, ", (Restart ? "YES" : "NO"));
692 	DEBUG(4, "Role %s,  ", Role ? "MASTER" : "SLAVE");
693 	DEBUG(4, "Ifn - %d, ", Ifn);
694 	DEBUG(4, "Loginuser - %s\n", Loginuser);
695 
696 	/* alarm/setjmp added here due to experience with uucico
697 	 * hanging for hours in imsg().
698 	 */
699 	if (setjmp(Sjbuf)) {
700 		delock(LOCKPRE, lockname);
701 		logent("startup", "TIMEOUT");
702 		DEBUG(4, "%s - timeout\n", "startup");
703 		cleanup(101);
704 	}
705 	(void) alarm(MAXSTART);
706 	ret = startup();
707 	(void) alarm(0);
708 
709 	if (ret != SUCCESS) {
710 		delock(LOCKPRE, lockname);
711 		logent("startup", "FAILED");
712 		Uerror = SS_STARTUP;
713 		CDEBUG(1, "%s\n", UERRORTEXT);
714 		systat(Rmtname, Uerror, UERRORTEXT, Retrytime);
715 		exitcode = 101;
716 	} else {
717 		pfConnected(Rmtname, Dc);
718 		acConnected(Rmtname, Dc);
719 		logent("startup", "OK");
720 		systat(Rmtname, SS_INPROGRESS, UTEXT(SS_INPROGRESS),Retrytime);
721 		Nstat.t_sftp = times(&Nstat.t_tga);
722 
723 		exitcode = cntrl();
724 		Nstat.t_eftp = times(&Nstat.t_tga);
725 		DEBUG(4, "cntrl - %d\n", exitcode);
726 		(void) signal(SIGINT, SIG_IGN);
727 		(void) signal(SIGHUP, SIG_IGN);
728 		(void) signal(SIGALRM, timeout);
729 
730 		if (exitcode == 0) {
731 			(void) time(&ts);
732 			(void) sprintf(cb, "conversation complete %s %ld",
733 				Dc, ts - tconv);
734 			logent(cb, "OK");
735 			systat(Rmtname, SS_OK, UTEXT(SS_OK), Retrytime);
736 
737 		} else {
738 			logent("conversation complete", "FAILED");
739 			systat(Rmtname, SS_CONVERSATION,
740 			    UTEXT(SS_CONVERSATION), Retrytime);
741 		}
742 		(void) alarm(msgtime);	/* give slow guys some thrash time */
743 		omsg('O', "OOOOO", Ofn);
744 		CDEBUG(4, "send OO %d,", ret);
745 		if (!setjmp(Sjbuf)) {
746 			for (;;) {
747 				omsg('O', "OOOOO", Ofn);
748 				ret = imsg(msg, Ifn);
749 				if (ret != 0)
750 					break;
751 				if (msg[0] == 'O')
752 					break;
753 			}
754 		}
755 		(void) alarm(0);
756 	}
757 	cleanup(exitcode);
758 	/*NOTREACHED*/
759 	return (0);
760 }
761 
762 /*
763  * clean and exit with "code" status
764  */
765 void
766 cleanup(code)
767 int code;
768 {
769 	(void) signal(SIGINT, SIG_IGN);
770 	(void) signal(SIGHUP, SIG_IGN);
771 	rmlock(CNULL);
772 	closedem();
773 	alarm(msgtime);		/* Start timer in case closes hang. */
774 	if (setjmp(Sjbuf) == 0)
775 		(*Teardown)( Role, Ifn, Ofn );
776 	alarm(0);			/* Turn off timer. */
777 	DEBUG(4, "exit code %d\n", code);
778 	CDEBUG(1, "Conversation Complete: Status %s\n\n",
779 	    code ? "FAILED" : "SUCCEEDED");
780 
781 	cleanTM();
782 	if ((code == 0) && (uuxqtflag == 1))
783 		xuuxqt(uuxqtarg);
784 	exit(code);
785 }
786 
787 short TM_cnt = 0;
788 char TM_name[MAXNAMESIZE];
789 
790 void
791 cleanTM()
792 {
793 	int i;
794 	char tm_name[MAXNAMESIZE];
795 
796 	DEBUG(7,"TM_cnt: %d\n",TM_cnt);
797 	for(i=0; i < TM_cnt; i++) {
798 		(void) sprintf(tm_name, "%s.%3.3d", TM_name, i);
799 		DEBUG(7, "tm_name: %s\n", tm_name);
800 		unlink(tm_name);
801 	}
802 	return;
803 }
804 
805 void
806 TMname(file, pnum)
807 char *file;
808 pid_t pnum;
809 {
810 
811 	(void) sprintf(file, "%s/TM.%.5ld.%.3d", RemSpool, (long) pnum, TM_cnt);
812 	if (TM_cnt == 0)
813 	    (void) sprintf(TM_name, "%s/TM.%.5ld", RemSpool, (long) pnum);
814 	DEBUG(7, "TMname(%s)\n", file);
815 	TM_cnt++;
816 	return;
817 }
818 
819 /*
820  * intrrupt - remove locks and exit
821  */
822 void
823 onintr(inter)
824 int inter;
825 {
826 	char str[30];
827 	/* I'm putting a test for zero here because I saw it happen
828 	 * and don't know how or why, but it seemed to then loop
829 	 * here for ever?
830 	 */
831 	if (inter == 0)
832 	    exit(99);
833 	(void) signal(inter, SIG_IGN);
834 	(void) sprintf(str, "SIGNAL %d", inter);
835 	logent(str, "CAUGHT");
836 	pfEndfile("PARTIAL FILE");
837 	acEnd(PARTIAL); /*stop collecting accounting log */
838 	cleanup(inter);
839 }
840 
841 void
842 intrEXIT(inter)
843 int inter;
844 {
845 	char	cb[20];
846 
847 	(void) sprintf(cb, "SIGNAL %d", inter);
848 	logent("INTREXIT", cb);
849 	(void) signal(SIGIOT, SIG_DFL);
850 	(void) signal(SIGILL, SIG_DFL);
851 	rmlock(CNULL);
852 	closedem();
853 	(void) setuid(Uid);
854 	abort();
855 }
856 
857 /*
858  * catch SIGALRM routine
859  */
860 void
861 timeout()
862 {
863 	longjmp(Sjbuf, 1);
864 }
865 
866 /* skip to next field */
867 static char *
868 pskip(p)
869 char *p;
870 {
871 	if ((p = strchr(p, ' ')) != CNULL)
872 		do
873 			*p++ = NULLCHAR;
874 		while (*p == ' ');
875 	return(p);
876 }
877 
878 void
879 closedem()
880 {
881 	int i, maxfiles;
882 
883 #ifdef ATTSVR3
884 	maxfiles = ulimit(4,0);
885 #else /* !ATTSVR3 */
886 #ifdef BSD4_2
887 	maxfiles = getdtablesize();
888 #else /* BSD4_2 */
889 	maxfiles = _NFILE;
890 #endif /* BSD4_2 */
891 #endif /* ATTSVR3 */
892 
893 	for (  i = 3; i < maxfiles; i++ )
894 		if ( i != Ifn && i != Ofn && i != fileno(stderr) )
895 			(void) close(i);
896 	return;
897 }
898 
899 #ifndef ATTSVR3
900 
901 /*
902  *	setTZ()
903  *
904  *	if login "shell" is uucico (i.e., Role == SLAVE), must set
905  *	timezone env variable TZ.  otherwise will default to EST.
906  */
907 
908 #define	LINELEN	81
909 
910 void
911 setTZ()
912 {
913 	static char	buf[LINELEN], *bp;
914 	extern char	*fgets();
915 	FILE		*tzfp;
916 	extern FILE	*fopen();
917 	int		i;
918 	extern int	fclose(), strncmp();
919 
920 	if ( (tzfp = fopen("/etc/TIMEZONE","r")) == (FILE *)NULL )
921 		return;
922 	while ( (bp = fgets(buf,LINELEN,tzfp)) != (char *)NULL ) {
923 		while ( isspace(*bp) )
924 			++bp;
925 		if ( strncmp(bp, "TZ=", 3) == 0 ) {
926 			for ( i = strlen(bp) - 1; i > 0 && isspace(*(bp+i)); --i )
927 				*(bp+i) = '\0';
928 			putenv(bp);
929 			(void)fclose(tzfp);
930 			return;
931 		}
932 	}
933 	(void)fclose(tzfp);
934 	return;
935 }
936 #endif /* ATTSVR3 */
937 
938 #ifdef NOSTRANGERS
939 /*
940 * Function:	checkrmt
941 *
942 * If NOSTRANGERS is defined, see if the remote system is in our systems
943 * file.  If it is not, execute NOSTRANGERS and then reject the call.
944 */
945 
946 static void
947 checkrmt ()
948 
949 {
950 	char **	eVarPtr;	/* Pointer to environment variable. */
951 	char	msgbuf[BUFSIZ];	/* Place to build messages. */
952 	pid_t	procid;		/* ID of Nostranger process. */
953 	static char * safePath = PATH;
954 	int	status;		/* Exit status of child. */
955 	pid_t	waitrv;		/* Return value from wait system call. */
956 
957 	/* here's the place to look the remote system up in the Systems file.
958 	 * If the command NOSTRANGERS is executable and
959 	 * If they're not in my file then hang up */
960 
961 	if (versys(Rmtname) && (access(NOSTRANGERS, 1) == 0)) {
962 		sprintf(msgbuf, "Invoking %s for %%s\n", NOSTRANGERS);
963 		DEBUG(4, msgbuf, Rmtname);
964 
965 		/*
966 		* Ignore hangup in case remote goes away before we can
967 		* finish logging.
968 		*/
969 
970 		(void) signal(SIGHUP, SIG_IGN);
971 		omsg('R', "You are unknown to me", Ofn);
972 		scWrite(); /* log unknown remote system */
973 		procid = fork();
974 		if ( procid == 0 ) {
975 			/*
976 			* Before execing the no strangers program, there is
977 			* a security aspect to consider.  If NOSTRANGERS is
978 			* not a full path name, then the PATH environment
979 			* variable will provide places to look for the file.
980 			* To be safe, we will set the PATH environment
981 			* variable before we do the exec.
982 			*/
983 
984 			/* Find PATH in current environment and change it. */
985 
986 			for (eVarPtr = Env; *eVarPtr != CNULL; eVarPtr++) {
987 				if (PREFIX("PATH=", *eVarPtr))
988 					*eVarPtr = safePath;
989 			}
990 			execlp( NOSTRANGERS, "stranger", Rmtname, (char *) 0);
991 			sprintf(msgbuf, "Execlp of %s failed with errno=%%d\n",
992 				NOSTRANGERS);
993 			DEBUG(4, msgbuf, errno);
994 			perror(gettext("cico.c: execlp NOSTRANGERS failed"));
995 			cleanup(errno);
996 		} else if (procid < 0) {
997 			perror(gettext("cico.c: execlp NOSTRANGERS failed"));
998 			cleanup(errno);
999 		} else {
1000 			while ((waitrv = wait(&status)) != procid)
1001 				if (waitrv == -1 && errno != EINTR)
1002 					cleanup(errno);
1003 			sprintf(msgbuf, "%s exit status was %%#x\n",
1004 				NOSTRANGERS);
1005 			DEBUG(4, msgbuf, status);
1006 		}
1007 		cleanup(101);
1008 	}
1009 }
1010 #endif /* NOSTRANGERS */
1011