![[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] / 43BSDTahoe / usr.bin / uucp|
Return to condevs.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin / uucp |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)condevs.c 5.20 (Berkeley) 5/4/88"; ! 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: if (dfp == NULL) { ! 165: syslog(LOG_ERR, "fopen(%s) failed: %m", DEVFILE); ! 166: cleanup(FAIL); ! 167: } ! 168: while ((status = rddev(dfp, &dev)) != FAIL) { ! 169: #ifdef VMSDTR /* Modem control on vms(works dtr) */ ! 170: /* If we find MOD in the device type field we go into action */ ! 171: if (strcmp(dev.D_type, "MOD") == SAME) { ! 172: modem_control = 1; ! 173: DEBUG(7, "Setting Modem control to %d",modem_control); ! 174: } ! 175: if (strcmp(flds[F_CLASS], dev.D_class) != SAME) ! 176: continue; ! 177: /* ! 178: * Modem control on vms(works dtr) Take anything in MOD class. ! 179: * It probably should work differently anyway so we can have ! 180: * multiple hardwired lines. ! 181: */ ! 182: if (!modem_control&&strcmp(flds[F_PHONE], dev.D_line) != SAME) ! 183: #else !VMSDTR ! 184: if (strcmp(flds[F_CLASS], dev.D_class) != SAME) ! 185: continue; ! 186: if (strcmp(flds[F_PHONE], dev.D_line) != SAME) ! 187: #endif !VMSDTR ! 188: continue; ! 189: if (mlock(dev.D_line) != FAIL) ! 190: break; ! 191: } ! 192: fclose(dfp); ! 193: if (status == FAIL) { ! 194: logent("DEVICE", "NO"); ! 195: return CF_NODEV; ! 196: } ! 197: ! 198: sprintf(dcname, "/dev/%s", dev.D_line); ! 199: if (setjmp(Sjbuf)) { ! 200: DEBUG(4, "Open timed out\n", CNULL); ! 201: delock(dev.D_line); ! 202: return CF_DIAL; ! 203: } ! 204: signal(SIGALRM, alarmtr); ! 205: /* For PC Pursuit, it could take a while to call back */ ! 206: alarm( strcmp(flds[F_LINE], "PCP") ? 10 : MAXMSGTIME*4 ); ! 207: getnextfd(); ! 208: errno = 0; ! 209: DEBUG(4,"Opening %s\n",dcname); ! 210: dcr = open(dcname, 2); /* read/write */ ! 211: #ifdef VMSDTR /* Modem control on vms(works dtr) */ ! 212: fflush(stdout); ! 213: if (modem_control) { /* Did we have MOD in the device type field ? */ ! 214: /* Sense the current terminal setup and save it */ ! 215: if ((ret = sys$qiow(_$EFN,(fd_fab_pointer[dcr]->fab).fab$l_stv, ! 216: IO$_SENSEMODE,iosb,0,0,mode,8,0,0,0,0)) ! 217: != SS$_NORMAL) { ! 218: DEBUG(7, "ret status on sense failed on Modem sense=%x<", ret); ! 219: return CF_DIAL; ! 220: } ! 221: mode[1] |= TT$M_MODEM; /* Or in modem control(DTR) */ ! 222: /* Now set the new terminal characteristics */ ! 223: /* This is temporary and will go away when we let go of it */ ! 224: if ((ret = sys$qiow(_$EFN,(fd_fab_pointer[dcr]->fab).fab$l_stv, ! 225: IO$_SETMODE,iosb,0,0,mode,8,0,0,0,0)) ! 226: != SS$_NORMAL) { ! 227: DEBUG(7, "ret status on sense failed on Modem setup=%x<", ret); ! 228: return CF_DIAL; ! 229: } ! 230: } ! 231: #endif VMSDTR ! 232: next_fd = -1; ! 233: alarm(0); ! 234: if (dcr < 0) { ! 235: if (errno == EACCES) ! 236: logent(dev.D_line, "CANT OPEN"); ! 237: DEBUG(4, "OPEN FAILED: errno %d\n", errno); ! 238: delock(dev.D_line); ! 239: return CF_DIAL; ! 240: } ! 241: fflush(stdout); ! 242: if (fixline(dcr, dev.D_speed) == FAIL) { ! 243: DEBUG(4, "FIXLINE FAILED\n", CNULL); ! 244: return CF_DIAL; ! 245: } ! 246: strcpy(devSel, dev.D_line); /* for latter unlock */ ! 247: CU_end = dircls; ! 248: return dcr; ! 249: } ! 250: ! 251: dircls(fd) ! 252: register int fd; ! 253: { ! 254: if (fd > 0) { ! 255: close(fd); ! 256: delock(devSel); ! 257: } ! 258: } ! 259: ! 260: /* ! 261: * open an ACU and dial the number. The condevs table ! 262: * will be searched until a dialing unit is found that is free. ! 263: * ! 264: * return codes: >0 - file number - o.k. ! 265: * FAIL - failed ! 266: */ ! 267: char devSel[20]; /* used for later unlock() */ ! 268: ! 269: Acuopn(flds) ! 270: register char *flds[]; ! 271: { ! 272: char phone[MAXPH+1]; ! 273: register struct condev *cd; ! 274: register int fd, acustatus; ! 275: register FILE *dfp; ! 276: struct Devices dev; ! 277: int retval = CF_NODEV; ! 278: char nobrand[MAXPH], *line; ! 279: ! 280: exphone(flds[F_PHONE], phone); ! 281: if (snccmp(flds[F_LINE], "LOCAL") == SAME) ! 282: line = "ACU"; ! 283: else ! 284: line = flds[F_LINE]; ! 285: devSel[0] = '\0'; ! 286: nobrand[0] = '\0'; ! 287: DEBUG(4, "Dialing %s\n", phone); ! 288: dfp = fopen(DEVFILE, "r"); ! 289: if (dfp == NULL) { ! 290: syslog(LOG_ERR, "fopen(%s) failed: %m", DEVFILE); ! 291: cleanup(FAIL); ! 292: } ! 293: ! 294: acustatus = 0; /* none found, none locked */ ! 295: while (rddev(dfp, &dev) != FAIL) { ! 296: /* ! 297: * for each ACU L.sys line, try at most twice ! 298: * (TRYCALLS) to establish carrier. The old way tried every ! 299: * available dialer, which on big sites takes forever! ! 300: * Sites with a single auto-dialer get one try. ! 301: * Sites with multiple dialers get a try on each of two ! 302: * different dialers. ! 303: * To try 'harder' to connect to a remote site, ! 304: * use multiple L.sys entries. ! 305: */ ! 306: if (acustatus > TRYCALLS) ! 307: break; ! 308: if (strcmp(flds[F_CLASS], dev.D_class) != SAME) ! 309: continue; ! 310: if (snccmp(line, dev.D_type) != SAME) ! 311: continue; ! 312: if (dev.D_brand[0] == '\0') { ! 313: logent("Acuopn","No 'brand' name on ACU"); ! 314: continue; ! 315: } ! 316: for(cd = condevs; cd->CU_meth != NULL; cd++) { ! 317: if (snccmp(line, cd->CU_meth) == SAME) { ! 318: if (snccmp(dev.D_brand, cd->CU_brand) == SAME) { ! 319: nobrand[0] = '\0'; ! 320: break; ! 321: } ! 322: strncpy(nobrand, dev.D_brand, sizeof nobrand); ! 323: } ! 324: } ! 325: ! 326: if (acustatus < 1) ! 327: acustatus = 1; /* has been found */ ! 328: ! 329: if (mlock(dev.D_line) == FAIL) ! 330: continue; ! 331: ! 332: #ifdef DIALINOUT ! 333: #ifdef ALLACUINOUT ! 334: if (1) { ! 335: #else !ALLACUINOUT ! 336: if (snccmp("inout", dev.D_calldev) == SAME) { ! 337: #endif !ALLACUINOUT ! 338: if (disable(dev.D_line) == FAIL) { ! 339: delock(dev.D_line); ! 340: continue; ! 341: } ! 342: } else ! 343: reenable(); ! 344: #endif DIALINOUT ! 345: ! 346: DEBUG(4, "Using %s\n", cd->CU_brand); ! 347: acustatus++; ! 348: fd = (*(cd->CU_open))(phone, flds, &dev); ! 349: if (fd > 0) { ! 350: CU_end = cd->CU_clos; /* point CU_end at close func */ ! 351: fclose(dfp); ! 352: strcpy(devSel, dev.D_line); /* save for later unlock() */ ! 353: return fd; ! 354: } else ! 355: delock(dev.D_line); ! 356: retval = CF_DIAL; ! 357: } ! 358: fclose(dfp); ! 359: if (acustatus == 0) { ! 360: if (nobrand[0]) ! 361: logent(nobrand, "unsupported ACU type"); ! 362: else ! 363: logent("L-devices", "No appropriate ACU"); ! 364: } ! 365: if (acustatus == 1) ! 366: logent("DEVICE", "NO"); ! 367: return retval; ! 368: } ! 369: ! 370: /* ! 371: * intervaldelay: delay execution for numerator/denominator seconds. ! 372: */ ! 373: ! 374: #ifdef INTERVALTIMER ! 375: #include <sys/time.h> ! 376: #define uucpdelay(num,denom) intervaldelay(num,denom) ! 377: intervaldelay(num,denom) ! 378: int num, denom; ! 379: { ! 380: struct timeval tv; ! 381: tv.tv_sec = num / denom; ! 382: tv.tv_usec = (num * 1000000L / denom ) % 1000000L; ! 383: (void) select (0, (int *)0, (int *)0, (int *)0, &tv); ! 384: } ! 385: #endif INTERVALTIMER ! 386: ! 387: #ifdef FASTTIMER ! 388: #define uucpdelay(num,denom) nap(60*num/denom) ! 389: /* Sleep in increments of 60ths of second. */ ! 390: nap (time) ! 391: register int time; ! 392: { ! 393: static int fd; ! 394: ! 395: if (fd == 0) ! 396: fd = open (FASTTIMER, 0); ! 397: ! 398: read (fd, 0, time); ! 399: } ! 400: #endif FASTTIMER ! 401: ! 402: #ifdef FTIME ! 403: #define uucpdelay(num,denom) ftimedelay(1000*num/denom) ! 404: ftimedelay(n) ! 405: { ! 406: static struct timeb loctime; ! 407: register i = loctime.millitm; ! 408: ! 409: ftime(&loctime); ! 410: while (abs((int)(loctime.millitm - i))<n) ftime(&loctime) ! 411: ; ! 412: } ! 413: #endif FTIME ! 414: ! 415: #ifdef BUSYLOOP ! 416: #define uucpdelay(num,denom) busyloop(CPUSPEED*num/denom) ! 417: #define CPUSPEED 1000000 /* VAX 780 is 1MIPS */ ! 418: #define DELAY(n) { register long N = (n); while (--N > 0); } ! 419: busyloop(n) ! 420: { ! 421: DELAY(n); ! 422: } ! 423: #endif BUSYLOOP ! 424: ! 425: slowrite(fd, str) ! 426: register char *str; ! 427: { ! 428: DEBUG(6, "slowrite ", CNULL); ! 429: while (*str) { ! 430: DEBUG(6, "%c", *str); ! 431: uucpdelay(1, 10); /* delay 1/10 second */ ! 432: write(fd, str, 1); ! 433: str++; ! 434: } ! 435: DEBUG(6, "\n", CNULL); ! 436: } ! 437: ! 438: #define BSPEED B150 ! 439: ! 440: /* ! 441: * send a break ! 442: */ ! 443: genbrk(fn, bnulls) ! 444: register int fn, bnulls; ! 445: { ! 446: #ifdef USG ! 447: if (ioctl(fn, TCSBRK, STBNULL) < 0) ! 448: DEBUG(5, "break TCSBRK %s\n", sys_errlist[errno]); ! 449: #else !USG ! 450: # ifdef TIOCSBRK ! 451: if (ioctl(fn, TIOCSBRK, STBNULL) < 0) ! 452: DEBUG(5, "break TIOCSBRK %s\n", sys_errlist[errno]); ! 453: # ifdef TIOCCBRK ! 454: uucpdelay(bnulls, 10); ! 455: if (ioctl(fn, TIOCCBRK, STBNULL) < 0) ! 456: DEBUG(5, "break TIOCCBRK %s\n", sys_errlist[errno]); ! 457: # endif TIOCCBRK ! 458: DEBUG(4, "ioctl %f second break\n", (float) bnulls/10 ); ! 459: # else !TIOCSBRK ! 460: struct sgttyb ttbuf; ! 461: register int sospeed; ! 462: ! 463: if (ioctl(fn, TIOCGETP, &ttbuf) < 0) ! 464: DEBUG(5, "break TIOCGETP %s\n", sys_errlist[errno]); ! 465: sospeed = ttbuf.sg_ospeed; ! 466: ttbuf.sg_ospeed = BSPEED; ! 467: if (ioctl(fn, TIOCSETP, &ttbuf) < 0) ! 468: DEBUG(5, "break TIOCSETP %s\n", sys_errlist[errno]); ! 469: if (write(fn, "\0\0\0\0\0\0\0\0\0\0\0\0", bnulls) != bnulls) { ! 470: badbreak: ! 471: logent(sys_errlist[errno], "BAD WRITE genbrk"); ! 472: alarm(0); ! 473: longjmp(Sjbuf, 3); ! 474: } ! 475: ttbuf.sg_ospeed = sospeed; ! 476: if (ioctl(fn, TIOCSETP, &ttbuf) < 0) ! 477: DEBUG(5, "break ioctl %s\n", sys_errlist[errno]); ! 478: if (write(fn, "@", 1) != 1) ! 479: goto badbreak; ! 480: DEBUG(4, "sent BREAK nulls - %d\n", bnulls); ! 481: #endif !TIOCSBRK ! 482: #endif !USG ! 483: } ! 484: ! 485: ! 486: #ifdef DIALINOUT ! 487: /* DIALIN/OUT CODE (WLS) */ ! 488: /* ! 489: * disable and reenable: allow a single line to be use for dialin/dialout ! 490: * ! 491: */ ! 492: ! 493: char enbdev[16]; ! 494: ! 495: disable(dev) ! 496: register char *dev; ! 497: { ! 498: register char *rdev; ! 499: ! 500: /* strip off directory prefixes */ ! 501: rdev = dev; ! 502: while (*rdev) ! 503: rdev++; ! 504: while (--rdev >= dev && *rdev != '/') ! 505: ; ! 506: rdev++; ! 507: ! 508: if (enbdev[0]) { ! 509: if (strcmp(enbdev, rdev) == SAME) ! 510: return SUCCESS; /* already disabled */ ! 511: delock(enbdev); ! 512: reenable(); /* else, reenable the old one */ ! 513: } ! 514: DEBUG(4, "Disable %s\n", rdev); ! 515: if (enbcall("disable", rdev) == FAIL) ! 516: return FAIL; ! 517: strcpy(enbdev, rdev); ! 518: return SUCCESS; ! 519: } ! 520: ! 521: reenable() ! 522: { ! 523: if (enbdev[0] == '\0') ! 524: return; ! 525: DEBUG(4, "Reenable %s\n", enbdev); ! 526: (void) enbcall("enable", enbdev); ! 527: enbdev[0] = '\0'; ! 528: } ! 529: ! 530: enbcall(type, dev) ! 531: char *type, *dev; ! 532: { ! 533: int pid; ! 534: register char *p; ! 535: int fildes[2]; ! 536: int status; ! 537: FILE *fil; ! 538: char buf[80]; ! 539: ! 540: fflush(stderr); ! 541: fflush(stdout); ! 542: pipe(fildes); ! 543: if ((pid = fork()) == 0) { ! 544: DEBUG(4, DIALINOUT, CNULL); ! 545: DEBUG(4, " %s", type); ! 546: DEBUG(4, " %s\n", dev); ! 547: close(fildes[0]); ! 548: close(0); close(1); close(2); ! 549: open("/dev/null",0); ! 550: dup(fildes[1]); dup(fildes[1]); ! 551: setuid(geteuid()); /* for chown(uid()) in acu program */ ! 552: execl(DIALINOUT, "acu", type, dev, Rmtname, (char *)0); ! 553: exit(-1); ! 554: } ! 555: if (pid<0) ! 556: return FAIL; ! 557: ! 558: close(fildes[1]); ! 559: fil = fdopen(fildes[0],"r"); ! 560: if (fil!=NULL) { ! 561: #ifdef BSD4_2 ! 562: setlinebuf(fil); ! 563: #endif BSD4_2 ! 564: while (fgets(buf, sizeof buf, fil) != NULL) { ! 565: p = buf + strlen(buf) - 1; ! 566: if (*p == '\n') ! 567: *p = '\0'; ! 568: DEBUG(4, "ACUCNTRL: %s\n", buf); ! 569: } ! 570: } ! 571: while(wait(&status) != pid) ! 572: ; ! 573: fclose(fil); ! 574: return status ? FAIL : SUCCESS; ! 575: } ! 576: #endif DIALINOUT
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.