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