![[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] / 43BSD / usr.bin / uucp|
Return to condevs.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / uucp |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)condevs.c 5.15 (Berkeley) 2/12/86"; ! 3: #endif ! 4: ! 5: extern int errno; ! 6: extern char *sys_errlist[]; ! 7: ! 8: /* ! 9: * Here are various dialers to establish the machine-machine connection. ! 10: * conn.c/condevs.c was glued together by Mike Mitchell. ! 11: * The dialers were supplied by many people, to whom we are grateful. ! 12: * ! 13: * --------------------------------------------------------------------- ! 14: * NOTE: ! 15: * There is a bug that occurs at least on PDP11s due to a limitation of ! 16: * setjmp/longjmp. If the routine that does a setjmp is interrupted ! 17: * and longjmp-ed to, it loses its register variables (on a pdp11). ! 18: * What works is if the routine that does the setjmp ! 19: * calls a routine and it is the *subroutine* that is interrupted. ! 20: * ! 21: * Anyway, in conclusion, condevs.c is plagued with register variables ! 22: * that are used inside ! 23: * if (setjmp(...)) { ! 24: * .... ! 25: * } ! 26: * ! 27: * THE FIX: Don't declare variables to be register ! 28: */ ! 29: ! 30: #include "condevs.h" ! 31: ! 32: struct condev condevs[] = { ! 33: { "DIR", "direct", diropn, nulldev, dircls }, ! 34: #ifdef DATAKIT ! 35: { "DK", "datakit", dkopn, nulldev, nulldev }, ! 36: #endif DATAKIT ! 37: #ifdef PNET ! 38: { "PNET", "pnet", pnetopn, nulldev, nulldev }, ! 39: #endif PNET ! 40: #ifdef UNETTCP ! 41: { "TCP", "TCP", unetopn, nulldev, unetcls }, ! 42: #endif UNETTCP ! 43: #ifdef BSDTCP ! 44: { "TCP", "TCP", bsdtcpopn, nulldev, bsdtcpcls }, ! 45: #endif BSDTCP ! 46: #ifdef MICOM ! 47: { "MICOM", "micom", micopn, nulldev, miccls }, ! 48: #endif MICOM ! 49: #ifdef DN11 ! 50: { "ACU", "dn11", Acuopn, dnopn, dncls }, ! 51: #endif DN11 ! 52: #ifdef HAYES ! 53: { "ACU", "hayes", Acuopn, hyspopn, hyscls }, ! 54: { "ACU", "hayespulse", Acuopn, hyspopn, hyscls }, ! 55: { "ACU", "hayestone", Acuopn, hystopn, hyscls }, ! 56: { "WATS", "hayestone", Acuopn, hystopn, hyscls }, ! 57: #endif HAYES ! 58: #ifdef HAYES2400 ! 59: { "ACU", "hayes2400", Acuopn, hyspopn24, hyscls24 }, ! 60: { "ACU", "hayes2400pulse", Acuopn, hyspopn24, hyscls24 }, ! 61: { "ACU", "hayes2400tone", Acuopn, hystopn24, hyscls24 }, ! 62: #endif HAYES2400 ! 63: #ifdef HAYESQ /* a version of hayes that doesn't use result codes */ ! 64: { "ACU", "hayesq", Acuopn, hysqpopn, hysqcls }, ! 65: { "ACU", "hayesqpulse", Acuopn, hysqpopn, hysqcls }, ! 66: { "ACU", "hayesqtone", Acuopn, hysqtopn, hysqcls }, ! 67: #endif HAYESQ ! 68: #ifdef CDS224 ! 69: { "ACU", "cds224", Acuopn, cdsopn224, cdscls224}, ! 70: #endif CDS224 ! 71: #ifdef NOVATION ! 72: { "ACU", "novation", Acuopn, novopn, novcls}, ! 73: #endif NOVATION ! 74: #ifdef DF02 ! 75: { "ACU", "DF02", Acuopn, df2opn, df2cls }, ! 76: #endif DF02 ! 77: #ifdef DF112 ! 78: { "ACU", "DF112P", Acuopn, df12popn, df12cls }, ! 79: { "ACU", "DF112T", Acuopn, df12topn, df12cls }, ! 80: #endif DF112 ! 81: #ifdef VENTEL ! 82: { "ACU", "ventel", Acuopn, ventopn, ventcls }, ! 83: #endif VENTEL ! 84: #ifdef PENRIL ! 85: { "ACU", "penril", Acuopn, penopn, pencls }, ! 86: #endif PENRIL ! 87: #ifdef VADIC ! 88: { "ACU", "vadic", Acuopn, vadopn, vadcls }, ! 89: #endif VADIC ! 90: #ifdef VA212 ! 91: { "ACU", "va212", Acuopn, va212opn, va212cls }, ! 92: #endif VA212 ! 93: #ifdef VA811S ! 94: { "ACU", "va811s", Acuopn, va811opn, va811cls }, ! 95: #endif VA811S ! 96: #ifdef VA820 ! 97: { "ACU", "va820", Acuopn, va820opn, va820cls }, ! 98: { "WATS", "va820", Acuopn, va820opn, va820cls }, ! 99: #endif VA820 ! 100: #ifdef RVMACS ! 101: { "ACU", "rvmacs", Acuopn, rvmacsopn, rvmacscls }, ! 102: #endif RVMACS ! 103: #ifdef VMACS ! 104: { "ACU", "vmacs", Acuopn, vmacsopn, vmacscls }, ! 105: #endif VMACS ! 106: #ifdef SYTEK ! 107: { "SYTEK", "sytek", sykopn, nulldev, sykcls }, ! 108: #endif SYTEK ! 109: #ifdef ATT2224 ! 110: { "ACU", "att", Acuopn, attopn, attcls }, ! 111: #endif ATT2224 ! 112: ! 113: ! 114: /* Insert new entries before this line */ ! 115: { NULL, NULL, NULL, NULL, NULL } ! 116: }; ! 117: ! 118: /* ! 119: * nulldev a null device (returns CF_DIAL) ! 120: */ ! 121: nulldev() ! 122: { ! 123: return CF_DIAL; ! 124: } ! 125: ! 126: /* ! 127: * nodev a null device (returns CF_NODEV) ! 128: */ ! 129: nodev() ! 130: { ! 131: return CF_NODEV; ! 132: } ! 133: ! 134: /* ! 135: * Generic devices look through L-devices and call the CU_open routines for ! 136: * appropriate devices. Some things, like the tcp/ip interface, or direct ! 137: * connect, do not use the CU_open entry. ACUs must search to find the ! 138: * right routine to call. ! 139: */ ! 140: ! 141: /* ! 142: * diropn(flds) connect to hardware line ! 143: * ! 144: * return codes: ! 145: * > 0 - file number - ok ! 146: * FAIL - failed ! 147: */ ! 148: diropn(flds) ! 149: register char *flds[]; ! 150: { ! 151: register int dcr, status; ! 152: struct Devices dev; ! 153: char dcname[20]; ! 154: FILE *dfp; ! 155: #ifdef VMSDTR /* Modem control on vms(works dtr) */ ! 156: int modem_control; ! 157: short iosb[4]; ! 158: int sys$qiow(); /* use this for long reads on vms */ ! 159: int ret; ! 160: long mode[2]; ! 161: modem_control = 0; ! 162: #endif ! 163: dfp = fopen(DEVFILE, "r"); ! 164: ASSERT(dfp != NULL, "CAN'T OPEN", DEVFILE, 0); ! 165: while ((status = rddev(dfp, &dev)) != FAIL) { ! 166: #ifdef VMSDTR /* Modem control on vms(works dtr) */ ! 167: /* If we find MOD in the device type field we go into action */ ! 168: if (strcmp(dev.D_type, "MOD") == SAME) { ! 169: modem_control = 1; ! 170: DEBUG(7, "Setting Modem control to %d",modem_control); ! 171: } ! 172: if (strcmp(flds[F_CLASS], dev.D_class) != SAME) ! 173: continue; ! 174: /* ! 175: * Modem control on vms(works dtr) Take anything in MOD class. ! 176: * It probably should work differently anyway so we can have ! 177: * multiple hardwired lines. ! 178: */ ! 179: if (!modem_control&&strcmp(flds[F_PHONE], dev.D_line) != SAME) ! 180: #else !VMSDTR ! 181: if (strcmp(flds[F_CLASS], dev.D_class) != SAME) ! 182: continue; ! 183: if (strcmp(flds[F_PHONE], dev.D_line) != SAME) ! 184: #endif !VMSDTR ! 185: continue; ! 186: if (mlock(dev.D_line) != FAIL) ! 187: break; ! 188: } ! 189: fclose(dfp); ! 190: if (status == FAIL) { ! 191: logent("DEVICE", "NO"); ! 192: return CF_NODEV; ! 193: } ! 194: ! 195: sprintf(dcname, "/dev/%s", dev.D_line); ! 196: if (setjmp(Sjbuf)) { ! 197: DEBUG(4, "Open timed out\n", CNULL); ! 198: delock(dev.D_line); ! 199: return CF_DIAL; ! 200: } ! 201: signal(SIGALRM, alarmtr); ! 202: /* For PC Pursuit, it could take a while to call back */ ! 203: alarm( strcmp(flds[F_LINE], "PCP") ? 10 : MAXMSGTIME*4 ); ! 204: getnextfd(); ! 205: errno = 0; ! 206: DEBUG(4,"Opening %s\n",dcname); ! 207: dcr = open(dcname, 2); /* read/write */ ! 208: #ifdef VMSDTR /* Modem control on vms(works dtr) */ ! 209: fflush(stdout); ! 210: if (modem_control) { /* Did we have MOD in the device type field ? */ ! 211: /* Sense the current terminal setup and save it */ ! 212: if ((ret = sys$qiow(_$EFN,(fd_fab_pointer[dcr]->fab).fab$l_stv, ! 213: IO$_SENSEMODE,iosb,0,0,mode,8,0,0,0,0)) ! 214: != SS$_NORMAL) { ! 215: DEBUG(7, "ret status on sense failed on Modem sense=%x<", ret); ! 216: return CF_DIAL; ! 217: } ! 218: mode[1] |= TT$M_MODEM; /* Or in modem control(DTR) */ ! 219: /* Now set the new terminal characteristics */ ! 220: /* This is temporary and will go away when we let go of it */ ! 221: if ((ret = sys$qiow(_$EFN,(fd_fab_pointer[dcr]->fab).fab$l_stv, ! 222: IO$_SETMODE,iosb,0,0,mode,8,0,0,0,0)) ! 223: != SS$_NORMAL) { ! 224: DEBUG(7, "ret status on sense failed on Modem setup=%x<", ret); ! 225: return CF_DIAL; ! 226: } ! 227: } ! 228: #endif VMSDTR ! 229: next_fd = -1; ! 230: alarm(0); ! 231: if (dcr < 0) { ! 232: if (errno == EACCES) ! 233: logent(dev.D_line, "CANT OPEN"); ! 234: DEBUG(4, "OPEN FAILED: errno %d\n", errno); ! 235: delock(dev.D_line); ! 236: return CF_DIAL; ! 237: } ! 238: fflush(stdout); ! 239: if (fixline(dcr, dev.D_speed) == FAIL) { ! 240: DEBUG(4, "FIXLINE FAILED\n", CNULL); ! 241: return CF_DIAL; ! 242: } ! 243: strcpy(devSel, dev.D_line); /* for latter unlock */ ! 244: CU_end = dircls; ! 245: return dcr; ! 246: } ! 247: ! 248: dircls(fd) ! 249: register int fd; ! 250: { ! 251: if (fd > 0) { ! 252: close(fd); ! 253: delock(devSel); ! 254: } ! 255: } ! 256: ! 257: /* ! 258: * open an ACU and dial the number. The condevs table ! 259: * will be searched until a dialing unit is found that is free. ! 260: * ! 261: * return codes: >0 - file number - o.k. ! 262: * FAIL - failed ! 263: */ ! 264: char devSel[20]; /* used for later unlock() */ ! 265: ! 266: Acuopn(flds) ! 267: register char *flds[]; ! 268: { ! 269: char phone[MAXPH+1]; ! 270: register struct condev *cd; ! 271: register int fd, acustatus; ! 272: register FILE *dfp; ! 273: struct Devices dev; ! 274: int retval = CF_NODEV; ! 275: char nobrand[MAXPH], *line; ! 276: ! 277: exphone(flds[F_PHONE], phone); ! 278: if (snccmp(flds[F_LINE], "LOCAL") == SAME) ! 279: line = "ACU"; ! 280: else ! 281: line = flds[F_LINE]; ! 282: devSel[0] = '\0'; ! 283: nobrand[0] = '\0'; ! 284: DEBUG(4, "Dialing %s\n", phone); ! 285: dfp = fopen(DEVFILE, "r"); ! 286: ASSERT(dfp != NULL, "Can't open", DEVFILE, 0); ! 287: ! 288: acustatus = 0; /* none found, none locked */ ! 289: while (rddev(dfp, &dev) != FAIL) { ! 290: /* ! 291: * for each ACU L.sys line, try at most twice ! 292: * (TRYCALLS) to establish carrier. The old way tried every ! 293: * available dialer, which on big sites takes forever! ! 294: * Sites with a single auto-dialer get one try. ! 295: * Sites with multiple dialers get a try on each of two ! 296: * different dialers. ! 297: * To try 'harder' to connect to a remote site, ! 298: * use multiple L.sys entries. ! 299: */ ! 300: if (acustatus > TRYCALLS) ! 301: break; ! 302: if (strcmp(flds[F_CLASS], dev.D_class) != SAME) ! 303: continue; ! 304: if (snccmp(line, dev.D_type) != SAME) ! 305: continue; ! 306: if (dev.D_brand[0] == '\0') { ! 307: logent("Acuopn","No 'brand' name on ACU"); ! 308: continue; ! 309: } ! 310: for(cd = condevs; cd->CU_meth != NULL; cd++) { ! 311: if (snccmp(line, cd->CU_meth) == SAME) { ! 312: if (snccmp(dev.D_brand, cd->CU_brand) == SAME) ! 313: break; ! 314: strncpy(nobrand, dev.D_brand, sizeof nobrand); ! 315: } ! 316: } ! 317: ! 318: if (mlock(dev.D_line) == FAIL) { ! 319: acustatus++; ! 320: continue; ! 321: } ! 322: if (acustatus < 1) ! 323: acustatus = 1; /* has been found */ ! 324: #ifdef DIALINOUT ! 325: #ifdef ALLACUINOUT ! 326: if (1) { ! 327: #else !ALLACUINOUT ! 328: if (snccmp("inout", dev.D_calldev) == SAME) { ! 329: #endif !ALLACUINOUT ! 330: if (disable(dev.D_line) == FAIL) { ! 331: delock(dev.D_line); ! 332: continue; ! 333: } ! 334: } else ! 335: reenable(); ! 336: #endif DIALINOUT ! 337: ! 338: DEBUG(4, "Using %s\n", cd->CU_brand); ! 339: acustatus++; ! 340: fd = (*(cd->CU_open))(phone, flds, &dev); ! 341: if (fd > 0) { ! 342: CU_end = cd->CU_clos; /* point CU_end at close func */ ! 343: fclose(dfp); ! 344: strcpy(devSel, dev.D_line); /* save for later unlock() */ ! 345: return fd; ! 346: } else ! 347: delock(dev.D_line); ! 348: retval = CF_DIAL; ! 349: } ! 350: fclose(dfp); ! 351: if (acustatus == 0) { ! 352: if (nobrand[0]) ! 353: logent(nobrand, "unsupported ACU type"); ! 354: else ! 355: logent("L-devices", "No appropriate ACU"); ! 356: } ! 357: if (acustatus == 1) ! 358: logent("DEVICE", "NO"); ! 359: return retval; ! 360: } ! 361: ! 362: /* ! 363: * intervaldelay: delay execution for numerator/denominator seconds. ! 364: */ ! 365: ! 366: #ifdef INTERVALTIMER ! 367: #include <sys/time.h> ! 368: #define uucpdelay(num,denom) intervaldelay(num,denom) ! 369: intervaldelay(num,denom) ! 370: int num, denom; ! 371: { ! 372: struct timeval tv; ! 373: tv.tv_sec = num / denom; ! 374: tv.tv_usec = (num * 1000000L / denom ) % 1000000L; ! 375: (void) select (0, (int *)0, (int *)0, (int *)0, &tv); ! 376: } ! 377: #endif INTERVALTIMER ! 378: ! 379: #ifdef FASTTIMER ! 380: #define uucpdelay(num,denom) nap(60*num/denom) ! 381: /* Sleep in increments of 60ths of second. */ ! 382: nap (time) ! 383: register int time; ! 384: { ! 385: static int fd; ! 386: ! 387: if (fd == 0) ! 388: fd = open (FASTTIMER, 0); ! 389: ! 390: read (fd, 0, time); ! 391: } ! 392: #endif FASTTIMER ! 393: ! 394: #ifdef FTIME ! 395: #define uucpdelay(num,denom) ftimedelay(1000*num/denom) ! 396: ftimedelay(n) ! 397: { ! 398: static struct timeb loctime; ! 399: register i = loctime.millitm; ! 400: ! 401: ftime(&loctime); ! 402: while (abs((int)(loctime.millitm - i))<n) ftime(&loctime) ! 403: ; ! 404: } ! 405: #endif FTIME ! 406: ! 407: #ifdef BUSYLOOP ! 408: #define uucpdelay(num,denom) busyloop(CPUSPEED*num/denom) ! 409: #define CPUSPEED 1000000 /* VAX 780 is 1MIPS */ ! 410: #define DELAY(n) { register long N = (n); while (--N > 0); } ! 411: busyloop(n) ! 412: { ! 413: DELAY(n); ! 414: } ! 415: #endif BUSYLOOP ! 416: ! 417: slowrite(fd, str) ! 418: register char *str; ! 419: { ! 420: DEBUG(6, "slowrite ", CNULL); ! 421: while (*str) { ! 422: DEBUG(6, "%c", *str); ! 423: uucpdelay(1, 10); /* delay 1/10 second */ ! 424: write(fd, str, 1); ! 425: str++; ! 426: } ! 427: DEBUG(6, "\n", CNULL); ! 428: } ! 429: ! 430: #define BSPEED B150 ! 431: ! 432: /* ! 433: * send a break ! 434: */ ! 435: genbrk(fn, bnulls) ! 436: register int fn, bnulls; ! 437: { ! 438: #ifdef USG ! 439: if (ioctl(fn, TCSBRK, STBNULL) < 0) ! 440: DEBUG(5, "break TCSBRK %s\n", sys_errlist[errno]); ! 441: #else !USG ! 442: # ifdef TIOCSBRK ! 443: if (ioctl(fn, TIOCSBRK, STBNULL) < 0) ! 444: DEBUG(5, "break TIOCSBRK %s\n", sys_errlist[errno]); ! 445: # ifdef TIOCCBRK ! 446: uucpdelay(bnulls, 10); ! 447: if (ioctl(fn, TIOCCBRK, STBNULL) < 0) ! 448: DEBUG(5, "break TIOCCBRK %s\n", sys_errlist[errno]); ! 449: # endif TIOCCBRK ! 450: DEBUG(4, "ioctl %f second break\n", (float) bnulls/10 ); ! 451: # else !TIOCSBRK ! 452: struct sgttyb ttbuf; ! 453: register int sospeed; ! 454: ! 455: if (ioctl(fn, TIOCGETP, &ttbuf) < 0) ! 456: DEBUG(5, "break TIOCGETP %s\n", sys_errlist[errno]); ! 457: sospeed = ttbuf.sg_ospeed; ! 458: ttbuf.sg_ospeed = BSPEED; ! 459: if (ioctl(fn, TIOCSETP, &ttbuf) < 0) ! 460: DEBUG(5, "break TIOCSETP %s\n", sys_errlist[errno]); ! 461: if (write(fn, "\0\0\0\0\0\0\0\0\0\0\0\0", bnulls) != bnulls) { ! 462: badbreak: ! 463: logent(sys_errlist[errno], "BAD WRITE genbrk"); ! 464: alarm(0); ! 465: longjmp(Sjbuf, 3); ! 466: } ! 467: ttbuf.sg_ospeed = sospeed; ! 468: if (ioctl(fn, TIOCSETP, &ttbuf) < 0) ! 469: DEBUG(5, "break ioctl %s\n", sys_errlist[errno]); ! 470: if (write(fn, "@", 1) != 1) ! 471: goto badbreak; ! 472: DEBUG(4, "sent BREAK nulls - %d\n", bnulls); ! 473: #endif !TIOCSBRK ! 474: #endif !USG ! 475: } ! 476: ! 477: ! 478: #ifdef DIALINOUT ! 479: /* DIALIN/OUT CODE (WLS) */ ! 480: /* ! 481: * disable and reenable: allow a single line to be use for dialin/dialout ! 482: * ! 483: */ ! 484: ! 485: char enbdev[16]; ! 486: ! 487: disable(dev) ! 488: register char *dev; ! 489: { ! 490: register char *rdev; ! 491: ! 492: /* strip off directory prefixes */ ! 493: rdev = dev; ! 494: while (*rdev) ! 495: rdev++; ! 496: while (--rdev >= dev && *rdev != '/') ! 497: ; ! 498: rdev++; ! 499: ! 500: if (enbdev[0]) { ! 501: if (strcmp(enbdev, rdev) == SAME) ! 502: return SUCCESS; /* already disabled */ ! 503: delock(enbdev); ! 504: reenable(); /* else, reenable the old one */ ! 505: } ! 506: DEBUG(4, "Disable %s\n", rdev); ! 507: if (enbcall("disable", rdev) == FAIL) ! 508: return FAIL; ! 509: strcpy(enbdev, rdev); ! 510: return SUCCESS; ! 511: } ! 512: ! 513: reenable() ! 514: { ! 515: if (enbdev[0] == '\0') ! 516: return; ! 517: DEBUG(4, "Reenable %s\n", enbdev); ! 518: (void) enbcall("enable", enbdev); ! 519: enbdev[0] = '\0'; ! 520: } ! 521: ! 522: enbcall(type, dev) ! 523: char *type, *dev; ! 524: { ! 525: int pid; ! 526: register char *p; ! 527: int fildes[2]; ! 528: int status; ! 529: FILE *fil; ! 530: char buf[80]; ! 531: ! 532: fflush(stderr); ! 533: fflush(stdout); ! 534: pipe(fildes); ! 535: if ((pid = fork()) == 0) { ! 536: DEBUG(4, DIALINOUT, CNULL); ! 537: DEBUG(4, " %s", type); ! 538: DEBUG(4, " %s\n", dev); ! 539: close(fildes[0]); ! 540: close(0); close(1); close(2); ! 541: open("/dev/null",0); ! 542: dup(fildes[1]); dup(fildes[1]); ! 543: setuid(geteuid()); /* for chown(uid()) in acu program */ ! 544: execl(DIALINOUT, "acu", type, dev, 0); ! 545: exit(-1); ! 546: } ! 547: if (pid<0) ! 548: return FAIL; ! 549: ! 550: close(fildes[1]); ! 551: fil = fdopen(fildes[0],"r"); ! 552: if (fil!=NULL) { ! 553: #ifdef BSD4_2 ! 554: setlinebuf(fil); ! 555: #endif BSD4_2 ! 556: while (fgets(buf, sizeof buf, fil) != NULL) { ! 557: p = buf + strlen(buf) - 1; ! 558: if (*p == '\n') ! 559: *p = '\0'; ! 560: logent(buf,"ACUCNTRL:"); ! 561: } ! 562: } ! 563: while(wait(&status) != pid) ! 564: ; ! 565: fclose(fil); ! 566: return status ? FAIL : SUCCESS; ! 567: } ! 568: #endif DIALINOUT
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.