![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to conn.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.bin / uucp|
Return to conn.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / uucp |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)conn.c 5.10 (Berkeley) 1/24/86"; ! 3: #endif ! 4: ! 5: #include <signal.h> ! 6: #include "uucp.h" ! 7: #include <setjmp.h> ! 8: #include <ctype.h> ! 9: #include <errno.h> ! 10: #ifdef USG ! 11: #include <termio.h> ! 12: #include <fcntl.h> ! 13: #endif ! 14: #ifndef USG ! 15: #include <sgtty.h> ! 16: #endif ! 17: #ifdef BSD4_2 ! 18: #include <sys/time.h> ! 19: #else ! 20: #include <time.h> ! 21: #endif ! 22: ! 23: #define MAXC 1000 ! 24: ! 25: extern jmp_buf Sjbuf; ! 26: jmp_buf Cjbuf; ! 27: extern int errno, onesys; ! 28: extern char *sys_errlist[]; ! 29: extern char MaxGrade, DefMaxGrade; ! 30: ! 31: /* Parity control during login procedure */ ! 32: #define P_ZERO 0 ! 33: #define P_ONE 1 ! 34: #define P_EVEN 2 ! 35: #define P_ODD 3 ! 36: ! 37: #define ABORT -2 ! 38: ! 39: char *AbortOn = NULL; ! 40: char par_tab[128]; /* must be power of two */ ! 41: int linebaudrate; /* used for the sleep test in pk1.c */ ! 42: int next_fd = -1; /* predicted fd to close interrupted opens */ ! 43: ! 44: char *PCP = "PCP"; /* PC Pursuit device type */ ! 45: /* ! 46: * catch alarm routine for "expect". ! 47: */ ! 48: alarmtr() ! 49: { ! 50: signal(SIGALRM, alarmtr); ! 51: if (next_fd >= 0) { ! 52: if (close(next_fd)) ! 53: logent("FAIL", "ACU LINE CLOSE"); ! 54: next_fd = -1; ! 55: } ! 56: longjmp(Sjbuf, 1); ! 57: } ! 58: ! 59: /* This template is for seismo to call ihnp4 ! 60: * the 3 lines marked ---> will be overwritten for the appropriate city ! 61: */ ! 62: #define PCP_BAUD 3 ! 63: #define PCP_PHONE 4 ! 64: #define PCP_CALLBACK 8 ! 65: #define PCP_CITY 10 ! 66: #define PCP_RPHONE 12 ! 67: #define NPCFIELDS 15 ! 68: ! 69: static char *PCFlds[] = { ! 70: "PC-PURSUIT", ! 71: "Any", ! 72: "ACU", ! 73: "1200", ! 74: CNULL, /* <--- **** Welcome to Telenet PC Pursuit ***** */ ! 75: "ABORT", ! 76: "Good", /* Abort of Good bye! */ ! 77: ")", /* <--- Enter your 7-digit phone number (xxx-xxxx) */ ! 78: CNULL, /* ---> 528-1234 */ ! 79: "call?", /* <--- Which city do you wish to call? */ ! 80: CNULL, /* ---> CHICAGO */ ! 81: ")", /* <--- Enter the phone number you wish to call (xxx-xxxx) */ ! 82: CNULL, /* ---> 690-7171 */ ! 83: "R)?", /* <--- You are #1 in the queue. Do you want to wait, or Restart (Y/N/R)? */ ! 84: "Y", ! 85: CNULL /* <--- .....Good Bye! */ ! 86: }; ! 87: ! 88: static char PCP_brand[20]; ! 89: ! 90: /* ! 91: * place a telephone call to system and login, etc. ! 92: * ! 93: * return codes: ! 94: * CF_SYSTEM: don't know system ! 95: * CF_TIME: wrong time to call ! 96: * CF_DIAL: call failed ! 97: * CF_NODEV: no devices available to place call ! 98: * CF_LOGIN: login/password dialog failed ! 99: * ! 100: * >0 - file no. - connect ok ! 101: */ ! 102: ! 103: int Dcf = -1; ! 104: char *Flds[MAXC/10]; ! 105: char LineType[10]; ! 106: extern int LocalOnly; ! 107: ! 108: conn(system) ! 109: char *system; ! 110: { ! 111: int nf; ! 112: char info[MAXC], wkpre[NAMESIZE], file[NAMESIZE]; ! 113: register FILE *fsys; ! 114: int fcode = 0; ! 115: ! 116: nf = 0; ! 117: ! 118: fsys = fopen(SYSFILE, "r"); ! 119: ASSERT(fsys != NULL, "CAN'T OPEN", SYSFILE, 0); ! 120: ! 121: DEBUG(4, "finds (%s) called\n", system); ! 122: keeplooking: ! 123: while((nf = finds(fsys, system, info, Flds)) > 0) { ! 124: strncpy(LineType, Flds[F_LINE], 10); ! 125: if (LocalOnly) { ! 126: if (strcmp("TCP", LineType) ! 127: && strcmp("DIR", LineType) ! 128: && strcmp("LOCAL", LineType) ) { ! 129: fcode = CF_TIME; ! 130: continue; ! 131: } ! 132: } ! 133: sprintf(wkpre, "%c.%.*s", CMDPRE, SYSNSIZE, Rmtname); ! 134: if (!onesys && MaxGrade != DefMaxGrade && ! 135: !iswrk(file, "chk", Spool, wkpre)) { ! 136: fcode = CF_TIME; ! 137: continue; ! 138: } ! 139: /* For GTE's PC Pursuit */ ! 140: if (snccmp(LineType, PCP) == SAME) { ! 141: FILE *dfp; ! 142: int status; ! 143: static struct Devices dev; ! 144: dfp = fopen(DEVFILE, "r"); ! 145: ASSERT(dfp != NULL, "Can't open", DEVFILE, 0); ! 146: while ((status=rddev(dfp, &dev)) != FAIL ! 147: && strcmp(PCP, dev.D_type) != SAME) ! 148: ; ! 149: fclose(dfp); ! 150: if (status == FAIL) ! 151: continue; ! 152: if (mlock(PCP) == FAIL) { ! 153: fcode = CF_NODEV; ! 154: logent("DEVICE", "NO"); ! 155: continue; ! 156: } ! 157: PCFlds[PCP_BAUD] = dev.D_class; ! 158: PCFlds[PCP_PHONE] = dev.D_calldev; ! 159: PCFlds[PCP_CALLBACK] = dev.D_arg[D_CHAT]; ! 160: PCFlds[PCP_CITY] = Flds[F_CLASS]; ! 161: PCFlds[PCP_RPHONE] = Flds[F_PHONE]; ! 162: strncpy(PCP_brand, dev.D_brand, sizeof(PCP_brand)); ! 163: if ((fcode = getto(PCFlds)) < 0) ! 164: continue; ! 165: Dcf = fcode; ! 166: fcode = login(NPCFIELDS, PCFlds, Dcf); ! 167: clsacu(); /* Hang up, they'll call back */ ! 168: if (fcode != SUCCESS) { ! 169: fcode = CF_DIAL; ! 170: continue; ! 171: } ! 172: Flds[F_CLASS] = dev.D_class; ! 173: Flds[F_PHONE] = dev.D_line; ! 174: ! 175: } /* end PC Pursuit */ ! 176: if ((fcode = getto(Flds)) > 0) ! 177: break; ! 178: } ! 179: ! 180: if (nf <= 0) { ! 181: fclose(fsys); ! 182: return fcode ? fcode : nf; ! 183: } ! 184: ! 185: Dcf = fcode; ! 186: ! 187: if (fcode >= 0 && snccmp(LineType, PCP) == SAME) { ! 188: AbortOn = "Good"; /* .... Good Bye */ ! 189: fcode = expect("****~300", Dcf); ! 190: if (fcode != SUCCESS) { ! 191: DEBUG(4, "\nexpect timed out\n", CNULL); ! 192: fcode = CF_DIAL; ! 193: } ! 194: } ! 195: if (fcode >= 0) { ! 196: DEBUG(4, "login %s\n", "called"); ! 197: fcode = login(nf, Flds, Dcf); ! 198: } ! 199: if (fcode < 0) { ! 200: clsacu(); ! 201: if (fcode == ABORT) { ! 202: fcode = CF_DIAL; ! 203: goto keeplooking; ! 204: } else { ! 205: fclose(fsys); ! 206: return CF_LOGIN; ! 207: } ! 208: } ! 209: fclose(fsys); ! 210: fioclex(Dcf); ! 211: return Dcf; ! 212: } ! 213: ! 214: /* ! 215: * connect to remote machine ! 216: * ! 217: * return codes: ! 218: * >0 - file number - ok ! 219: * FAIL - failed ! 220: */ ! 221: ! 222: getto(flds) ! 223: register char *flds[]; ! 224: { ! 225: register struct condev *cd; ! 226: int nulldev(), diropn(); ! 227: char *line; ! 228: ! 229: DEBUG(4, "getto: call no. %s ", flds[F_PHONE]); ! 230: DEBUG(4, "for sys %s\n", flds[F_NAME]); ! 231: ! 232: if (snccmp(flds[F_LINE], "LOCAL") == SAME) ! 233: line = "ACU"; ! 234: else ! 235: line = flds[F_LINE]; ! 236: #ifdef DIALINOUT ! 237: if (snccmp(line, "ACU") != SAME) ! 238: reenable(); ! 239: #endif DIALINOUT ! 240: CU_end = nulldev; ! 241: if (snccmp(line, PCP) == SAME) { ! 242: for(cd = condevs; cd->CU_meth != NULL; cd++) { ! 243: if (snccmp(PCP_brand, cd->CU_brand) == SAME) { ! 244: CU_end = cd->CU_clos; ! 245: return diropn(flds); ! 246: } ! 247: } ! 248: logent(PCP_brand, "UNSUPPORTED ACU TYPE"); ! 249: } else { ! 250: for (cd = condevs; cd->CU_meth != NULL; cd++) { ! 251: if (snccmp(cd->CU_meth, line) == SAME) { ! 252: DEBUG(4, "Using %s to call\n", cd->CU_meth); ! 253: return (*(cd->CU_gen))(flds); ! 254: } ! 255: } ! 256: DEBUG(1, "Can't find %s, assuming DIR\n", flds[F_LINE]); ! 257: } ! 258: return diropn(flds); /* search failed, so use direct */ ! 259: } ! 260: ! 261: /* ! 262: * close call unit ! 263: * ! 264: * return codes: none ! 265: */ ! 266: ! 267: int (*CU_end)() = nulldev; ! 268: clsacu() ! 269: { ! 270: /* make *sure* Dcf is no longer exclusive. ! 271: * Otherwise dual call-in/call-out modems could get stuck. ! 272: * Unfortunately, doing this here is not ideal, but it is the ! 273: * easiest place to put the call. ! 274: * Hopefully everyone honors the LCK protocol, of course ! 275: */ ! 276: #ifdef TIOCNXCL ! 277: if (!IsTcpIp && Dcf >= 0 && ioctl(Dcf, TIOCNXCL, STBNULL) < 0) ! 278: DEBUG(5, "clsacu ioctl %s\n", sys_errlist[errno]); ! 279: #endif ! 280: if (setjmp(Sjbuf)) ! 281: logent(Rmtname, "CLOSE TIMEOUT"); ! 282: else { ! 283: signal(SIGALRM, alarmtr); ! 284: alarm(20); ! 285: (*(CU_end))(Dcf); ! 286: alarm(0); ! 287: } ! 288: if (close(Dcf) == 0) { ! 289: DEBUG(4, "fd %d NOT CLOSED by CU_clos\n", Dcf); ! 290: logent("clsacu", "NOT CLOSED by CU_clos"); ! 291: } ! 292: Dcf = -1; ! 293: CU_end = nulldev; ! 294: } ! 295: ! 296: /* ! 297: * expand phone number for given prefix and number ! 298: */ ! 299: ! 300: exphone(in, out) ! 301: register char *in, *out; ! 302: { ! 303: FILE *fn; ! 304: char pre[MAXPH], npart[MAXPH], tpre[MAXPH], p[MAXPH]; ! 305: char buf[BUFSIZ]; ! 306: register char *s1; ! 307: ! 308: if (!isascii(*in) || !isalpha(*in)) { ! 309: strcpy(out, in); ! 310: return; ! 311: } ! 312: ! 313: s1=pre; ! 314: while (isascii(*in) && isalpha(*in)) ! 315: *s1++ = *in++; ! 316: *s1 = '\0'; ! 317: s1 = npart; ! 318: while (*in != '\0') ! 319: *s1++ = *in++; ! 320: *s1 = '\0'; ! 321: ! 322: tpre[0] = '\0'; ! 323: if ((fn = fopen(DIALFILE, "r")) == NULL) ! 324: DEBUG(2, "CAN'T OPEN %s\n", DIALFILE); ! 325: else { ! 326: while (cfgets(buf, BUFSIZ, fn)) { ! 327: if (sscanf(buf, "%s%s", p, tpre) != 2) ! 328: continue; ! 329: if (strcmp(p, pre) == SAME) ! 330: goto found; ! 331: tpre[0] = '\0'; ! 332: } ! 333: DEBUG(2, "CAN'T FIND dialcodes prefix '%s'\n", pre); ! 334: found:; ! 335: fclose(fn); ! 336: } ! 337: ! 338: strcpy(out, tpre); ! 339: strcat(out, npart); ! 340: } ! 341: ! 342: /* ! 343: * read and decode a line from device file ! 344: * ! 345: * return code - FAIL at end-of file; 0 otherwise ! 346: */ ! 347: ! 348: rddev(fp, dev) ! 349: register struct Devices *dev; ! 350: FILE *fp; ! 351: { ! 352: register int na; ! 353: ! 354: if (!cfgets(dev->D_argbfr, sizeof(dev->D_argbfr), fp)) ! 355: return FAIL; ! 356: na = getargs(dev->D_argbfr, dev->D_arg, 20); ! 357: ASSERT(na >= 4, "BAD DEVICE ENTRY", dev->D_argbfr, 0); ! 358: if (na == 4) { ! 359: dev->D_brand = ""; ! 360: na++; ! 361: } ! 362: dev->D_speed = atoi(fdig(dev->D_class)); ! 363: dev->D_numargs = na; ! 364: return 0; ! 365: } ! 366: ! 367: /* ! 368: * set system attribute vector ! 369: * ! 370: * return codes: ! 371: * >0 - number of arguments in vector - succeeded ! 372: * CF_SYSTEM - system name not found ! 373: * CF_TIME - wrong time to call ! 374: */ ! 375: ! 376: finds(fsys, sysnam, info, flds) ! 377: char *sysnam, info[], *flds[]; ! 378: FILE *fsys; ! 379: { ! 380: int na; ! 381: int fcode = 0; ! 382: ! 383: /* format of fields ! 384: * 0 name; ! 385: * 1 time ! 386: * 2 acu/hardwired ! 387: * 3 speed ! 388: * etc ! 389: */ ! 390: while (cfgets(info, MAXC, fsys) != NULL) { ! 391: na = getargs(info, flds, MAXC/10); ! 392: if (strncmp(sysnam, flds[F_NAME], MAXBASENAME) != SAME) ! 393: continue; ! 394: if (ifdate(flds[F_TIME]) != FAIL) ! 395: /* found a good entry */ ! 396: return na; ! 397: DEBUG(2, "Wrong time ('%s') to call\n", flds[F_TIME]); ! 398: fcode = CF_TIME; ! 399: } ! 400: return fcode ? fcode : CF_SYSTEM; ! 401: } ! 402: ! 403: /* ! 404: * do login conversation ! 405: * ! 406: * return codes: SUCCESS | FAIL ! 407: */ ! 408: ! 409: login(nf, flds, fn) ! 410: register char *flds[]; ! 411: int nf, fn; ! 412: { ! 413: register char *want, *altern; ! 414: int k, ok; ! 415: ! 416: ASSERT(nf > 4, "TOO FEW LOG FIELDS", CNULL, nf); ! 417: if (setjmp(Cjbuf)) ! 418: return FAIL; ! 419: AbortOn = NULL; ! 420: for (k = F_LOGIN; k < nf; k += 2) { ! 421: want = flds[k]; ! 422: ok = FAIL; ! 423: while (ok != SUCCESS) { ! 424: altern = index(want, '-'); ! 425: if (altern != NULL) ! 426: *altern++ = '\0'; ! 427: if (strcmp(want, "ABORT") == 0) { ! 428: AbortOn = flds[k+1]; ! 429: DEBUG(4, "ABORT ON: %s\n", AbortOn); ! 430: goto nextfield; ! 431: } ! 432: DEBUG(4, "wanted \"%s\"\n", want); ! 433: ok = expect(want, fn); ! 434: DEBUG(4, "got: %s\n", ok ? "?" : "that"); ! 435: if (ok == FAIL) { ! 436: if (altern == NULL) { ! 437: logent("LOGIN", _FAILED); ! 438: return FAIL; ! 439: } ! 440: want = index(altern, '-'); ! 441: if (want != NULL) ! 442: *want++ = '\0'; ! 443: sendthem(altern, fn); ! 444: } else ! 445: if (ok == ABORT) { ! 446: logent("LOGIN ABORTED", _FAILED); ! 447: return ABORT; ! 448: } ! 449: } ! 450: sleep(1); ! 451: if (k+1 < nf) ! 452: sendthem(flds[k+1], fn); ! 453: nextfield: ; ! 454: } ! 455: return SUCCESS; ! 456: } ! 457: ! 458: ! 459: /* conditional table generation to support odd speeds */ ! 460: struct sg_spds {int sp_val, sp_name;} spds[] = { ! 461: #ifdef B50 ! 462: { 50, B50}, ! 463: #endif ! 464: #ifdef B75 ! 465: { 75, B75}, ! 466: #endif ! 467: #ifdef B110 ! 468: { 110, B110}, ! 469: #endif ! 470: #ifdef B150 ! 471: { 150, B150}, ! 472: #endif ! 473: #ifdef B200 ! 474: { 200, B200}, ! 475: #endif ! 476: #ifdef B300 ! 477: { 300, B300}, ! 478: #endif ! 479: #ifdef B600 ! 480: {600, B600}, ! 481: #endif ! 482: #ifdef B1200 ! 483: {1200, B1200}, ! 484: #endif ! 485: #ifdef B1800 ! 486: {1800, B1800}, ! 487: #endif ! 488: #ifdef B2000 ! 489: {2000, B2000}, ! 490: #endif ! 491: #ifdef B2400 ! 492: {2400, B2400}, ! 493: #endif ! 494: #ifdef B3600 ! 495: {3600, B3600}, ! 496: #endif ! 497: #ifdef B4800 ! 498: {4800, B4800}, ! 499: #endif ! 500: #ifdef B7200 ! 501: {7200, B7200}, ! 502: #endif ! 503: #ifdef B9600 ! 504: {9600, B9600}, ! 505: #endif ! 506: #ifdef B19200 ! 507: {19200, B19200}, ! 508: #endif ! 509: #ifdef EXTA ! 510: {19200, EXTA}, ! 511: #endif ! 512: {0, 0} ! 513: }; ! 514: ! 515: /* ! 516: * set speed/echo/mode... ! 517: * ! 518: * return codes: none ! 519: */ ! 520: ! 521: fixline(tty, spwant) ! 522: int tty, spwant; ! 523: { ! 524: #ifdef USG ! 525: struct termio ttbuf; ! 526: #else !USG ! 527: struct sgttyb ttbuf; ! 528: #endif !USG ! 529: register struct sg_spds *ps; ! 530: int speed = -1; ! 531: ! 532: for (ps = spds; ps->sp_val; ps++) ! 533: if (ps->sp_val == spwant) ! 534: speed = ps->sp_name; ! 535: ASSERT(speed >= 0, "BAD SPEED", CNULL, speed); ! 536: #ifdef USG ! 537: if (ioctl(tty, TCGETA, &ttbuf) < 0) ! 538: return FAIL; ! 539: /* ttbuf.sg_flags = (ANYP|RAW); ! 540: ttbuf.sg_ispeed = ttbuf.sg_ospeed = speed; */ ! 541: ttbuf.c_iflag = (ushort)0; ! 542: ttbuf.c_oflag = (ushort)0; ! 543: ttbuf.c_cflag = (speed|CS8|HUPCL|CREAD); ! 544: ttbuf.c_lflag = (ushort)0; ! 545: ttbuf.c_cc[VMIN] = 6; ! 546: ttbuf.c_cc[VTIME] = 1; ! 547: if (ioctl(tty, TCSETA, &ttbuf) < 0) ! 548: return FAIL; ! 549: #else !USG ! 550: if (ioctl(tty, TIOCGETP, &ttbuf) < 0) ! 551: return FAIL; ! 552: ttbuf.sg_flags = (ANYP|RAW); ! 553: ttbuf.sg_ispeed = ttbuf.sg_ospeed = speed; ! 554: if (ioctl(tty, TIOCSETP, &ttbuf) < 0) ! 555: return FAIL; ! 556: #endif ! 557: #ifndef USG ! 558: if (ioctl(tty, TIOCHPCL, STBNULL) < 0) ! 559: return FAIL; ! 560: if (ioctl(tty, TIOCEXCL, STBNULL) < 0) ! 561: return FAIL; ! 562: #endif ! 563: linebaudrate = spwant; ! 564: return SUCCESS; ! 565: } ! 566: ! 567: #define MR 100 ! 568: ! 569: /* ! 570: * look for expected string ! 571: * ! 572: * return codes: ! 573: * 0 - found ! 574: * FAIL - lost line or too many characters read ! 575: * some character - timed out ! 576: */ ! 577: ! 578: expect(str, fn) ! 579: register char *str; ! 580: int fn; ! 581: { ! 582: char rdvec[MR]; ! 583: register char *rp = rdvec, *strptr; ! 584: int kr, cnt_char; ! 585: char nextch; ! 586: int timo = MAXMSGTIME; ! 587: ! 588: if (*str == '\0' || strcmp(str, "\"\"") == SAME) ! 589: return SUCCESS; ! 590: /* Cleanup str, convert \0xx strings to one char */ ! 591: for (strptr = str; *strptr; strptr++) { ! 592: if (*strptr == '\\') ! 593: switch(*++strptr) { ! 594: case 's': ! 595: DEBUG(5, "BLANK\n", CNULL); ! 596: *strptr = ' '; ! 597: break; ! 598: default: ! 599: strptr--; /* back up to backslash */ ! 600: sscanf(strptr + 1,"%o", &cnt_char); ! 601: DEBUG(6, "BACKSLASHED %02xH\n", cnt_char); ! 602: *strptr = (char) (cnt_char); ! 603: strcpy(&strptr[1], &strptr[4]); ! 604: } ! 605: } ! 606: ! 607: strptr = index(str, '~'); ! 608: if (strptr != NULL) { ! 609: *strptr++ = '\0'; ! 610: timo = atoi(strptr); ! 611: if (timo <= 0) ! 612: timo = MAXMSGTIME; ! 613: } ! 614: ! 615: if (setjmp(Sjbuf)) ! 616: return FAIL; ! 617: signal(SIGALRM, alarmtr); ! 618: alarm(timo); ! 619: *rp = 0; ! 620: while (notin(str, rdvec)) { ! 621: int c; ! 622: if(AbortOn != NULL && !notin(AbortOn, rdvec)) { ! 623: DEBUG(1, "Call aborted on '%s'\n", AbortOn); ! 624: alarm(0); ! 625: return ABORT; ! 626: } ! 627: kr = read(fn, &nextch, 1); ! 628: if (kr <= 0) { ! 629: alarm(0); ! 630: DEBUG(4, "lost line kr - %d\n, ", kr); ! 631: logent("LOGIN", "LOST LINE"); ! 632: return FAIL; ! 633: } ! 634: c = nextch & 0177; ! 635: if (c == '\0') ! 636: continue; ! 637: DEBUG(4, (isprint(c) || isspace(c)) ? "%c" : "\\%03o", c); ! 638: *rp++ = c; ! 639: if (rp >= rdvec + MR) { ! 640: register char *p; ! 641: for (p = rdvec+MR/2; p < rp; p++) ! 642: *(p-MR/2) = *p; ! 643: rp -= MR/2; ! 644: } ! 645: *rp = '\0'; ! 646: } ! 647: alarm(0); ! 648: return SUCCESS; ! 649: } ! 650: ! 651: ! 652: /* ! 653: * Determine next file descriptor that would be allocated. ! 654: * This permits later closing of a file whose open was interrupted. ! 655: * It is a UNIX kernel problem, but it has to be handled. ! 656: * unc!smb (Steve Bellovin) probably first discovered it. ! 657: */ ! 658: getnextfd() ! 659: { ! 660: close(next_fd = open("/", 0)); ! 661: } ! 662: ! 663: /* ! 664: * send line of login sequence ! 665: * ! 666: * return codes: none ! 667: */ ! 668: sendthem(str, fn) ! 669: register char *str; ! 670: int fn; ! 671: { ! 672: register char *strptr; ! 673: int i, n, cr = 1; ! 674: register char c; ! 675: static int p_init = 0; ! 676: ! 677: DEBUG(5, "send \"%s\"\n", str); ! 678: ! 679: if (!p_init) { ! 680: p_init++; ! 681: bld_partab(P_EVEN); ! 682: } ! 683: ! 684: if (prefix("BREAK", str)) { ! 685: sscanf(&str[5], "%1d", &i); ! 686: if (i <= 0 || i > 10) ! 687: i = 3; ! 688: /* send break */ ! 689: genbrk(fn, i); ! 690: return; ! 691: } ! 692: ! 693: if (prefix("PAUSE", str)) { ! 694: sscanf(&str[5], "%1d", &i); ! 695: if (i <= 0 || i > 10) ! 696: i = 3; ! 697: /* pause for a while */ ! 698: sleep((unsigned)i); ! 699: return; ! 700: } ! 701: ! 702: if (strcmp(str, "EOT") == SAME) { ! 703: p_chwrite(fn, '\04'); ! 704: return; ! 705: } ! 706: ! 707: /* Send a '\n' */ ! 708: if (strcmp(str, "LF") == SAME) { ! 709: p_chwrite(fn, '\n'); ! 710: return; ! 711: } ! 712: ! 713: /* Send a '\r' */ ! 714: if (strcmp(str, "CR") == SAME) { ! 715: p_chwrite(fn, '\r'); ! 716: return; ! 717: } ! 718: ! 719: /* Set parity as needed */ ! 720: if (strcmp(str, "P_ZERO") == SAME) { ! 721: bld_partab(P_ZERO); ! 722: return; ! 723: } ! 724: if (strcmp(str, "P_ONE") == SAME) { ! 725: bld_partab(P_ONE); ! 726: return; ! 727: } ! 728: if (strcmp(str, "P_EVEN") == SAME) { ! 729: bld_partab(P_EVEN); ! 730: return; ! 731: } ! 732: if (strcmp(str, "P_ODD") == SAME) { ! 733: bld_partab(P_ODD); ! 734: return; ! 735: } ! 736: ! 737: /* If "", just send '\r' */ ! 738: if (strcmp(str, "\"\"") == SAME) { ! 739: p_chwrite(fn, '\r'); ! 740: return; ! 741: } ! 742: ! 743: strptr = str; ! 744: while ((c = *strptr++) != '\0') { ! 745: if (c == '\\') { ! 746: switch(*strptr++) { ! 747: case '\0': ! 748: DEBUG(5, "TRAILING BACKSLASH IGNORED\n", CNULL); ! 749: --strptr; ! 750: continue; ! 751: case 's': ! 752: DEBUG(5, "BLANK\n", CNULL); ! 753: c = ' '; ! 754: break; ! 755: case 'd': ! 756: DEBUG(5, "DELAY\n", CNULL); ! 757: sleep(1); ! 758: continue; ! 759: case 'n': ! 760: DEBUG(5, "NEW LINE\n", CNULL); ! 761: c = '\n'; ! 762: break; ! 763: case 'r': ! 764: DEBUG(5, "RETURN\n", CNULL); ! 765: c = '\r'; ! 766: break; ! 767: case 'b': ! 768: if (isdigit(*strptr)) { ! 769: i = (*strptr++ - '0'); ! 770: if (i <= 0 || i > 10) ! 771: i = 3; ! 772: } else ! 773: i = 3; ! 774: /* send break */ ! 775: genbrk(fn, i); ! 776: if (*strptr == '\0') ! 777: cr = 0; ! 778: continue; ! 779: case 'c': ! 780: if (*strptr == '\0') { ! 781: DEBUG(5, "NO CR\n", CNULL); ! 782: cr = 0; ! 783: } else ! 784: DEBUG(5, "NO CR - IGNORED NOT EOL\n", CNULL); ! 785: continue; ! 786: #define isoctal(x) ((x >= '0') && (x <= '7')) ! 787: default: ! 788: if (isoctal(strptr[-1])) { ! 789: i = 0; ! 790: n = 0; ! 791: --strptr; ! 792: while (isoctal(*strptr) && ++n <= 3) ! 793: i = i * 8 + (*strptr++ - '0'); ! 794: DEBUG(5, "\\%o\n", i); ! 795: p_chwrite(fn, (char)i); ! 796: continue; ! 797: } ! 798: } ! 799: } ! 800: p_chwrite(fn, c); ! 801: } ! 802: ! 803: if (cr) ! 804: p_chwrite(fn, '\r'); ! 805: return; ! 806: } ! 807: ! 808: p_chwrite(fd, c) ! 809: int fd; ! 810: char c; ! 811: { ! 812: c = par_tab[c&0177]; ! 813: if (write(fd, &c, 1) != 1) { ! 814: logent(sys_errlist[errno], "BAD WRITE"); ! 815: longjmp(Cjbuf, 2); ! 816: } ! 817: } ! 818: ! 819: /* ! 820: * generate parity table for use by p_chwrite. ! 821: */ ! 822: bld_partab(type) ! 823: int type; ! 824: { ! 825: register int i, j, n; ! 826: ! 827: for (i = 0; i < sizeof(par_tab); i++) { ! 828: n = 0; ! 829: for (j = i&(sizeof(par_tab)-1); j; j = (j-1)&j) ! 830: n++; ! 831: par_tab[i] = i; ! 832: if (type == P_ONE ! 833: || (type == P_EVEN && (n&01) != 0) ! 834: || (type == P_ODD && (n&01) == 0)) ! 835: par_tab[i] |= sizeof(par_tab); ! 836: } ! 837: } ! 838: ! 839: /* ! 840: * check for occurrence of substring "sh" ! 841: * ! 842: * return codes: ! 843: * 0 - found the string ! 844: * 1 - not in the string ! 845: */ ! 846: notin(sh, lg) ! 847: register char *sh, *lg; ! 848: { ! 849: while (*lg != '\0') { ! 850: if (wprefix(sh, lg)) ! 851: return 0; ! 852: else ! 853: lg++; ! 854: } ! 855: return 1; ! 856: } ! 857: ! 858: /* ! 859: * Allow multiple date specifications separated by ','. ! 860: */ ! 861: ifdate(p) ! 862: register char *p; ! 863: { ! 864: register char *np; ! 865: register int ret, g; ! 866: int rtime, i; ! 867: ! 868: /* pick up retry time for failures */ ! 869: /* global variable Retrytime is set here */ ! 870: if ((np = index(p, ';')) == NULL) { ! 871: Retrytime = RETRYTIME; ! 872: } else { ! 873: i = sscanf(np+1, "%d", &rtime); ! 874: if (i < 1 || rtime < 0) ! 875: rtime = 5; ! 876: Retrytime = rtime * 60; ! 877: } ! 878: ! 879: ret = FAIL; ! 880: MaxGrade = '\0'; ! 881: do { ! 882: np = strpbrk(p, ",|"); /* prefer , but allow | for compat */ ! 883: if (np) ! 884: *np = '\0'; ! 885: g = ifadate(p); ! 886: DEBUG(11,"ifadate returns %o\n", g); ! 887: if (g != FAIL) { ! 888: ret = SUCCESS; ! 889: if (g > MaxGrade) ! 890: MaxGrade = g; ! 891: } ! 892: if (np) ! 893: *np = ','; ! 894: p = np + 1; ! 895: } while (np); ! 896: if (MaxGrade == '\0') ! 897: MaxGrade = DefMaxGrade; ! 898: return ret; ! 899: } ! 900: ! 901: /* ! 902: * this routine will check a string (string) ! 903: * like "MoTu0800-1730" to see if the present ! 904: * time is within the given limits. ! 905: * SIDE EFFECT - Retrytime is set ! 906: * ! 907: * return codes: ! 908: * 0 - not within limits ! 909: * 1 - within limits ! 910: */ ! 911: ! 912: ifadate(string) ! 913: char *string; ! 914: { ! 915: static char *days[]={ ! 916: "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa", 0 ! 917: }; ! 918: time_t clock; ! 919: register char *s = string; ! 920: int i, tl, th, tn, dayok=0; ! 921: struct tm *localtime(); ! 922: struct tm *tp; ! 923: char *p, MGrade; ! 924: ! 925: if ((p = index(s, '/')) == NULL) ! 926: MGrade = DefMaxGrade; ! 927: else ! 928: MGrade = p[1]; ! 929: ! 930: time(&clock); ! 931: tp = localtime(&clock); ! 932: while (isascii(*s) && isalpha(*s)) { ! 933: for (i = 0; days[i]; i++) { ! 934: if (prefix(days[i], s)) ! 935: if (tp->tm_wday == i) ! 936: dayok = 1; ! 937: } ! 938: ! 939: if (prefix("Wk", s)) ! 940: if (tp->tm_wday >= 1 && tp->tm_wday <= 5) ! 941: dayok = 1; ! 942: if (prefix("Any", s)) ! 943: dayok = 1; ! 944: if (prefix("Evening", s)) { ! 945: /* Sat or Sun */ ! 946: if (tp->tm_wday == 6 || tp->tm_wday == 0 ! 947: || tp->tm_hour >= 17 || tp->tm_hour < 8) ! 948: dayok = 1; ! 949: } ! 950: if (prefix("Night", s)) { ! 951: if (tp->tm_wday == 6 /* Sat */ ! 952: || tp->tm_hour >= 23 || tp->tm_hour < 8 ! 953: /* Sunday before 5pm */ ! 954: || (tp->tm_wday == 0 && tp->tm_hour < 17)) ! 955: dayok = 1; ! 956: } ! 957: if (prefix("NonPeak", s)) { /* For Tymnet and PC Pursuit */ ! 958: /* Sat or Sun */ ! 959: if (tp->tm_wday == 6 || tp->tm_wday == 0 ! 960: || tp->tm_hour >= 18 || tp->tm_hour < 7) ! 961: dayok = 1; ! 962: } ! 963: s++; ! 964: } ! 965: ! 966: if (dayok == 0 && s != string) ! 967: return FAIL; ! 968: i = sscanf(s, "%d-%d", &tl, &th); ! 969: if (i < 2) ! 970: return MGrade; ! 971: tn = tp->tm_hour * 100 + tp->tm_min; ! 972: if (th < tl) { /* crosses midnight */ ! 973: if (tl <= tn || tn < th) ! 974: return MGrade; ! 975: } else { ! 976: if (tl <= tn && tn < th) ! 977: return MGrade; ! 978: } ! 979: return FAIL; ! 980: } ! 981: ! 982: /* ! 983: * find first digit in string ! 984: * ! 985: * return - pointer to first digit in string or end of string ! 986: */ ! 987: char * ! 988: fdig(cp) ! 989: register char *cp; ! 990: { ! 991: register char *c; ! 992: ! 993: for (c = cp; *c; c++) ! 994: if (*c >= '0' && *c <= '9') ! 995: break; ! 996: return c; ! 997: } ! 998: ! 999: /* ! 1000: * Compare strings: s1>s2: >0 s1==s2: 0 s1<s2: <0 ! 1001: * Strings are compared as if they contain all capital letters. ! 1002: */ ! 1003: snccmp(s1, s2) ! 1004: register char *s1, *s2; ! 1005: { ! 1006: char c1, c2; ! 1007: ! 1008: if (islower(*s1)) ! 1009: c1 = toupper(*s1); ! 1010: else ! 1011: c1 = *s1; ! 1012: if (islower(*s2)) ! 1013: c2 = toupper(*s2); ! 1014: else ! 1015: c2 = *s2; ! 1016: ! 1017: while (c1 == c2) { ! 1018: if (*s1++ == '\0') ! 1019: return 0; ! 1020: s2++; ! 1021: if (islower(*s1)) ! 1022: c1 = toupper(*s1); ! 1023: else ! 1024: c1 = *s1; ! 1025: if (islower(*s2)) ! 1026: c2 = toupper(*s2); ! 1027: else ! 1028: c2 = *s2; ! 1029: } ! 1030: return c1 - c2; ! 1031: } ! 1032: ! 1033: /* ! 1034: * Compare strings: s1>s2: >0 s1==s2: 0 s1<s2: <0 ! 1035: * Strings are compared as if they contain all capital letters. ! 1036: */ ! 1037: sncncmp(s1, s2, n) ! 1038: register char *s1, *s2; ! 1039: register int n; ! 1040: { ! 1041: char c1, c2; ! 1042: ! 1043: if (islower(*s1)) ! 1044: c1 = toupper(*s1); ! 1045: else ! 1046: c1 = *s1; ! 1047: if (islower(*s2)) ! 1048: c2 = toupper(*s2); ! 1049: else ! 1050: c2 = *s2; ! 1051: ! 1052: while ( --n >= 0 && c1 == c2) { ! 1053: if (*s1++ == '\0') ! 1054: return 0; ! 1055: s2++; ! 1056: if (islower(*s1)) ! 1057: c1 = toupper(*s1); ! 1058: else ! 1059: c1 = *s1; ! 1060: if (islower(*s2)) ! 1061: c2 = toupper(*s2); ! 1062: else ! 1063: c2 = *s2; ! 1064: } ! 1065: return n<0 ? 0 : (c1 - c2); ! 1066: } ! 1067: /* ! 1068: * do chat script ! 1069: * occurs after local port is opened, ! 1070: * before 'dialing' the other machine. ! 1071: */ ! 1072: dochat(dev, flds, fd) ! 1073: register struct Devices *dev; ! 1074: char *flds[]; ! 1075: int fd; ! 1076: { ! 1077: register int i; ! 1078: register char *p; ! 1079: char bfr[sizeof(dev->D_argbfr)]; ! 1080: ! 1081: if (dev->D_numargs <= 5) ! 1082: return(0); ! 1083: DEBUG(4, "dochat called %d\n", dev->D_numargs); ! 1084: for (i = 0; i < dev->D_numargs-5; i++) { ! 1085: sprintf(bfr, dev->D_arg[D_CHAT+i], flds[F_PHONE]); ! 1086: if (strcmp(bfr, dev->D_arg[D_CHAT+i])) { ! 1087: p = malloc((unsigned)strlen(bfr)+1); ! 1088: if (p != NULL) { ! 1089: strcpy(p, bfr); ! 1090: dev->D_arg[D_CHAT+i] = p; ! 1091: } ! 1092: } ! 1093: } ! 1094: /* following is a kludge because login() arglist is a kludge */ ! 1095: i = login(dev->D_numargs, &dev->D_arg[D_CHAT-5], fd); ! 1096: /* ! 1097: * If login() last did a sendthem(), must pause so things can settle. ! 1098: * But don't bother if chat failed. ! 1099: */ ! 1100: if (i == 0 && (dev->D_numargs&01)) ! 1101: sleep(2); ! 1102: return(i); ! 1103: } ! 1104: ! 1105: /* ! 1106: * fix kill/echo/raw on line ! 1107: * ! 1108: * return codes: none ! 1109: */ ! 1110: fixmode(tty) ! 1111: register int tty; ! 1112: { ! 1113: #ifdef USG ! 1114: struct termio ttbuf; ! 1115: #else !USG ! 1116: struct sgttyb ttbuf; ! 1117: #endif !USG ! 1118: register struct sg_spds *ps; ! 1119: int speed; ! 1120: ! 1121: if (IsTcpIp) ! 1122: return; ! 1123: #ifdef USG ! 1124: ioctl(tty, TCGETA, &ttbuf); ! 1125: ttbuf.c_iflag = ttbuf.c_oflag = ttbuf.c_lflag = (ushort)0; ! 1126: speed = ttbuf.c_cflag &= (CBAUD); ! 1127: ttbuf.c_cflag |= (CS8|CREAD); ! 1128: ttbuf.c_cc[VMIN] = 6; ! 1129: ttbuf.c_cc[VTIME] = 1; ! 1130: ioctl(tty, TCSETA, &ttbuf); ! 1131: #else !USG ! 1132: ioctl(tty, TIOCGETP, &ttbuf); ! 1133: ttbuf.sg_flags = (ANYP | RAW); ! 1134: ioctl(tty, TIOCSETP, &ttbuf); ! 1135: speed = ttbuf.sg_ispeed; ! 1136: ioctl(tty, TIOCEXCL, STBNULL); ! 1137: #endif !USG ! 1138: ! 1139: for (ps = spds; ps->sp_val; ps++) ! 1140: if (ps->sp_name == speed) { ! 1141: linebaudrate = ps->sp_val; ! 1142: DEBUG(9,"Incoming baudrate is %d\n", linebaudrate); ! 1143: return; ! 1144: } ! 1145: ASSERT(linebaudrate >= 0, "BAD SPEED", CNULL, speed); ! 1146: } ! 1147:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.