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
57jmp_buf Sjbuf;
58extern unsigned msgtime;
59char	uuxqtarg[MAXBASENAME] = {'\0'};
60int	uuxqtflag = 0;
61
62extern 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"
65extern void closedem();
66void cleanup(), cleanTM();
67
68extern int sysaccess(), guinfo(), eaccess(), countProcs(), interface(),
69	savline(), omsg(), restline(), imsg(), callok(), gnxseq(),
70	cmtseq(), conn(), startup(), cntrl();
71extern void setuucp(), fixline(), gename(), ulkseq(), pfEndfile();
72
73#ifdef	NOSTRANGERS
74static void checkrmt();		/* See if we want to talk to remote. */
75#endif /* NOSTRANGERS */
76
77extern char *Mytype;
78
79static char *pskip();
80
81int
82main(argc, argv, envp)
83int argc;
84char *argv[];
85char **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 */
765void
766cleanup(code)
767int 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
787short TM_cnt = 0;
788char TM_name[MAXNAMESIZE];
789
790void
791cleanTM()
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
805void
806TMname(file, pnum)
807char *file;
808pid_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 */
822void
823onintr(inter)
824int 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
841void
842intrEXIT(inter)
843int 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 */
860void
861timeout()
862{
863	longjmp(Sjbuf, 1);
864}
865
866/* skip to next field */
867static char *
868pskip(p)
869char *p;
870{
871	if ((p = strchr(p, ' ')) != CNULL)
872		do
873			*p++ = NULLCHAR;
874		while (*p == ' ');
875	return(p);
876}
877
878void
879closedem()
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
910void
911setTZ()
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
946static void
947checkrmt ()
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