xref: /titanic_53/usr/src/cmd/bnu/uucico.c (revision 7c478bd95313f5f23a4c958a745db2134aa03244)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 1995 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/


#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*

 * uucp file transfer program:
 * to place a call to a remote machine, login, and
 * copy files between the two machines.

*/
/*
 * Added check to limit the total number of uucicos as defined
 * in the Limits file.
 *
 * Added -f flag to "force execution", ignoring the limit on the
 * number of uucicos. This will be used when invoking uucico from
 * Uutry.
*/

#include "uucp.h"
#include "log.h"

#ifndef	V7
#include <sys/mkdev.h>
#endif /* V7 */

#ifdef TLI
#include	<sys/tiuser.h>
#endif /* TLI */

jmp_buf Sjbuf;
extern unsigned msgtime;
char	uuxqtarg[MAXBASENAME] = {'\0'};
int	uuxqtflag = 0;

extern int	(*Setup)(), (*Teardown)();	/* defined in interface.c */

#define USAGE	"Usage: %s [-x NUM] [-r [0|1]] -s SYSTEM -u USERID -d SPOOL -i INTERFACE [-f]\n"
extern void closedem();
void cleanup(), cleanTM();

extern int sysaccess(), guinfo(), eaccess(), countProcs(), interface(),
	savline(), omsg(), restline(), imsg(), callok(), gnxseq(),
	cmtseq(), conn(), startup(), cntrl();
extern void setuucp(), fixline(), gename(), ulkseq(), pfEndfile();

#ifdef	NOSTRANGERS
static void checkrmt();		/* See if we want to talk to remote. */
#endif /* NOSTRANGERS */

extern char *Mytype;

main(argc, argv, envp)
char *argv[];
char **envp;
{

	extern void intrEXIT(), onintr(), timeout();
	static char *pskip();
	extern void setservice();
#ifndef ATTSVR3
	void setTZ();
#endif /* ATTSVR3 */
	int ret, seq, exitcode;
	char file[NAMESIZE];
	char msg[BUFSIZ], *p, *q;
	char xflag[6];	/* -xN N is single digit */
	char *ttyn;
	char *iface;	/* interface name	*/
	char	cb[128];
	time_t	ts, tconv;
	char lockname[MAXFULLNAME];
	struct limits limitval;
	int maxnumb;
	int force = 0;	/* set to force execution, ignoring uucico limit */
	char gradedir[2*NAMESIZE];

	/* Set locale environment variables local definitions */
	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)	/* Should be defined by cc -D */
#define	TEXT_DOMAIN "SYS_TEST"	/* Use this only if it wasn't */
#endif
	(void) textdomain(TEXT_DOMAIN);

	Ulimit = ulimit(1,0L);
	Uid = getuid();
	Euid = geteuid();	/* this should be UUCPUID */
	if (Uid == 0)
	    setuid(UUCPUID);
	Env = envp;
	Role = SLAVE;
	strcpy(Logfile, LOGCICO);
	*Rmtname = NULLCHAR;
	Ifn = Ofn = -1;		/* must be set before signal handlers */

	closedem();
	time(&Nstat.t_qtime);
	tconv = Nstat.t_start = Nstat.t_qtime;
	strcpy(Progname, "uucico");
	setservice(Progname);
	ret = sysaccess(EACCESS_SYSTEMS);
	ASSERT(ret == 0, Ct_OPEN, "Systems", ret);
	ret = sysaccess(EACCESS_DEVICES);
	ASSERT(ret == 0, Ct_OPEN, "Devices", ret);
	ret = sysaccess(EACCESS_DIALERS);
	ASSERT(ret == 0, Ct_OPEN, "Dialers", ret);
	Pchar = 'C';
	(void) signal(SIGILL, intrEXIT);
	(void) signal(SIGTRAP, intrEXIT);
	(void) signal(SIGIOT, intrEXIT);
	(void) signal(SIGEMT, intrEXIT);
	(void) signal(SIGFPE, intrEXIT);
	(void) signal(SIGBUS, intrEXIT);
	(void) signal(SIGSEGV, intrEXIT);
	(void) signal(SIGSYS, intrEXIT);
	if (signal(SIGPIPE, SIG_IGN) != SIG_IGN)	/* This for sockets */
		(void) signal(SIGPIPE, intrEXIT);
	(void) signal(SIGINT, onintr);
	(void) signal(SIGHUP, onintr);
	(void) signal(SIGQUIT, onintr);
	(void) signal(SIGTERM, onintr);
#ifdef SIGUSR1
	(void) signal(SIGUSR1, SIG_IGN);
#endif
#ifdef SIGUSR2
	(void) signal(SIGUSR2, SIG_IGN);
#endif
#ifdef BSD4_2
	(void) sigsetmask(sigblock(0) & ~(1 << (SIGALRM - 1)));
#endif /*BSD4_2*/

	pfInit();
	scInit("xfer");
	ret = guinfo(Euid, User);
	ASSERT(ret == 0, "BAD UID ", "", ret);
	strncpy(Uucp, User, NAMESIZE);

	setuucp(User);

	*xflag = NULLCHAR;
	iface = "UNIX";

	while ((ret = getopt(argc, argv, "fd:c:r:s:x:u:i:")) != EOF) {
		switch (ret) {
		case 'd':
			if ( eaccess(optarg, 01) != 0 ) {
				(void) fprintf(stderr, gettext("%s: cannot"
				    " access spool directory %s\n"),
					Progname, optarg);
				exit(1);
			}
			Spool = optarg;
			break;
		case 'c':
			Mytype = optarg;
			break;
		case 'f':
			++force;
			break;
		case 'r':
			if ( (Role = atoi(optarg)) != MASTER && Role != SLAVE ) {
				(void) fprintf(stderr, gettext("%s: bad value"
				    " '%s' for -r argument\n" USAGE),
					Progname, optarg, Progname);
				exit(1);
			}
			break;
		case 's':
			strncpy(Rmtname, optarg, MAXFULLNAME-1);
			if (versys(Rmtname)) {
			    (void) fprintf(stderr,
				gettext("%s: %s not in Systems file\n"),
				Progname, optarg);
			    cleanup(101);
			}
			/* set args for possible xuuxqt call */
			strcpy(uuxqtarg, Rmtname);
			/* if versys put a longer name in, truncate it again */
			Rmtname[MAXBASENAME] = '\0';
			break;
		case 'x':
			Debug = atoi(optarg);
			if (Debug <= 0)
				Debug = 1;
			if (Debug > 9)
				Debug = 9;
			(void) sprintf(xflag, "-x%d", Debug);
			break;
		case 'u':
			DEBUG(4, "Loginuser %s specified\n", optarg);
			strncpy(Loginuser, optarg, NAMESIZE);
			Loginuser[NAMESIZE - 1] = NULLCHAR;
			break;
		case 'i':
			/*	interface type		*/
			iface = optarg;
			break;
		default:
			(void) fprintf(stderr, gettext(USAGE), Progname);
			exit(1);
		}
	}

	if (Role == MASTER || *Loginuser == NULLCHAR) {
	    ret = guinfo(Uid, Loginuser);
	    ASSERT(ret == 0, "BAD LOGIN_UID ", "", ret);
	}

	/* limit the total number of uucicos */
	if (force) {
	    DEBUG(4, "force flag set (ignoring uucico limit)\n%s", "");
	} else if (scanlimit("uucico", &limitval) == FAIL) {
	    DEBUG(1, "No limits for uucico in %s\n", LIMITS);
	} else {
	    maxnumb = limitval.totalmax;
	    if (maxnumb < 0) {
		DEBUG(4, "Non-positive limit for uucico in %s\n", LIMITS);
		DEBUG(1, "No limits for uucico\n%s", "");
	    } else {
		DEBUG(4, "Uucico limit %d -- ", maxnumb);
		(void) sprintf(lockname, "%s.", LOCKPRE);
		if (countProcs(lockname, (maxnumb-1)) == FALSE) {
			DEBUG(4, "exiting\n%s", "");
			cleanup(101);
		}
		DEBUG(4, "continuing\n%s", "");
	    }
	}

	pfStrtConn((Role == MASTER) ? 'M' : 'S');
	if (Role == MASTER) {
	    if (*Rmtname == NULLCHAR) {
		DEBUG(5, "No -s specified\n%s" , "");
		cleanup(101);
	    }
	    /* get Myname - it depends on who I'm calling--Rmtname */
	    (void) mchFind(Rmtname);
	    myName(Myname);
	    if (EQUALSN(Rmtname, Myname, MAXBASENAME)) {
		DEBUG(5, "This system specified: -sMyname: %s, ", Myname);
		cleanup(101);
	    }
	    acInit("xfer");
	}

	ASSERT(chdir(Spool) == 0, Ct_CHDIR, Spool, errno);
	strcpy(Wrkdir, Spool);

	scReqsys((Role == MASTER) ? Myname : Rmtname); /* log requestor system */

	if (Role == SLAVE) {

#ifndef ATTSVR3
		setTZ();
#endif /* ATTSVR3 */

		if (freopen(RMTDEBUG, "a", stderr) == 0) {
			errent(Ct_OPEN, RMTDEBUG, errno, __FILE__, __LINE__);
			freopen("/dev/null", "w", stderr);
		}
		if ( interface(iface) ) {
			(void)fprintf(stderr,
			"%s: invalid interface %s\n", Progname, iface);
			cleanup(101);
		}
		/*master setup will be called from processdev()*/
		if ( (*Setup)( Role, &Ifn, &Ofn ) ) {
			DEBUG(5, "SLAVE Setup failed%s", "");
			cleanup(101);
		}

		/*
		 * initial handshake
		 */
		(void) savline();
		fixline(Ifn, 0, D_ACU);
		/* get MyName - use logFind to check PERMISSIONS file */
		(void) logFind(Loginuser, "");
		myName(Myname);

		DEBUG(4,"cico.c: Myname - %s\n",Myname);
		DEBUG(4,"cico.c: Loginuser - %s\n",Loginuser);
		fflush(stderr);
		Nstat.t_scall = times(&Nstat.t_tga);
		(void) sprintf(msg, "here=%s", Myname);
		omsg('S', msg, Ofn);
		(void) signal(SIGALRM, timeout);
		(void) alarm(msgtime); /* give slow machines a second chance */
		if (setjmp(Sjbuf)) {

			/*
			 * timed out
			 */
			(void) restline();
			rmlock(CNULL);
			exit(0);
		}
		for (;;) {
			ret = imsg(msg, Ifn);
			if (ret != 0) {
				(void) alarm(0);
				(void) restline();
				rmlock(CNULL);
				exit(0);
			}
			if (msg[0] == 'S')
				break;
		}
		Nstat.t_ecall = times(&Nstat.t_tga);
		(void) alarm(0);
		q = &msg[1];
		p = pskip(q);
		strncpy(Rmtname, q, MAXBASENAME);
		Rmtname[MAXBASENAME] = '\0';

		seq = 0;
		while (p && *p == '-') {
			q = pskip(p);
			switch(*(++p)) {
			case 'x':
				Debug = atoi(++p);
				if (Debug <= 0)
					Debug = 1;
				(void) sprintf(xflag, "-x%d", Debug);
				break;
			case 'Q':
				seq = atoi(++p);
				if (seq < 0)
					seq = 0;
				break;
#ifdef MAXGRADE
			case 'v':	/* version -- -vname=val or -vname */
				if (strncmp(++p, "grade=", 6) == 0 &&
				    isalnum(p[6]))
					MaxGrade = p[6];
				break;
#endif /* MAXGRADE */
			case 'R':
				Restart++;
				p++;
				break;
			case 'U':
				SizeCheck++;
				RemUlimit = strtol(++p, (char **) NULL,0);
				break;
			default:
				break;
			}
			p = q;
		}
		DEBUG(4, "sys-%s\n", Rmtname);
		if (strpbrk(Rmtname, Shchar) != NULL) {
			DEBUG(4, "Bad remote system name '%s'\n", Rmtname);
			logent(Rmtname, "BAD REMOTE SYSTEM NAME");
			omsg('R', "Bad remote system name", Ofn);
			cleanup(101);
		}
		if (Restart)
		    CDEBUG(1,"Checkpoint Restart enabled\n%s", "");

#ifdef NOSTRANGERS
		checkrmt();	/* Do we know the remote system. */
#else
		(void) versys(Rmtname);	/* in case the real name is longer */
#endif /* NOSTRANGERS */

		(void) sprintf(lockname, "%ld", (long) getpid());
		if (umlock(LOCKPRE, lockname)) {
			omsg('R', "LCK", Ofn);
			cleanup(101);
		}

		/* validate login using PERMISSIONS file */
		if (logFind(Loginuser, Rmtname) == FAIL) {
			scWrite(); /* log security violation */
			Uerror = SS_BAD_LOG_MCH;
			logent(UERRORTEXT, "FAILED");
			systat(Rmtname, SS_BAD_LOG_MCH, UERRORTEXT,
			    Retrytime);
			omsg('R', "LOGIN", Ofn);
			cleanup(101);
		}

		ret = callBack();
		DEBUG(4,"return from callcheck: %s",ret ? "TRUE" : "FALSE");
		if (ret==TRUE) {
			(void) signal(SIGINT, SIG_IGN);
			(void) signal(SIGHUP, SIG_IGN);
			omsg('R', "CB", Ofn);
			logent("CALLBACK", "REQUIRED");
			/*
			 * set up for call back
			 */
			chremdir(Rmtname);
			(void) sprintf(file, "%s/%c", Rmtname, D_QUEUE);
			chremdir(file);
			gename(CMDPRE, Rmtname, 'C', file);
			(void) close(creat(file, CFILEMODE));
			if (callok(Rmtname) == SS_CALLBACK_LOOP) {
			    systat(Rmtname, SS_CALLBACK_LOOP, "CALL BACK - LOOP", Retrytime);
			} else {
			    systat(Rmtname, SS_CALLBACK, "CALL BACK", Retrytime);
			    xuucico(Rmtname);
			}
			cleanup(101);
		}

		if (callok(Rmtname) == SS_SEQBAD) {
			Uerror = SS_SEQBAD;
			logent(UERRORTEXT, "PREVIOUS");
			omsg('R', "BADSEQ", Ofn);
			cleanup(101);
		}

		if (gnxseq(Rmtname) == seq) {
			if (Restart) {
			    if (SizeCheck)
				(void) sprintf (msg, "OK -R -U0x%lx %s",
					Ulimit, xflag);
			    else
				(void) sprintf (msg, "OK -R %s", xflag);
			    omsg('R', msg, Ofn);
			} else
			    omsg('R', "OK", Ofn);
			(void) cmtseq();
		} else {
			Uerror = SS_SEQBAD;
			systat(Rmtname, SS_SEQBAD, UERRORTEXT, Retrytime);
			logent(UERRORTEXT, "HANDSHAKE FAILED");
			ulkseq();
			omsg('R', "BADSEQ", Ofn);
			cleanup(101);
		}
		ttyn = ttyname(Ifn);
		if (ttyn != CNULL && *ttyn != NULLCHAR) {
			struct stat ttysbuf;
			if ( fstat(Ifn,&ttysbuf) == 0 )
				Dev_mode = ttysbuf.st_mode;
			else
				Dev_mode = R_DEVICEMODE;
			if ( EQUALSN(ttyn,"/dev/",5) )
			    strcpy(Dc, ttyn+5);
			else
			    strcpy(Dc, ttyn);
			chmod(ttyn, S_DEVICEMODE);
		} else
			strcpy(Dc, "notty");
		/* set args for possible xuuxqt call */
		strcpy(uuxqtarg, Rmtname);
	}

	strcpy(User, Uucp);
/*
 *  Ensure reasonable ulimit (MINULIMIT)
 */

#ifndef	V7
	{
	long 	minulimit;
	minulimit = ulimit(1, (long) 0);
	ASSERT(minulimit >= MINULIMIT, "ULIMIT TOO SMALL",
	    Loginuser, (int) minulimit);
	}
#endif
	if (Role == MASTER && callok(Rmtname) != 0) {
		logent("SYSTEM STATUS", "CAN NOT CALL");
		cleanup(101);
	}

	chremdir(Rmtname);

	(void) strcpy(Wrkdir, RemSpool);
	if (Role == MASTER) {

		/*
		 * master part
		 */
		(void) signal(SIGINT, SIG_IGN);
		(void) signal(SIGHUP, SIG_IGN);
		(void) signal(SIGQUIT, SIG_IGN);
		if (Ifn != -1 && Role == MASTER) {
			(void) (*Write)(Ofn, EOTMSG, strlen(EOTMSG));
			(void) close(Ofn);
			(void) close(Ifn);
			Ifn = Ofn = -1;
			rmlock(CNULL);
			sleep(3);
		}

		/*
		 * Find the highest priority job grade that has
		 * jobs to do. This is needed to form the lock name.
		 */

		findgrade(RemSpool, JobGrade);
		DEBUG(4, "Job grade to process - %s\n", JobGrade);

		/*
		 * Lock the job grade if there is one to process.
		 */

		if (*JobGrade != NULLCHAR) {
			(void) sprintf(gradedir, "%s/%s", Rmtname, JobGrade);
			chremdir(gradedir);

			(void) sprintf(lockname, "%.*s.%s", SYSNSIZE, Rmtname, JobGrade);
			(void) sprintf(msg, "call to %s - process job grade %s ",
			    Rmtname, JobGrade);
			if (umlock(LOCKPRE, lockname) != 0) {
				logent(msg, "LOCKED");
				CDEBUG(1, "Currently Talking With %s\n",
				    Rmtname);
 				cleanup(100);
			}
		} else {
			(void) sprintf(msg, "call to %s - no work", Rmtname);
		}

		Nstat.t_scall = times(&Nstat.t_tga);
		Ofn = Ifn = conn(Rmtname);
		Nstat.t_ecall = times(&Nstat.t_tga);
		if (Ofn < 0) {
			delock(LOCKPRE, lockname);
			logent(UERRORTEXT, "CONN FAILED");
			systat(Rmtname, Uerror, UERRORTEXT, Retrytime);
			cleanup(101);
		} else {
			logent(msg, "SUCCEEDED");
			ttyn = ttyname(Ifn);
			if (ttyn != CNULL && *ttyn != NULLCHAR) {
				struct stat ttysbuf;
				if ( fstat(Ifn,&ttysbuf) == 0 )
					Dev_mode = ttysbuf.st_mode;
				else
					Dev_mode = R_DEVICEMODE;
				chmod(ttyn, M_DEVICEMODE);
			}
		}

		if (setjmp(Sjbuf)) {
			delock(LOCKPRE, lockname);
			Uerror = SS_LOGIN_FAILED;
			logent(Rmtname, UERRORTEXT);
			systat(Rmtname, SS_LOGIN_FAILED,
			    UERRORTEXT, Retrytime);
			DEBUG(4, "%s - failed\n", UERRORTEXT);
			cleanup(101);
		}
		(void) signal(SIGALRM, timeout);
		/* give slow guys lots of time to thrash */
		(void) alarm(2 * msgtime);
		for (;;) {
			ret = imsg(msg, Ifn);
			if (ret != 0) {
				continue; /* try again */
			}
			if (msg[0] == 'S')
				break;
		}
		(void) alarm(0);
		if(EQUALSN("here=", &msg[1], 5)){
			/* This may be a problem, we check up to MAXBASENAME
			 * characters now. The old comment was:
			 * this is a problem.  We'd like to compare with an
			 * untruncated Rmtname but we fear incompatability.
			 * So we'll look at most 6 chars (at most).
			 */
			(void) pskip(&msg[6]);
			if (!EQUALSN(&msg[6], Rmtname, MAXBASENAME)) {
				delock(LOCKPRE, lockname);
				Uerror = SS_WRONG_MCH;
				logent(&msg[6], UERRORTEXT);
				systat(Rmtname, SS_WRONG_MCH, UERRORTEXT,
				     Retrytime);
				DEBUG(4, "%s - failed\n", UERRORTEXT);
				cleanup(101);
			}
		}
		CDEBUG(1,"Login Successful: System=%s\n",&msg[6]);
		seq = gnxseq(Rmtname);
		(void) sprintf(msg, "%s -Q%d -R -U0x%lx %s",
			Myname, seq, Ulimit, xflag);
#ifdef MAXGRADE
		if (MaxGrade != NULLCHAR) {
			p = strchr(msg, NULLCHAR);
			sprintf(p, " -vgrade=%c", MaxGrade);
		}
#endif /* MAXGRADE */
		omsg('S', msg, Ofn);
		(void) alarm(msgtime);	/* give slow guys some thrash time */
		for (;;) {
			ret = imsg(msg, Ifn);
			DEBUG(4, "msg-%s\n", msg);
			if (ret != 0) {
				(void) alarm(0);
				delock(LOCKPRE, lockname);
				ulkseq();
				cleanup(101);
			}
			if (msg[0] == 'R')
				break;
		}
		(void) alarm(0);

		/*  check for rejects from remote */
		Uerror = 0;
		if (EQUALS(&msg[1], "LCK"))
			Uerror = SS_RLOCKED;
		else if (EQUALS(&msg[1], "LOGIN"))
			Uerror = SS_RLOGIN;
		else if (EQUALS(&msg[1], "CB"))
			Uerror = (callBack() ? SS_CALLBACK_LOOP : SS_CALLBACK);
		else if (EQUALS(&msg[1], "You are unknown to me"))
			Uerror = SS_RUNKNOWN;
		else if (EQUALS(&msg[1], "BADSEQ"))
			Uerror = SS_SEQBAD;
		else if (!EQUALSN(&msg[1], "OK", 2))
			Uerror = SS_UNKNOWN_RESPONSE;
		if (Uerror)  {
			delock(LOCKPRE, lockname);
			systat(Rmtname, Uerror, UERRORTEXT, Retrytime);
			logent(UERRORTEXT, "HANDSHAKE FAILED");
			CDEBUG(1, "HANDSHAKE FAILED: %s\n", UERRORTEXT);
			ulkseq();
			cleanup(101);
		}
		(void) cmtseq();

		/*
		 * See if we have any additional parameters on the OK
		 */

		if (strlen(&msg[3])) {
			p = pskip(&msg[3]);
			while (p && *p == '-') {
				q = pskip(p);
				switch(*(++p)) {
				case 'R':
					Restart++;
					p++;
					break;
				case 'U':
					SizeCheck++;
					RemUlimit = strtol(++p, (char **) NULL, 0);
					break;
				case 'x':
					if (!Debug) {
						Debug = atoi(++p);
						if (Debug <= 0)
							Debug = 1;
					}
					break;
				default:
					break;
				}
				p = q;
			}
		}

	}
	DEBUG(4, " Rmtname %s, ", Rmtname);
	DEBUG(4, " Restart %s, ", (Restart ? "YES" : "NO"));
	DEBUG(4, "Role %s,  ", Role ? "MASTER" : "SLAVE");
	DEBUG(4, "Ifn - %d, ", Ifn);
	DEBUG(4, "Loginuser - %s\n", Loginuser);

	/* alarm/setjmp added here due to experience with uucico
	 * hanging for hours in imsg().
	 */
	if (setjmp(Sjbuf)) {
		delock(LOCKPRE, lockname);
		logent("startup", "TIMEOUT");
		DEBUG(4, "%s - timeout\n", "startup");
		cleanup(101);
	}
	(void) alarm(MAXSTART);
	ret = startup();
	(void) alarm(0);

	if (ret != SUCCESS) {
		delock(LOCKPRE, lockname);
		logent("startup", "FAILED");
		Uerror = SS_STARTUP;
		CDEBUG(1, "%s\n", UERRORTEXT);
		systat(Rmtname, Uerror, UERRORTEXT, Retrytime);
		exitcode = 101;
	} else {
		pfConnected(Rmtname, Dc);
		acConnected(Rmtname, Dc);
		logent("startup", "OK");
		systat(Rmtname, SS_INPROGRESS, UTEXT(SS_INPROGRESS),Retrytime);
		Nstat.t_sftp = times(&Nstat.t_tga);

		exitcode = cntrl();
		Nstat.t_eftp = times(&Nstat.t_tga);
		DEBUG(4, "cntrl - %d\n", exitcode);
		(void) signal(SIGINT, SIG_IGN);
		(void) signal(SIGHUP, SIG_IGN);
		(void) signal(SIGALRM, timeout);

		if (exitcode == 0) {
			(void) time(&ts);
			(void) sprintf(cb, "conversation complete %s %ld",
				Dc, ts - tconv);
			logent(cb, "OK");
			systat(Rmtname, SS_OK, UTEXT(SS_OK), Retrytime);

		} else {
			logent("conversation complete", "FAILED");
			systat(Rmtname, SS_CONVERSATION,
			    UTEXT(SS_CONVERSATION), Retrytime);
		}
		(void) alarm(msgtime);	/* give slow guys some thrash time */
		omsg('O', "OOOOO", Ofn);
		CDEBUG(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;
			}
		}
		(void) alarm(0);
	}
	cleanup(exitcode);
	/*NOTREACHED*/
}

/*
 * clean and exit with "code" status
 */
void
cleanup(code)
register int code;
{
	(void) signal(SIGINT, SIG_IGN);
	(void) signal(SIGHUP, SIG_IGN);
	rmlock(CNULL);
	closedem();
	alarm(msgtime);		/* Start timer in case closes hang. */
	if (setjmp(Sjbuf) == 0)
		(*Teardown)( Role, Ifn, Ofn );
	alarm(0);			/* Turn off timer. */
	DEBUG(4, "exit code %d\n", code);
	CDEBUG(1, "Conversation Complete: Status %s\n\n",
	    code ? "FAILED" : "SUCCEEDED");

	cleanTM();
	if ((code == 0) && (uuxqtflag == 1))
		xuuxqt(uuxqtarg);
	exit(code);
}

short TM_cnt = 0;
char TM_name[MAXNAMESIZE];

void
cleanTM()
{
	register int i;
	char tm_name[MAXNAMESIZE];

	DEBUG(7,"TM_cnt: %d\n",TM_cnt);
	for(i=0; i < TM_cnt; i++) {
		(void) sprintf(tm_name, "%s.%3.3d", TM_name, i);
		DEBUG(7, "tm_name: %s\n", tm_name);
		unlink(tm_name);
	}
	return;
}

void
TMname(file, pnum)
char *file;
pid_t pnum;
{

	(void) sprintf(file, "%s/TM.%.5ld.%.3d", RemSpool, (long) pnum, TM_cnt);
	if (TM_cnt == 0)
	    (void) sprintf(TM_name, "%s/TM.%.5ld", RemSpool, (long) pnum);
	DEBUG(7, "TMname(%s)\n", file);
	TM_cnt++;
	return;
}

/*
 * intrrupt - remove locks and exit
 */
void
onintr(inter)
register int inter;
{
	char str[30];
	/* I'm putting a test for zero here because I saw it happen
	 * and don't know how or why, but it seemed to then loop
	 * here for ever?
	 */
	if (inter == 0)
	    exit(99);
	(void) signal(inter, SIG_IGN);
	(void) sprintf(str, "SIGNAL %d", inter);
	logent(str, "CAUGHT");
	pfEndfile("PARTIAL FILE");
	acEnd(PARTIAL); /*stop collecting accounting log */
	cleanup(inter);
}

void
intrEXIT(inter)
int inter;
{
	char	cb[20];

	(void) sprintf(cb, "SIGNAL %d", inter);
	logent("INTREXIT", cb);
	(void) signal(SIGIOT, SIG_DFL);
	(void) signal(SIGILL, SIG_DFL);
	rmlock(CNULL);
	closedem();
	(void) setuid(Uid);
	abort();
}

/*
 * catch SIGALRM routine
 */
void
timeout()
{
	longjmp(Sjbuf, 1);
}

/* skip to next field */
static char *
pskip(p)
register char *p;
{
	if ((p = strchr(p, ' ')) != CNULL)
		do
			*p++ = NULLCHAR;
		while (*p == ' ');
	return(p);
}

void
closedem()
{
	register i, maxfiles;

#ifdef ATTSVR3
	maxfiles = ulimit(4,0);
#else /* !ATTSVR3 */
#ifdef BSD4_2
	maxfiles = getdtablesize();
#else /* BSD4_2 */
	maxfiles = _NFILE;
#endif /* BSD4_2 */
#endif /* ATTSVR3 */

	for (  i = 3; i < maxfiles; i++ )
		if ( i != Ifn && i != Ofn && i != fileno(stderr) )
			(void) close(i);
	return;
}

#ifndef ATTSVR3

/*
 *	setTZ()
 *
 *	if login "shell" is uucico (i.e., Role == SLAVE), must set
 *	timezone env variable TZ.  otherwise will default to EST.
 */

#define	LINELEN	81

void
setTZ()
{
	static char	buf[LINELEN], *bp;
	extern char	*fgets();
	FILE		*tzfp;
	extern FILE	*fopen();
	register int	i;
	extern int	fclose(), strncmp();

	if ( (tzfp = fopen("/etc/TIMEZONE","r")) == (FILE *)NULL )
		return;
	while ( (bp = fgets(buf,LINELEN,tzfp)) != (char *)NULL ) {
		while ( isspace(*bp) )
			++bp;
		if ( strncmp(bp, "TZ=", 3) == 0 ) {
			for ( i = strlen(bp) - 1; i > 0 && isspace(*(bp+i)); --i )
				*(bp+i) = '\0';
			putenv(bp);
			(void)fclose(tzfp);
			return;
		}
	}
	(void)fclose(tzfp);
	return;
}
#endif /* ATTSVR3 */

#ifdef NOSTRANGERS
/*
* Function:	checkrmt
*
* If NOSTRANGERS is defined, see if the remote system is in our systems
* file.  If it is not, execute NOSTRANGERS and then reject the call.
*/

static void
checkrmt ()

{
	char **	eVarPtr;	/* Pointer to environment variable. */
	char	msgbuf[BUFSIZ];	/* Place to build messages. */
	pid_t	procid;		/* ID of Nostranger process. */
	static char * safePath = PATH;
	int	status;		/* Exit status of child. */
	pid_t	waitrv;		/* Return value from wait system call. */

	/* here's the place to look the remote system up in the Systems file.
	 * If the command NOSTRANGERS is executable and
	 * If they're not in my file then hang up */

	if (versys(Rmtname) && (access(NOSTRANGERS, 1) == 0)) {
		sprintf(msgbuf, "Invoking %s for %%s\n", NOSTRANGERS);
		DEBUG(4, msgbuf, Rmtname);

		/*
		* Ignore hangup in case remote goes away before we can
		* finish logging.
		*/

		(void) signal(SIGHUP, SIG_IGN);
		omsg('R', "You are unknown to me", Ofn);
		scWrite(); /* log unknown remote system */
		procid = fork();
		if ( procid == 0 ) {
			/*
			* Before execing the no strangers program, there is
			* a security aspect to consider.  If NOSTRANGERS is
			* not a full path name, then the PATH environment
			* variable will provide places to look for the file.
			* To be safe, we will set the PATH environment
			* variable before we do the exec.
			*/

			/* Find PATH in current environment and change it. */

			for (eVarPtr = Env; *eVarPtr != CNULL; eVarPtr++) {
				if (PREFIX("PATH=", *eVarPtr))
					*eVarPtr = safePath;
			}
			execlp( NOSTRANGERS, "stranger", Rmtname, (char *) 0);
			sprintf(msgbuf, "Execlp of %s failed with errno=%%d\n",
				NOSTRANGERS);
			DEBUG(4, msgbuf, errno);
			perror(gettext("cico.c: execlp NOSTRANGERS failed"));
			cleanup(errno);
		} else if (procid < 0) {
			perror(gettext("cico.c: execlp NOSTRANGERS failed"));
			cleanup(errno);
		} else {
			while ((waitrv = wait(&status)) != procid)
				if (waitrv == -1 && errno != EINTR)
					cleanup(errno);
			sprintf(msgbuf, "%s exit status was %%#x\n",
				NOSTRANGERS);
			DEBUG(4, msgbuf, status);
		}
		cleanup(101);
	}
}
#endif /* NOSTRANGERS */