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 */