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