![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to condevs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / usr.bin / uucp|
Return to condevs.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.bin / uucp |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)condevs.c 5.6 (Berkeley) 8/12/83"; ! 3: #endif ! 4: ! 5: /* ! 6: * Here are various dialers to establish the machine-machine connection. ! 7: * conn.c/condevs.c was glued together by Mike Mitchell. ! 8: * The dialers were supplied by many people, to whom we are grateful. ! 9: * ! 10: * --------------------------------------------------------------------- ! 11: * NOTE: ! 12: * There is a bug that occurs at least on PDP11s due to a limitation of ! 13: * setjmp/longjmp. If the routine that does a setjmp is interrupted ! 14: * and longjmp-ed to, it loses its register variables (on a pdp11). ! 15: * What works is if the routine that does the setjmp ! 16: * calls a routine and it is the *subroutine* that is interrupted. ! 17: * ! 18: * Anyway, in conclusion, condevs.c is plagued with register variables ! 19: * that are used inside ! 20: * if (setjmp(...)) { ! 21: * .... ! 22: * } ! 23: * ! 24: * THE FIX: In dnopn(), for example, delete the 'register' Devices *dev. ! 25: * (That was causing a core dump; deleting register fixed it.) ! 26: * Also for dnopn delete 'register' int dnf... . ! 27: * In pkopn, delete 'register' flds... . ! 28: * There may be others, especially mcm's version of hysopen. ! 29: * You could just delete all references to register, that is safest. ! 30: * This problem might not occur on 4.1bsd, I am not sure. ! 31: * Tom Truscott ! 32: */ ! 33: #include <sys/types.h> ! 34: #include <errno.h> ! 35: #include <setjmp.h> ! 36: #include <signal.h> ! 37: #include <sgtty.h> ! 38: #include "uucp.h" ! 39: ! 40: extern char devSel[]; /* name to pass to delock() in close */ ! 41: extern int errno, next_fd; ! 42: extern jmp_buf Sjbuf; ! 43: extern int alarmtr(); ! 44: int nulldev(), nodev(), Acuopn(), diropn(), dircls(); ! 45: ! 46: #ifdef DATAKIT ! 47: int dkopn(); ! 48: #endif ! 49: #ifdef DN11 ! 50: int dnopn(), dncls(); ! 51: #endif ! 52: #ifdef HAYES ! 53: int hysopn(), hyscls(); ! 54: #endif ! 55: #ifdef HAYESQ ! 56: int hysqopn(), hysqcls(); /* a version of hayes that doesn't use ret codes */ ! 57: #endif ! 58: #ifdef DF02 ! 59: int df2opn(), df2cls(); ! 60: #endif ! 61: #ifdef PNET ! 62: int pnetopn(); ! 63: #endif ! 64: #ifdef VENTEL ! 65: int ventopn(), ventcls(); ! 66: #endif ! 67: #ifdef UNET ! 68: #include <UNET/unetio.h> ! 69: #include <UNET/tcp.h> ! 70: int unetopn(), unetcls(); ! 71: #endif UNET ! 72: #ifdef VADIC ! 73: int vadopn(), vadcls(); ! 74: #endif VADIC ! 75: #ifdef RVMACS ! 76: int rvmacsopn(), rvmacscls(); ! 77: #endif ! 78: #ifdef MICOM ! 79: int micopn(), miccls(); ! 80: #endif MICOM ! 81: ! 82: struct condev condevs[] = { ! 83: { "DIR", "direct", diropn, nulldev, dircls }, ! 84: #ifdef DATAKIT ! 85: { "DK", "datakit", dkopn, nulldev, nulldev }, ! 86: #endif ! 87: #ifdef PNET ! 88: { "PNET", "pnet", pnetopn, nulldev, nulldev }, ! 89: #endif ! 90: #ifdef UNET ! 91: { "UNET", "UNET", unetopn, nulldev, unetcls }, ! 92: #endif UNET ! 93: #ifdef MICOM ! 94: { "MICOM", "micom", micopn, nulldev, miccls }, ! 95: #endif MICOM ! 96: #ifdef DN11 ! 97: { "ACU", "dn11", Acuopn, dnopn, dncls }, ! 98: #endif ! 99: #ifdef HAYES ! 100: { "ACU", "hayes", Acuopn, hysopn, hyscls }, ! 101: #endif HAYES ! 102: #ifdef HAYESQ /* a version of hayes that doesn't use result codes */ ! 103: { "ACU", "hayesq", Acuopn, hysqopn, hysqcls }, ! 104: #endif HATESQ ! 105: #ifdef DF02 ! 106: { "ACU", "DF02", Acuopn, df2opn, df2cls }, ! 107: #endif ! 108: #ifdef VENTEL ! 109: { "ACU", "ventel", Acuopn, ventopn, ventcls }, ! 110: #endif VENTEL ! 111: #ifdef VADIC ! 112: { "ACU", "vadic", Acuopn, vadopn, vadcls }, ! 113: #endif VADIC ! 114: #ifdef RVMACS ! 115: { "ACU", "rvmacs", Acuopn, rvmacsopn, rvmacscls }, ! 116: #endif RVMACS ! 117: ! 118: /* Insert new entries before this line */ ! 119: { NULL, NULL, NULL, NULL, NULL } }; ! 120: ! 121: /*** ! 122: * nulldev a null device (returns CF_DIAL) ! 123: */ ! 124: int nulldev() ! 125: { ! 126: return(CF_DIAL); ! 127: } ! 128: ! 129: /*** ! 130: * nodev a null device (returns CF_NODEV) ! 131: */ ! 132: int nodev() ! 133: { ! 134: return(CF_NODEV); ! 135: } ! 136: ! 137: ! 138: /* ! 139: * The first things in this file are the generic devices. ! 140: * Generic devices look through L-devices and call the CU_open routines for ! 141: * appropriate devices. Some things, like the Unet interface, or direct ! 142: * connect, do not use the CU_open entry. ACUs must search to find the' ! 143: * right routine to call. ! 144: */ ! 145: ! 146: /*** ! 147: * diropn(flds) connect to hardware line ! 148: * char *flds[]; ! 149: * ! 150: * return codes: ! 151: * >0 - file number - ok ! 152: * FAIL - failed ! 153: */ ! 154: ! 155: diropn(flds) ! 156: register char *flds[]; ! 157: { ! 158: register int dcr, status; ! 159: struct Devices dev; ! 160: char dcname[20]; ! 161: FILE *dfp; ! 162: dfp = fopen(DEVFILE, "r"); ! 163: ASSERT(dfp != NULL, "CAN'T OPEN", DEVFILE, 0); ! 164: while ((status = rddev(dfp, &dev)) != FAIL) { ! 165: if (strcmp(flds[F_CLASS], dev.D_class) != SAME) ! 166: continue; ! 167: if (strcmp(flds[F_PHONE], dev.D_line) != SAME) ! 168: continue; ! 169: if (mlock(dev.D_line) != FAIL) ! 170: break; ! 171: } ! 172: fclose(dfp); ! 173: if (status == FAIL) { ! 174: logent("DEVICE", "NO"); ! 175: return(CF_NODEV); ! 176: } ! 177: ! 178: sprintf(dcname, "/dev/%s", dev.D_line); ! 179: if (setjmp(Sjbuf)) { ! 180: delock(dev.D_line); ! 181: return(FAIL); ! 182: } ! 183: signal(SIGALRM, alarmtr); ! 184: alarm(10); ! 185: getnextfd(); ! 186: errno = 0; ! 187: dcr = open(dcname, 2); /* read/write */ ! 188: next_fd = -1; ! 189: if (dcr < 0 && errno == EACCES) ! 190: logent(dcname, "CAN'T OPEN"); ! 191: alarm(0); ! 192: if (dcr < 0) { ! 193: delock(dev.D_line); ! 194: return(FAIL); ! 195: } ! 196: fflush(stdout); ! 197: fixline(dcr, dev.D_speed); ! 198: strcpy(devSel, dev.D_line); /* for latter unlock */ ! 199: CU_end = dircls; ! 200: return(dcr); ! 201: } ! 202: ! 203: dircls(fd) ! 204: register int fd; ! 205: { ! 206: if (fd > 0) { ! 207: close(fd); ! 208: delock(devSel); ! 209: } ! 210: } ! 211: ! 212: #ifdef DATAKIT ! 213: ! 214: #include <dk.h> ! 215: #define DKTRIES 2 ! 216: ! 217: /*** ! 218: * dkopn(flds) make datakit connection ! 219: * ! 220: * return codes: ! 221: * >0 - file number - ok ! 222: * FAIL - failed ! 223: */ ! 224: ! 225: dkopn(flds) ! 226: char *flds[]; ! 227: { ! 228: int dkphone; ! 229: register char *cp; ! 230: register ret, i; ! 231: ! 232: if (setjmp(Sjbuf)) ! 233: return(FAIL); ! 234: ! 235: signal(SIGALRM, alarmtr); ! 236: dkphone = 0; ! 237: cp = flds[F_PHONE]; ! 238: while(*cp) ! 239: dkphone = 10 * dkphone + (*cp++ - '0'); ! 240: DEBUG(4, "dkphone (%d) ", dkphone); ! 241: for (i = 0; i < DKTRIES; i++) { ! 242: getnextfd(); ! 243: ret = dkdial(D_SH, dkphone, 0); ! 244: next_fd = -1; ! 245: DEBUG(4, "dkdial (%d)\n", ret); ! 246: if (ret > -1) ! 247: break; ! 248: } ! 249: return(ret); ! 250: } ! 251: #endif ! 252: ! 253: #ifdef PNET ! 254: /*** ! 255: * pnetopn(flds) ! 256: * ! 257: * call remote machine via Purdue network ! 258: * use dial string as host name, speed as socket number ! 259: * Author: Steve Bellovin ! 260: */ ! 261: ! 262: pnetopn(flds) ! 263: char *flds[]; ! 264: { ! 265: int fd; ! 266: int socket; ! 267: register char *cp; ! 268: ! 269: fd = pnetfile(); ! 270: DEBUG(4, "pnet fd - %d\n", fd); ! 271: if (fd < 0) { ! 272: logent("AVAILABLE DEVICE", "NO"); ! 273: return(CF_NODEV); ! 274: } ! 275: socket = 0; ! 276: for (cp = flds[F_CLASS]; *cp; cp++) ! 277: socket = 10*socket + (*cp - '0'); ! 278: DEBUG(4, "socket - %d\n", socket); ! 279: if (setjmp(Sjbuf)) { ! 280: DEBUG(4, "pnet timeout - %s\n", flds[F_PHONE]); ! 281: return(FAIL); ! 282: } ! 283: signal(SIGALRM, alarmtr); ! 284: DEBUG(4, "host - %s\n", flds[F_PHONE]); ! 285: alarm(15); ! 286: if (pnetscon(fd, flds[F_PHONE], socket) < 0) { ! 287: DEBUG(4, "pnet connect failed - %s\n", flds[F_PHONE]); ! 288: return(FAIL); ! 289: } ! 290: alarm(0); ! 291: return(fd); ! 292: } ! 293: #endif PNET ! 294: ! 295: #ifdef UNET ! 296: /*** ! 297: * unetopn -- make UNET (tcp-ip) connection ! 298: * ! 299: * return codes: ! 300: * >0 - file number - ok ! 301: * FAIL - failed ! 302: */ ! 303: ! 304: /* Default port of uucico server */ ! 305: #define DFLTPORT 33 ! 306: ! 307: unetopn(flds) ! 308: register char *flds[]; ! 309: { ! 310: register int ret, port; ! 311: int unetcls(); ! 312: ! 313: port = atoi(flds[F_PHONE]); ! 314: if (port <= 0 || port > 255) ! 315: port = DFLTPORT; ! 316: DEBUG(4, "unetopn host %s, ", flds[F_NAME]); ! 317: DEBUG(4, "port %d\n", port); ! 318: if (setjmp(Sjbuf)) { ! 319: logent("tcpopen", "TIMEOUT"); ! 320: endhnent(); /* see below */ ! 321: return(CF_DIAL); ! 322: } ! 323: signal(SIGALRM, alarmtr); ! 324: alarm(30); ! 325: ret = tcpopen(flds[F_NAME], port, 0, TO_ACTIVE, "rw"); ! 326: alarm(0); ! 327: endhnent(); /* wave magic wand at 3com and incant "eat it, bruce" */ ! 328: if (ret < 0) { ! 329: DEBUG(5, "tcpopen failed: errno %d\n", errno); ! 330: logent("tcpopen", "FAILED"); ! 331: return(CF_DIAL); ! 332: } ! 333: CU_end = unetcls; ! 334: return(ret); ! 335: } ! 336: ! 337: /* ! 338: * unetcls -- close UNET connection. ! 339: */ ! 340: unetcls(fd) ! 341: register int fd; ! 342: { ! 343: DEBUG(4, "UNET CLOSE called\n", 0); ! 344: if (fd > 0) { ! 345: /* disable this until a timeout is put in ! 346: if (ioctl(fd, UIOCCLOSE, STBNULL)) ! 347: logent("UNET CLOSE", "FAILED"); ! 348: */ ! 349: close(fd); ! 350: DEBUG(4, "closed fd %d\n", fd); ! 351: } ! 352: } ! 353: #endif UNET ! 354: ! 355: #ifdef MICOM ! 356: ! 357: /* ! 358: * micopn: establish connection through a micom. ! 359: * Returns descriptor open to tty for reading and writing. ! 360: * Negative values (-1...-7) denote errors in connmsg. ! 361: * Be sure to disconnect tty when done, via HUPCL or stty 0. ! 362: */ ! 363: micopn(flds) ! 364: register char *flds[]; ! 365: { ! 366: extern errno; ! 367: char *rindex(), *fdig(), dcname[20]; ! 368: int dh, ok = 0, speed; ! 369: register struct condev *cd; ! 370: register FILE *dfp; ! 371: struct Devices dev; ! 372: ! 373: dfp = fopen(DEVFILE, "r"); ! 374: ASSERT(dfp != NULL, "Can't open", DEVFILE, 0); ! 375: ! 376: signal(SIGALRM, alarmtr); ! 377: dh = -1; ! 378: for(cd = condevs; ((cd->CU_meth != NULL)&&(dh < 0)); cd++) { ! 379: if (snccmp(flds[F_LINE], cd->CU_meth) == SAME) { ! 380: fseek(dfp, (off_t)0, 0); ! 381: while(rddev(dfp, &dev) != FAIL) { ! 382: if (strcmp(flds[F_CLASS], dev.D_class) != SAME) ! 383: continue; ! 384: if (snccmp(flds[F_LINE], dev.D_type) != SAME) ! 385: continue; ! 386: if (mlock(dev.D_line) == FAIL) ! 387: continue; ! 388: ! 389: sprintf(dcname, "/dev/%s", dev.D_line); ! 390: getnextfd(); ! 391: alarm(10); ! 392: if (setjmp(Sjbuf)) { ! 393: delock(dev.D_line); ! 394: logent(dev.D_line,"micom open TIMEOUT"); ! 395: dh = -1; ! 396: break; ! 397: } ! 398: dh = open(dcname, 2); ! 399: alarm(0); ! 400: next_fd = -1; ! 401: if (dh > 0) { ! 402: break; ! 403: } ! 404: devSel[0] = '\0'; ! 405: delock(dev.D_line); ! 406: } ! 407: } ! 408: } ! 409: fclose(dfp); ! 410: if (dh < 0) ! 411: return(CF_NODEV); ! 412: ! 413: speed = atoi(fdig(flds[F_CLASS])); ! 414: fixline(dh, speed); ! 415: sleep(1); ! 416: ! 417: /* negotiate with micom */ ! 418: if (speed != 4800) /* damn their eyes! */ ! 419: write(dh, "\r", 1); ! 420: else ! 421: write(dh, " ", 1); ! 422: ! 423: DEBUG(4, "wanted %s ", "NAME"); ! 424: ok = expect("NAME", dh); ! 425: DEBUG(4, "got %s\n", ok ? "?" : "that"); ! 426: if (ok == 0) { ! 427: write(dh, flds[F_PHONE], strlen(flds[F_PHONE])); ! 428: sleep(1); ! 429: write(dh, "\r", 1); ! 430: DEBUG(4, "wanted %s ", "GO"); ! 431: ok = expect("GO", dh); ! 432: DEBUG(4, "got %s\n", ok ? "?" : "that"); ! 433: } ! 434: ! 435: if (ok != 0) { ! 436: if (dh > 2) ! 437: close(dh); ! 438: DEBUG(4, "micom failed\n", ""); ! 439: delock(dev.D_line); ! 440: return(CF_DIAL); ! 441: } else ! 442: DEBUG(4, "micom ok\n", ""); ! 443: ! 444: CU_end = cd->CU_clos; ! 445: strcat(devSel, dev.D_line); /* for later unlock */ ! 446: return(dh); ! 447: ! 448: } ! 449: ! 450: miccls(fd) ! 451: register int fd; ! 452: { ! 453: ! 454: if (fd > 0) { ! 455: close(fd); ! 456: delock(devSel); ! 457: } ! 458: } ! 459: #endif MICOM ! 460: ! 461: /*** ! 462: * Acuopn - open an ACU and dial the number. The condevs table ! 463: * will be searched until a dialing unit is found that is ! 464: * free. ! 465: * ! 466: * return codes: >0 - file number - o.k. ! 467: * FAIL - failed ! 468: */ ! 469: ! 470: char devSel[20]; /* used for later unlock() */ ! 471: ! 472: Acuopn(flds) ! 473: register char *flds[]; ! 474: { ! 475: char phone[MAXPH+1]; ! 476: register struct condev *cd; ! 477: register int fd; ! 478: register FILE *dfp; ! 479: struct Devices dev; ! 480: ! 481: exphone(flds[F_PHONE], phone); ! 482: devSel[0] = '\0'; ! 483: DEBUG(4, "Dialing %s\n", phone); ! 484: dfp = fopen(DEVFILE, "r"); ! 485: ASSERT(dfp != NULL, "Can't open", DEVFILE, 0); ! 486: ! 487: for(cd = condevs; cd->CU_meth != NULL; cd++) { ! 488: if (snccmp(flds[F_LINE], cd->CU_meth) == SAME) { ! 489: fseek(dfp, (off_t)0, 0); ! 490: while(rddev(dfp, &dev) != FAIL) { ! 491: if (strcmp(flds[F_CLASS], dev.D_class) != SAME) ! 492: continue; ! 493: if (snccmp(flds[F_LINE], dev.D_type) != SAME) ! 494: continue; ! 495: if (dev.D_brand[0] == '\0') ! 496: logent("Acuopn","No 'brand' name on ACU"); ! 497: else if (snccmp(dev.D_brand, cd->CU_brand) != SAME) ! 498: continue; ! 499: if (mlock(dev.D_line) == FAIL) ! 500: continue; ! 501: ! 502: DEBUG(4, "Using %s\n", cd->CU_brand); ! 503: fd = (*(cd->CU_open))(phone, flds, &dev); ! 504: if (fd > 0) { ! 505: CU_end = cd->CU_clos; /* point CU_end at close func */ ! 506: fclose(dfp); ! 507: strcpy(devSel, dev.D_line); /* save for later unlock() */ ! 508: return(fd); ! 509: } ! 510: delock(dev.D_line); ! 511: } ! 512: } ! 513: } ! 514: fclose(dfp); ! 515: return(FAIL); ! 516: } ! 517: ! 518: #ifdef DN11 ! 519: ! 520: /*** ! 521: * dnopn(ph, flds, dev) dial remote machine ! 522: * char *ph; ! 523: * char *flds[]; ! 524: * struct Devices *dev; ! 525: * ! 526: * return codes: ! 527: * file descriptor - succeeded ! 528: * FAIL - failed ! 529: */ ! 530: ! 531: dnopn(ph, flds, dev) ! 532: char *ph; ! 533: char *flds[]; ! 534: struct Devices *dev; ! 535: { ! 536: char dcname[20], dnname[20], phone[MAXPH+2], c = 0; ! 537: #ifdef SYSIII ! 538: struct termio ttbuf; ! 539: #endif ! 540: int dnf, dcf; ! 541: int nw, lt, pid, status; ! 542: unsigned timelim; ! 543: ! 544: sprintf(dnname, "/dev/%s", dev->D_calldev); ! 545: errno = 0; ! 546: ! 547: if (setjmp(Sjbuf)) { ! 548: logent(dnname, "CAN'T OPEN"); ! 549: DEBUG(4, "%s Open timed out\n", dnname); ! 550: return(CF_NODEV); ! 551: } ! 552: signal(SIGALRM, alarmtr); ! 553: getnextfd(); ! 554: alarm(10); ! 555: dnf = open(dnname, 1); ! 556: alarm(0); ! 557: next_fd = -1; ! 558: if (dnf < 0 && errno == EACCES) { ! 559: logent(dnname, "CAN'T OPEN"); ! 560: logent("DEVICE", "NO"); ! 561: return(CF_NODEV); ! 562: } ! 563: /* rti!trt: avoid passing acu file descriptor to children */ ! 564: fioclex(dnf); ! 565: ! 566: sprintf(dcname, "/dev/%s", dev->D_line); ! 567: sprintf(phone, "%s%s", ph, ACULAST); ! 568: DEBUG(4, "dc - %s, ", dcname); ! 569: DEBUG(4, "acu - %s\n", dnname); ! 570: pid = 0; ! 571: if (setjmp(Sjbuf)) { ! 572: logent("DIALUP DN write", "TIMEOUT"); ! 573: if (pid) ! 574: kill(pid, 9); ! 575: delock(dev->D_line); ! 576: if (dnf) ! 577: close(dnf); ! 578: return(FAIL); ! 579: } ! 580: signal(SIGALRM, alarmtr); ! 581: timelim = 5 * strlen(phone); ! 582: alarm(timelim < 30 ? 30 : timelim); ! 583: if ((pid = fork()) == 0) { ! 584: sleep(2); ! 585: fclose(stdin); ! 586: fclose(stdout); ! 587: #ifdef TIOCFLUSH ! 588: ioctl(dnf, TIOCFLUSH, STBNULL); ! 589: #endif ! 590: nw = write(dnf, phone, lt = strlen(phone)); ! 591: if (nw != lt) { ! 592: logent("DIALUP ACU write", "FAILED"); ! 593: exit(1); ! 594: } ! 595: DEBUG(4, "ACU write ok%s\n", ""); ! 596: exit(0); ! 597: } ! 598: /* open line - will return on carrier */ ! 599: /* RT needs a sleep here because it returns immediately from open */ ! 600: ! 601: #if RT ! 602: sleep(15); ! 603: #endif ! 604: ! 605: getnextfd(); ! 606: errno = 0; ! 607: dcf = open(dcname, 2); ! 608: next_fd = -1; ! 609: if (dcf < 0 && errno == EACCES) ! 610: logent(dcname, "CAN'T OPEN"); ! 611: DEBUG(4, "dcf is %d\n", dcf); ! 612: if (dcf < 0) { ! 613: logent("DIALUP LINE open", "FAILED"); ! 614: alarm(0); ! 615: kill(pid, 9); ! 616: close(dnf); ! 617: delock(dev->D_line); ! 618: return(FAIL); ! 619: } ! 620: /* brl-bmd.351 (Doug Kingston) says the next ioctl is unneeded . */ ! 621: /* ioctl(dcf, TIOCHPCL, STBNULL);*/ ! 622: while ((nw = wait(<)) != pid && nw != -1) ! 623: ; ! 624: #ifdef SYSIII ! 625: ioctl(dcf, TCGETA, &ttbuf); ! 626: if(!(ttbuf.c_cflag & HUPCL)) { ! 627: ttbuf.c_cflag |= HUPCL; ! 628: ioctl(dcf, TCSETA, &ttbuf); ! 629: } ! 630: #endif ! 631: alarm(0); ! 632: fflush(stdout); ! 633: fixline(dcf, dev->D_speed); ! 634: DEBUG(4, "Fork Stat %o\n", lt); ! 635: if (lt != 0) { ! 636: close(dcf); ! 637: if (dnf) ! 638: close(dnf); ! 639: delock(dev->D_line); ! 640: return(FAIL); ! 641: } ! 642: return(dcf); ! 643: } ! 644: ! 645: /*** ! 646: * dncls() close dn type call unit ! 647: * ! 648: * return codes: None ! 649: */ ! 650: dncls(fd) ! 651: register int fd; ! 652: { ! 653: if (fd > 0) { ! 654: close(fd); ! 655: sleep(5); ! 656: delock(devSel); ! 657: } ! 658: } ! 659: #endif DN11 ! 660: ! 661: #ifdef DF02 ! 662: /*** ! 663: * df2opn(ph, flds, dev) dial remote machine ! 664: * char *ph; ! 665: * char *flds[]; ! 666: * struct Devices *dev; ! 667: * ! 668: * return codes: ! 669: * file descriptor - succeeded ! 670: * FAIL - failed ! 671: * ! 672: * Modified 9/28/81 by Bill Shannon (DEC) ! 673: * Changed to use DEC DF02 or DF03 ACU ! 674: */ ! 675: ! 676: ! 677: df2opn(ph, flds, dev) ! 678: char *ph; ! 679: char *flds[]; ! 680: struct Devices *dev; ! 681: { ! 682: char dcname[20], dnname[20], phone[MAXPH+2], c = 0; ! 683: #ifdef SYSIII ! 684: struct termio ttbuf; ! 685: #endif ! 686: int dcf, dnf; ! 687: int nw, lt, pid, st, status; ! 688: unsigned timelim; ! 689: ! 690: sprintf(dnname, "/dev/%s", dev->D_calldev); ! 691: if (setjmp(Sjbuf)) { ! 692: logent(dnname, "CAN'T OPEN"); ! 693: DEBUG(4, "%s Open timed out\n", dnname); ! 694: return(CF_NODEV); ! 695: } ! 696: signal(SIGALRM, alarmtr); ! 697: getnextfd(); ! 698: errno = 0; ! 699: alarm(10); ! 700: dnf = open(dnname, 2 ); ! 701: alarm(0); ! 702: next_fd = -1; ! 703: if (dnf < 0 && errno == EACCES) { ! 704: logent(dnname, "CAN'T OPEN"); ! 705: delock(dev->D_line); ! 706: logent("DEVICE", "NO"); ! 707: return(CF_NODEV); ! 708: } ! 709: /* rti!trt: avoid passing acu file descriptor to children */ ! 710: fioclex(dnf); ! 711: ! 712: sprintf(dcname, "/dev/%s", dev->D_line); ! 713: fixline(dnf, dev->D_speed); ! 714: sprintf(phone, "\02%s", ph); ! 715: DEBUG(4, "dc - %s, ", dcname); ! 716: DEBUG(4, "acu - %s\n", dnname); ! 717: pid = 0; ! 718: if (setjmp(Sjbuf)) { ! 719: logent("DIALUP DN write", "TIMEOUT"); ! 720: if (pid) ! 721: kill(pid, 9); ! 722: delock(dev->D_line); ! 723: if (dnf) ! 724: close(dnf); ! 725: return(FAIL); ! 726: } ! 727: signal(SIGALRM, alarmtr); ! 728: timelim = 5 * strlen(phone); ! 729: alarm(timelim < 30 ? 30 : timelim); ! 730: if ((pid = fork()) == 0) { ! 731: sleep(2); ! 732: fclose(stdin); ! 733: fclose(stdout); ! 734: #ifdef TIOCFLUSH ! 735: ioctl(dnf, TIOCFLUSH, STBNULL); ! 736: #endif ! 737: write(dnf, "\01", 1); ! 738: sleep(1); ! 739: nw = write(dnf, phone, lt = strlen(phone)); ! 740: if (nw != lt) { ! 741: logent("DIALUP ACU write", "FAILED"); ! 742: exit(1); ! 743: } ! 744: DEBUG(4, "ACU write ok%s\n", ""); ! 745: exit(0); ! 746: } ! 747: /* open line - will return on carrier */ ! 748: /* RT needs a sleep here because it returns immediately from open */ ! 749: ! 750: #if RT ! 751: sleep(15); ! 752: #endif ! 753: ! 754: if (read(dnf, &c, 1) != 1 || c != 'A') ! 755: dcf = -1; ! 756: else ! 757: dcf = 0; ! 758: DEBUG(4, "dcf is %d\n", dcf); ! 759: if (dcf < 0) { ! 760: logent("DIALUP LINE open", "FAILED"); ! 761: alarm(0); ! 762: kill(pid, 9); ! 763: close(dnf); ! 764: delock(dev->D_line); ! 765: return(FAIL); ! 766: } ! 767: dcf = dnf; ! 768: dnf = 0; ! 769: /* brl-bmd.351 (Doug Kingston) says the next ioctl is unneeded . */ ! 770: /* ioctl(dcf, TIOCHPCL, STBNULL);*/ ! 771: while ((nw = wait(<)) != pid && nw != -1) ! 772: ; ! 773: #ifdef SYSIII ! 774: ioctl(dcf, TCGETA, &ttbuf); ! 775: if(!(ttbuf.c_cflag & HUPCL)) { ! 776: ttbuf.c_cflag |= HUPCL; ! 777: ioctl(dcf, TCSETA, &ttbuf); ! 778: } ! 779: #endif ! 780: alarm(0); ! 781: fflush(stdout); ! 782: fixline(dcf, dev->D_speed); ! 783: DEBUG(4, "Fork Stat %o\n", lt); ! 784: if (lt != 0) { ! 785: close(dcf); ! 786: if (dnf) ! 787: close(dnf); ! 788: delock(dev->D_line); ! 789: return(FAIL); ! 790: } ! 791: return(dcf); ! 792: } ! 793: ! 794: /* ! 795: * df2cls() close the DF02/DF03 call unit ! 796: * ! 797: * return codes: none ! 798: */ ! 799: ! 800: df2cls(fd) ! 801: register int fd; ! 802: { ! 803: if (fd > 0) { ! 804: close(fd); ! 805: sleep(5); ! 806: delock(devSel); ! 807: } ! 808: } ! 809: #endif DF02 ! 810: ! 811: #ifdef HAYES ! 812: /*** ! 813: * hysopn(telno, flds, dev) connect to hayes smartmodem ! 814: * char *flds[], *dev[]; ! 815: * ! 816: * return codes: ! 817: * >0 - file number - ok ! 818: * CF_DIAL,CF_DEVICE - failed ! 819: */ ! 820: /* ! 821: * Define HAYSTONE if you have touch tone dialing. ! 822: */ ! 823: /*#define HAYSTONE */ ! 824: ! 825: hysopn(telno, flds, dev) ! 826: char *telno; ! 827: char *flds[]; ! 828: struct Devices *dev; ! 829: { ! 830: int dh = -1; ! 831: extern errno; ! 832: char dcname[20]; ! 833: ! 834: sprintf(dcname, "/dev/%s", dev->D_line); ! 835: DEBUG(4, "dc - %s\n", dcname); ! 836: if (setjmp(Sjbuf)) { ! 837: DEBUG(1, "timeout hayes open %s\n", dcname); ! 838: logent("hayes open", "TIMEOUT"); ! 839: if (dh >= 0) ! 840: close(dh); ! 841: delock(dev->D_line); ! 842: return(CF_DIAL); ! 843: } ! 844: signal(SIGALRM, alarmtr); ! 845: getnextfd(); ! 846: alarm(10); ! 847: dh = open(dcname, 2); /* read/write */ ! 848: alarm(0); ! 849: ! 850: /* modem is open */ ! 851: next_fd = -1; ! 852: if (dh >= 0) { ! 853: fixline(dh, dev->D_speed); ! 854: #ifdef HAYSTONE ! 855: write(dh, "\rATDT", 5); ! 856: #else ! 857: write(dh, "\rATDP", 5); ! 858: #endif ! 859: write(dh, telno, strlen(telno)); ! 860: write(dh, "\r", 1); ! 861: ! 862: if (expect("CONNECT", dh) != 0) { ! 863: logent("HSM no carrier", "FAILED"); ! 864: strcpy(devSel, dev->D_line); ! 865: hyscls(dh); ! 866: return(CF_DIAL); ! 867: } ! 868: ! 869: } ! 870: if (dh < 0) { ! 871: DEBUG(4, "hayes failed\n", ""); ! 872: delock(dev->D_line); ! 873: } ! 874: DEBUG(4, "hayes ok\n", ""); ! 875: return(dh); ! 876: } ! 877: ! 878: hyscls(fd) ! 879: int fd; ! 880: { ! 881: char dcname[20]; ! 882: struct sgttyb hup, sav; ! 883: ! 884: if (fd > 0) { ! 885: sprintf(dcname, "/dev/%s", devSel); ! 886: DEBUG(4, "Hanging up fd = %d\n", fd); ! 887: /* ! 888: * code to drop DTR -- change to 0 baud then back to default. ! 889: */ ! 890: gtty(fd, &hup); ! 891: gtty(fd, &sav); ! 892: hup.sg_ispeed = B0; ! 893: hup.sg_ospeed = B0; ! 894: stty(fd, &hup); ! 895: sleep(2); ! 896: stty(fd, &sav); ! 897: /* ! 898: * now raise DTR -- close the device & open it again. ! 899: */ ! 900: sleep(2); ! 901: close(fd); ! 902: sleep(2); ! 903: fd = open(dcname, 2); ! 904: /* ! 905: * Since we have a getty sleeping on this line, when it wakes up it sends ! 906: * all kinds of garbage to the modem. Unfortunatly, the modem likes to ! 907: * execute the previous command when it sees the garbage. The previous ! 908: * command was to dial the phone, so let's make the last command reset ! 909: * the modem. ! 910: */ ! 911: sleep(2); ! 912: write(fd, "\rATZ\r", 5); ! 913: close(fd); ! 914: delock(devSel); ! 915: } ! 916: } ! 917: ! 918: #endif HAYES ! 919: ! 920: #ifdef HAYESQ ! 921: /* ! 922: * New dialout routine to work with Hayes' SMART MODEM ! 923: * 13-JUL-82, Mike Mitchell ! 924: * Modified 23-MAR-83 to work with Tom Truscott's (rti!trt) ! 925: * version of UUCP (ncsu!mcm) ! 926: * ! 927: * The modem should be set to NOT send any result codes to ! 928: * the system (switch 3 up, 4 down). This end will figure out ! 929: * what is wrong. ! 930: * ! 931: * I had lots of problems with the modem sending ! 932: * result codes since I am using the same modem for both incomming and ! 933: * outgoing calls. I'd occasionally miss the result code (getty would ! 934: * grab it), and the connect would fail. Worse yet, the getty would ! 935: * think the result code was a user name, and send garbage to it while ! 936: * it was in the command state. I turned off ALL result codes, and hope ! 937: * for the best. 99% of the time the modem is in the correct state. ! 938: * Occassionally it doesn't connect, or the phone was busy, etc., and ! 939: * uucico sits there trying to log in. It eventually times out, calling ! 940: * clsacu() in the process, so it resets itself for the next attempt. ! 941: */ ! 942: ! 943: /* ! 944: * Define HAYSTONE if touch-tone dialing is to be used. If it is not defined, ! 945: * Pulse dialing is assumed. ! 946: */ ! 947: /*#define HAYSTONE*/ ! 948: ! 949: hysqopn(telno, flds, dev) ! 950: char *telno, *flds[]; ! 951: struct Devices *dev; ! 952: { ! 953: char dcname[20], phone[MAXPH+10], c = 0; ! 954: #ifdef SYSIII ! 955: struct termio ttbuf; ! 956: #endif ! 957: int status, dnf; ! 958: unsigned timelim; ! 959: ! 960: signal(SIGALRM, alarmtr); ! 961: sprintf(dcname, "/dev/%s", dev->D_line); ! 962: ! 963: getnextfd(); ! 964: if (setjmp(Sjbuf)) { ! 965: delock(dev->D_line); ! 966: logent("DEVICE", "NO"); ! 967: DEBUG(4, "Open timed out %s", dcname); ! 968: return(CF_NODEV); ! 969: } ! 970: alarm(10); ! 971: ! 972: if ((dnf = open(dcname, 2)) <= 0) { ! 973: delock(dev->D_line); ! 974: logent("DEVICE", "NO"); ! 975: DEBUG(4, "Can't open %s", dcname); ! 976: return(CF_NODEV); ! 977: } ! 978: ! 979: alarm(0); ! 980: next_fd = -1; ! 981: fixline(dnf, dev->D_speed); ! 982: DEBUG(4, "Hayes port - %s, ", dcname); ! 983: ! 984: #ifdef HAYSTONE ! 985: sprintf(phone, "\rATDT%s\r", telno); ! 986: #else ! 987: sprintf(phone, "\rATDP%s\r", telno); ! 988: #endif ! 989: ! 990: write(dnf, phone, strlen(phone)); ! 991: ! 992: /* calculate delay time for the other system to answer the phone. ! 993: * Default is 15 seconds, add 2 seconds for each comma in the phone ! 994: * number. ! 995: */ ! 996: timelim = 150; ! 997: while(*telno) { ! 998: c = *telno++; ! 999: if (c == ',') ! 1000: timelim += 20; ! 1001: else { ! 1002: #ifdef HAYSTONE ! 1003: timelim += 2; /* .2 seconds per tone */ ! 1004: } ! 1005: #else ! 1006: if (c == '0') timelim += 10; /* .1 second per digit */ ! 1007: else if (c > '0' && c <= '9') ! 1008: timelim += (c - '0'); ! 1009: } ! 1010: #endif ! 1011: } ! 1012: alarm(timelim/10); ! 1013: if (setjmp(Sjbuf) == 0) { ! 1014: read(dnf, &c, 1); ! 1015: alarm(0); ! 1016: } ! 1017: ! 1018: return(dnf); ! 1019: } ! 1020: ! 1021: hysqcls(fd) ! 1022: int fd; ! 1023: { ! 1024: char dcname[20]; ! 1025: struct sgttyb hup, sav; ! 1026: ! 1027: if (fd > 0) { ! 1028: sprintf(dcname, "/dev/%s", devSel); ! 1029: DEBUG(4, "Hanging up fd = %d\n", fd); ! 1030: /* ! 1031: * code to drop DTR -- change to 0 baud then back to default. ! 1032: */ ! 1033: gtty(fd, &hup); ! 1034: gtty(fd, &sav); ! 1035: hup.sg_ispeed = B0; ! 1036: hup.sg_ospeed = B0; ! 1037: stty(fd, &hup); ! 1038: sleep(2); ! 1039: stty(fd, &sav); ! 1040: /* ! 1041: * now raise DTR -- close the device & open it again. ! 1042: */ ! 1043: sleep(2); ! 1044: close(fd); ! 1045: sleep(2); ! 1046: fd = open(dcname, 2); ! 1047: /* ! 1048: * Since we have a getty sleeping on this line, when it wakes up it sends ! 1049: * all kinds of garbage to the modem. Unfortunatly, the modem likes to ! 1050: * execute the previous command when it sees the garbage. The previous ! 1051: * command was to dial the phone, so let's make the last command reset ! 1052: * the modem. ! 1053: */ ! 1054: sleep(2); ! 1055: write(fd, "\rATZ\r", 5); ! 1056: close(fd); ! 1057: delock(devSel); ! 1058: } ! 1059: } ! 1060: ! 1061: #endif HAYESQ ! 1062: ! 1063: #ifdef VENTEL ! 1064: ventopn(telno, flds, dev) ! 1065: char *flds[], *telno; ! 1066: struct Devices *dev; ! 1067: { ! 1068: int dh; ! 1069: int i, ok = -1; ! 1070: char dcname[20]; ! 1071: ! 1072: sprintf(dcname, "/dev/%s", dev->D_line); ! 1073: if (setjmp(Sjbuf)) { ! 1074: DEBUG(1, "timeout ventel open\n", ""); ! 1075: logent("ventel open", "TIMEOUT"); ! 1076: if (dh >= 0) ! 1077: close(dh); ! 1078: delock(dev->D_line); ! 1079: return(CF_NODEV); ! 1080: } ! 1081: signal(SIGALRM, alarmtr); ! 1082: getnextfd(); ! 1083: alarm(10); ! 1084: dh = open(dcname, 2); ! 1085: next_fd = -1; ! 1086: if (dh < 0) { ! 1087: DEBUG(4,"%s\n", errno == 4 ? "no carrier" : "can't open modem"); ! 1088: delock(dev->D_line); ! 1089: return(errno == 4 ? CF_DIAL : CF_NODEV); ! 1090: } ! 1091: ! 1092: /* modem is open */ ! 1093: fixline(dh, dev->D_speed); ! 1094: ! 1095: /* translate - to % and = to & for VenTel */ ! 1096: DEBUG(4, "calling %s -> ", telno); ! 1097: for (i = 0; i < strlen(telno); ++i) { ! 1098: switch(telno[i]) { ! 1099: case '-': /* delay */ ! 1100: telno[i] = '%'; ! 1101: break; ! 1102: case '=': /* await dial tone */ ! 1103: telno[i] = '&'; ! 1104: break; ! 1105: case '<': ! 1106: telno[i] = '%'; ! 1107: break; ! 1108: } ! 1109: } ! 1110: DEBUG(4, "%s\n", telno); ! 1111: sleep(1); ! 1112: for(i = 0; i < 5; ++i) { /* make up to 5 tries */ ! 1113: slowrite(dh, "\r\r");/* awake, thou lowly VenTel! */ ! 1114: ! 1115: DEBUG(4, "wanted %s ", "$"); ! 1116: ok = expect("$", dh); ! 1117: DEBUG(4, "got %s\n", ok ? "?" : "that"); ! 1118: if (ok != 0) ! 1119: continue; ! 1120: slowrite(dh, "K"); /* "K" (enter number) command */ ! 1121: DEBUG(4, "wanted %s ", "DIAL: "); ! 1122: ok = expect("DIAL: ", dh); ! 1123: DEBUG(4, "got %s\n", ok ? "?" : "that"); ! 1124: if (ok == 0) ! 1125: break; ! 1126: } ! 1127: ! 1128: if (ok == 0) { ! 1129: slowrite(dh, telno); /* send telno, send \r */ ! 1130: slowrite(dh, "\r"); ! 1131: DEBUG(4, "wanted %s ", "ONLINE"); ! 1132: ok = expect("ONLINE!", dh); ! 1133: DEBUG(4, "got %s\n", ok ? "?" : "that"); ! 1134: } ! 1135: if (ok != 0) { ! 1136: if (dh > 2) ! 1137: close(dh); ! 1138: DEBUG(4, "venDial failed\n", ""); ! 1139: return(CF_DIAL); ! 1140: } else ! 1141: DEBUG(4, "venDial ok\n", ""); ! 1142: return(dh); ! 1143: } ! 1144: ! 1145: ! 1146: /* ! 1147: * uucpdelay: delay execution for numerator/denominator seconds. ! 1148: */ ! 1149: ! 1150: #ifdef INTERVALTIMER ! 1151: #define uucpdelay(num,denom) intervaldelay(1000000*num/denom) ! 1152: #include <sys/time.h> ! 1153: catch alarm sig ! 1154: SIGALRM ! 1155: struct itimerval itimerval; ! 1156: itimerval.itimer_reload = ! 1157: itimerval.rtime.itimer_interval = ! 1158: itimerval.rtime.itimer_value = ! 1159: settimer(ITIMER_REAL, &itimerval); ! 1160: pause(); ! 1161: alarm comes in ! 1162: turn off timer. ! 1163: #endif INTERVALTIMER ! 1164: ! 1165: #ifdef FASTTIMER ! 1166: #define uucpdelay(num,denom) nap(60*num/denom) ! 1167: /* Sleep in increments of 60ths of second. */ ! 1168: nap (time) ! 1169: register int time; ! 1170: { ! 1171: static int fd; ! 1172: ! 1173: if (fd == 0) ! 1174: fd = open (FASTTIMER, 0); ! 1175: ! 1176: read (fd, 0, time); ! 1177: } ! 1178: #endif FASTTIMER ! 1179: ! 1180: #ifdef FTIME ! 1181: #define uucpdelay(num,denom) ftimedelay(1000*num/denom) ! 1182: #include <sys/timeb.h> ! 1183: ftimedelay(n) ! 1184: { ! 1185: static struct timeb loctime; ! 1186: ftime(&loctime); ! 1187: {register i = loctime.millitm; ! 1188: while (abs((int)(loctime.millitm - i))<n) ftime(&loctime); ! 1189: } ! 1190: } ! 1191: #endif FTIME ! 1192: ! 1193: #ifdef BUSYLOOP ! 1194: #define uucpdelay(num,denom) busyloop(CPUSPEED*num/denom) ! 1195: #define CPUSPEED 1000000 /* VAX 780 is 1MIPS */ ! 1196: #define DELAY(n) { register long N = (n); while (--N > 0); } ! 1197: busyloop(n) ! 1198: { ! 1199: DELAY(n); ! 1200: } ! 1201: #endif BUSYLOOP ! 1202: ! 1203: slowrite(fd, str) ! 1204: register char *str; ! 1205: { ! 1206: DEBUG(6, "slowrite ", ""); ! 1207: while (*str) { ! 1208: DEBUG(6, "%c", *str); ! 1209: uucpdelay(1,10); /* delay 1/10 second */ ! 1210: write(fd, str, 1); ! 1211: str++; ! 1212: } ! 1213: DEBUG(6, "\n", ""); ! 1214: } ! 1215: ! 1216: ! 1217: ventcls(fd) ! 1218: int fd; ! 1219: { ! 1220: ! 1221: if (fd > 0) { ! 1222: close(fd); ! 1223: sleep(5); ! 1224: delock(devSel); ! 1225: } ! 1226: } ! 1227: #endif VENTEL ! 1228: ! 1229: #ifdef VADIC ! 1230: ! 1231: /* ! 1232: * vadopn: establish dial-out connection through a Racal-Vadic 3450. ! 1233: * Returns descriptor open to tty for reading and writing. ! 1234: * Negative values (-1...-7) denote errors in connmsg. ! 1235: * Be sure to disconnect tty when done, via HUPCL or stty 0. ! 1236: */ ! 1237: ! 1238: vadopn(telno, flds, dev) ! 1239: char *telno; ! 1240: char *flds[]; ! 1241: struct Devices *dev; ! 1242: { ! 1243: int dh = -1; ! 1244: int i, ok, er = 0, delay; ! 1245: extern errno; ! 1246: char dcname[20]; ! 1247: ! 1248: sprintf(dcname, "/dev/%s", dev->D_line); ! 1249: if (setjmp(Sjbuf)) { ! 1250: DEBUG(1, "timeout vadic open\n", ""); ! 1251: logent("vadic open", "TIMEOUT"); ! 1252: if (dh >= 0) ! 1253: close(dh); ! 1254: delock(dev->D_line); ! 1255: return(CF_NODEV); ! 1256: } ! 1257: signal(SIGALRM, alarmtr); ! 1258: getnextfd(); ! 1259: alarm(10); ! 1260: dh = open(dcname, 2); ! 1261: alarm(0); ! 1262: ! 1263: /* modem is open */ ! 1264: next_fd = -1; ! 1265: if (dh < 0) { ! 1266: delock(dev->D_line); ! 1267: return(CF_NODEV); ! 1268: } ! 1269: fixline(dh, dev->D_speed); ! 1270: ! 1271: /* translate - to K for Vadic */ ! 1272: DEBUG(4, "calling %s -> ", telno); ! 1273: delay = 0; ! 1274: for (i = 0; i < strlen(telno); ++i) { ! 1275: switch(telno[i]) { ! 1276: case '=': /* await dial tone */ ! 1277: case '-': /* delay */ ! 1278: case '<': ! 1279: telno[i] = 'K'; ! 1280: delay += 5; ! 1281: break; ! 1282: } ! 1283: } ! 1284: DEBUG(4, "%s\n", telno); ! 1285: for(i = 0; i < 5; ++i) { /* make 5 tries */ ! 1286: /* wake up Vadic */ ! 1287: sendthem("\005\\d", dh); ! 1288: DEBUG(4, "wanted %s ", "*"); ! 1289: ok = expect("*", dh); ! 1290: DEBUG(4, "got %s\n", ok ? "?" : "that"); ! 1291: if (ok != 0) ! 1292: continue; ! 1293: ! 1294: sendthem("D\\d", dh); /* "D" (enter number) command */ ! 1295: DEBUG(4, "wanted %s ", "NUMBER?\\r\\n"); ! 1296: ok = expect("NUMBER?\r\n", dh); ! 1297: DEBUG(4, "got %s\n", ok ? "?" : "that"); ! 1298: if (ok != 0) ! 1299: continue; ! 1300: ! 1301: /* send telno, send \r */ ! 1302: sendthem(telno, dh); ! 1303: ok = expect(telno, dh); ! 1304: if (ok == 0) ! 1305: ok = expect("\r\n", dh); ! 1306: DEBUG(4, "got %s\n", ok ? "?" : "that"); ! 1307: if (ok != 0) ! 1308: continue; ! 1309: ! 1310: sendthem("", dh); /* confirm number */ ! 1311: DEBUG(4, "wanted %s ", "DIALING: "); ! 1312: ok = expect("DIALING: ", dh); ! 1313: DEBUG(4, "got %s\n", ok ? "?" : "that"); ! 1314: if (ok == 0) ! 1315: break; ! 1316: } ! 1317: ! 1318: if (ok == 0) { ! 1319: sleep(10 + delay); /* give vadic some time */ ! 1320: DEBUG(4, "wanted ON LINE\\r\\n ", 0); ! 1321: ok = expect("ON LINE\r\n", dh); ! 1322: DEBUG(4, "got %s\n", ok ? "?" : "that"); ! 1323: } ! 1324: ! 1325: if (ok != 0) { ! 1326: sendthem("I\\d", dh); /* back to idle */ ! 1327: if (dh > 2) ! 1328: close(dh); ! 1329: DEBUG(4, "vadDial failed\n", ""); ! 1330: delock(dev->D_line); ! 1331: return(CF_DIAL); ! 1332: } ! 1333: DEBUG(4, "vadic ok\n", ""); ! 1334: return(dh); ! 1335: } ! 1336: ! 1337: vadcls(fd) { ! 1338: ! 1339: if (fd > 0) { ! 1340: close(fd); ! 1341: sleep(5); ! 1342: delock(devSel); ! 1343: } ! 1344: } ! 1345: ! 1346: #endif VADIC ! 1347: ! 1348: #ifdef RVMACS ! 1349: /* ! 1350: * Racal-Vadic 'RV820' MACS system with 831 adaptor. ! 1351: * A typical 300 baud L-devices entry is ! 1352: * ACU /dev/tty10 /dev/tty11,48 300 rvmacs ! 1353: * where tty10 is the communication line (D_Line), ! 1354: * tty11 is the dialer line (D_calldev), ! 1355: * the '4' is the dialer address + modem type (viz. dialer 0, Bell 103), ! 1356: * and the '8' is the communication port (they are 1-indexed). ! 1357: * BUGS: ! 1358: * Only tested with one dialer, one modem ! 1359: * uses common speed for dialer and communication line. ! 1360: * UNTESTED ! 1361: */ ! 1362: ! 1363: #define STX 02 /* Access Adaptor */ ! 1364: #define ETX 03 /* Transfer to Dialer */ ! 1365: #define SI 017 /* Buffer Empty (end of phone number) */ ! 1366: #define SOH 01 /* Abort */ ! 1367: ! 1368: rvmacsopn(ph, flds, dev) ! 1369: char *ph, *flds[]; ! 1370: struct Devices *dev; ! 1371: { ! 1372: register int va, i, child; ! 1373: register char *p; ! 1374: char c, acu[20], com[20]; ! 1375: ! 1376: child = -1; ! 1377: if ((p = index(dev->D_calldev, ',')) == NULL) { ! 1378: DEBUG(2, "No dialer/modem specification\n", 0); ! 1379: goto failret; ! 1380: } ! 1381: *p++ = '\0'; ! 1382: if (setjmp(Sjbuf)) { ! 1383: logent("rvmacsopn", "TIMEOUT"); ! 1384: i = CF_DIAL; ! 1385: goto ret; ! 1386: } ! 1387: DEBUG(4, "STARTING CALL\n", 0); ! 1388: sprintf(acu, "/dev/%s", dev->D_calldev); ! 1389: getnextfd(); ! 1390: signal(SIGALRM, alarmtr); ! 1391: alarm(30); ! 1392: if ((va = open(acu, 2)) < 0) { ! 1393: logent(acu, "CAN'T OPEN"); ! 1394: i = CF_NODEV; ! 1395: goto ret; ! 1396: } ! 1397: fixline(va, dev->D_speed); ! 1398: ! 1399: p_chwrite(va, STX); /* access adaptor */ ! 1400: i = *p++ - '0'; ! 1401: if (i < 0 || i > 7) { ! 1402: logent(p-1, "Bad dialer address/modem type\n"); ! 1403: goto failret; ! 1404: } ! 1405: p_chwrite(va, i); /* Send Dialer Address Digit */ ! 1406: i = *p - '0'; ! 1407: if (i <= 0 || i > 14) { ! 1408: logent(p-1, "Bad modem address\n"); ! 1409: goto failret; ! 1410: } ! 1411: p_chwrite(va, i-1); /* Send Modem Address Digit */ ! 1412: write(va, ph, strlen(ph)); /* Send Phone Number */ ! 1413: p_chwrite(va, SI); /* Send Buffer Empty */ ! 1414: p_chwrite(va, ETX); /* Initiate Call */ ! 1415: sprintf(com, "/dev/%s", dev->D_line); ! 1416: ! 1417: /* create child to open comm line */ ! 1418: if ((child = fork()) == 0) { ! 1419: signal(SIGINT, SIG_DFL); ! 1420: open(com, 0); ! 1421: sleep(5); ! 1422: exit(1); ! 1423: } ! 1424: ! 1425: if (read(va, &c, 1) != 1) { ! 1426: logent("ACU READ", "FAILED"); ! 1427: goto failret; ! 1428: } ! 1429: switch(c) { ! 1430: case 'A': ! 1431: /* Fine! */ ! 1432: break; ! 1433: case 'B': ! 1434: DEBUG(2, "CALL ABORTED\n", 0); ! 1435: goto failret; ! 1436: case 'D': ! 1437: DEBUG(2, "Dialer format error\n", 0); ! 1438: goto failret; ! 1439: case 'E': ! 1440: DEBUG(2, "Dialer parity error\n", 0); ! 1441: goto failret; ! 1442: case 'F': ! 1443: DEBUG(2, "Phone number too long\n", 0); ! 1444: goto failret; ! 1445: case 'G': ! 1446: DEBUG(2, "Busy signal\n", 0); ! 1447: goto failret; ! 1448: default: ! 1449: DEBUG(2, "Unknown MACS return code '%c'\n", i); ! 1450: goto failret; ! 1451: } ! 1452: /* ! 1453: * open line - will return on carrier ! 1454: */ ! 1455: if ((i = open(com, 2)) < 0) { ! 1456: if (errno == EIO) ! 1457: logent("carrier", "LOST"); ! 1458: else ! 1459: logent("dialup open", "FAILED"); ! 1460: goto failret; ! 1461: } ! 1462: fixline(i, dev->D_speed); ! 1463: goto ret; ! 1464: failret: ! 1465: i = CF_DIAL; ! 1466: ret: ! 1467: alarm(0); ! 1468: if (child != -1) ! 1469: kill(child, SIGKILL); ! 1470: close(va); ! 1471: return(i); ! 1472: } ! 1473: ! 1474: rvmacscls(fd) ! 1475: register int fd; ! 1476: { ! 1477: DEBUG(2, "MACS close %d\n", fd); ! 1478: p_chwrite(fd, SOH); ! 1479: /* ioctl(fd, TIOCCDTR, NULL);*/ ! 1480: close(fd); ! 1481: } ! 1482: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.