![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to callers.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / uucp|
Return to callers.c CVS log | Up to [Research Unix] / researchv10no / cmd / uucp |
1.1 ! root 1: /* %W% ! 2: */ ! 3: #include "uucp.h" ! 4: VERSION(%W%); ! 5: ! 6: #ifdef BSD4_2 ! 7: #include <netdb.h> ! 8: #include <netinet/in.h> ! 9: #include <sys/socket.h> ! 10: #endif ! 11: #ifdef UNET ! 12: #include "UNET/unetio.h" ! 13: #include "UNET/tcp.h" ! 14: #endif ! 15: #if defined V8 && defined TCP ! 16: #include <sys/inet/in.h> ! 17: #include <sys/inet/tcp_user.h> ! 18: #endif ! 19: ! 20: ! 21: int alarmtr(); ! 22: extern jmp_buf Sjbuf; ! 23: extern char *fdig(); ! 24: ! 25: /* ! 26: * to add a new caller: ! 27: * declare the function that knows how to call on the device, ! 28: * add a line to the callers table giving the name of the device ! 29: * (from Devices file) and the name of the function ! 30: * add the function to the end of this file ! 31: */ ! 32: ! 33: #ifdef DIAL801 ! 34: int dial801(); ! 35: #endif ! 36: ! 37: #ifdef DATAKIT ! 38: int dkcall(); ! 39: #endif ! 40: ! 41: #ifdef CSERV ! 42: int cscall(); ! 43: #endif ! 44: ! 45: #ifdef V8 ! 46: int Dialout(); ! 47: #endif ! 48: ! 49: #ifdef TCP ! 50: int unetcall(); ! 51: int tcpcall(); ! 52: #endif ! 53: ! 54: #ifdef SYTEK ! 55: int sytcall(); ! 56: #endif ! 57: ! 58: struct caller Caller[] = { ! 59: ! 60: #ifdef DIAL801 ! 61: {"801", dial801}, ! 62: {"212", dial801}, ! 63: #endif ! 64: ! 65: #ifdef V8 ! 66: {"Dialout", Dialout}, /* ditto but using dialout(III) */ ! 67: #endif ! 68: ! 69: #ifdef TCP ! 70: #if defined BSD4_2 || defined V8 ! 71: {"TCP", tcpcall}, /* 4.2BSD sockets */ ! 72: #else ! 73: #ifdef UNET ! 74: {"TCP", unetcall}, /* 3com implementation of tcp */ ! 75: {"Unetserver", unetcall}, ! 76: #endif ! 77: #endif ! 78: #endif ! 79: ! 80: #ifdef DATAKIT ! 81: {"DK", dkcall}, /* standard AT&T DATAKIT VCS caller */ ! 82: #endif ! 83: ! 84: #ifdef CSERV ! 85: {"CS", cscall}, /* presotto connection server */ ! 86: #endif ! 87: ! 88: #ifdef SYTEK ! 89: {"Sytek", sytcall}, /* untested but should work */ ! 90: #endif ! 91: ! 92: {NULL, NULL} /* this line must be last */ ! 93: }; ! 94: ! 95: /*** ! 96: * exphone - expand phone number for given prefix and number ! 97: * ! 98: * return code - none ! 99: */ ! 100: ! 101: static void ! 102: exphone(in, out) ! 103: char *in, *out; ! 104: { ! 105: FILE *fn; ! 106: char pre[MAXPH], npart[MAXPH], tpre[MAXPH], p[MAXPH]; ! 107: char buf[BUFSIZ]; ! 108: char *s1; ! 109: ! 110: if (!isalpha(*in)) { ! 111: (void) strcpy(out, in); ! 112: return; ! 113: } ! 114: ! 115: s1=pre; ! 116: while (isalpha(*in)) ! 117: *s1++ = *in++; ! 118: *s1 = NULLCHAR; ! 119: s1 = npart; ! 120: while (*in != NULLCHAR) ! 121: *s1++ = *in++; ! 122: *s1 = NULLCHAR; ! 123: ! 124: tpre[0] = NULLCHAR; ! 125: fn = fopen(DIALFILE, "r"); ! 126: if (fn != NULL) { ! 127: while (fgets(buf, BUFSIZ, fn)) { ! 128: if ( sscanf(buf, "%s%s", p, tpre) < 1) ! 129: continue; ! 130: if (EQUALS(p, pre)) ! 131: break; ! 132: tpre[0] = NULLCHAR; ! 133: } ! 134: fclose(fn); ! 135: } ! 136: ! 137: (void) strcpy(out, tpre); ! 138: (void) strcat(out, npart); ! 139: return; ! 140: } ! 141: ! 142: /* ! 143: * repphone - Replace \D and \T sequences in arg with phone ! 144: * expanding and translating as appropriate. ! 145: */ ! 146: static char * ! 147: repphone(arg, phone, trstr) ! 148: register char *arg, *phone, *trstr; ! 149: { ! 150: extern void translate(); ! 151: static char pbuf[2*(MAXPH+2)]; ! 152: register char *fp, *tp; ! 153: ! 154: for (tp=pbuf; *arg; arg++) { ! 155: if (*arg != '\\') { ! 156: *tp++ = *arg; ! 157: continue; ! 158: } else { ! 159: switch (*(arg+1)) { ! 160: case 'T': ! 161: exphone(phone, tp); ! 162: translate(trstr, tp); ! 163: for(; *tp; tp++) ! 164: ; ! 165: arg++; ! 166: break; ! 167: case 'D': ! 168: for(fp=phone; *tp = *fp++; tp++) ! 169: ; ! 170: arg++; ! 171: break; ! 172: default: ! 173: *tp++ = *arg; ! 174: break; ! 175: } ! 176: } ! 177: } ! 178: *tp = '\0'; ! 179: return(pbuf); ! 180: } ! 181: ! 182: /* ! 183: * processdev - Process a line from the Devices file ! 184: * ! 185: * return codes: ! 186: * file descriptor - succeeded ! 187: * FAIL - failed ! 188: */ ! 189: ! 190: processdev(flds, dev) ! 191: register char *flds[], *dev[]; ! 192: { ! 193: register int dcf = -1; ! 194: register struct caller *ca; ! 195: char *args[D_MAX+1], dcname[20]; ! 196: register char **sdev; ! 197: extern void translate(); ! 198: register nullfd; ! 199: char *phonecl; /* clear phone string */ ! 200: char phoneex[2*(MAXPH+2)]; /* expanded phone string */ ! 201: ! 202: sdev = dev; ! 203: for (ca = Caller; ca->CA_type != NULL; ca++) { ! 204: /* This will find built-in caller functions */ ! 205: if (EQUALS(ca->CA_type, dev[D_CALLER])) { ! 206: DEBUG(5, "Internal caller type %s\n", dev[D_CALLER]); ! 207: if (dev[D_ARG] == NULL) { ! 208: /* if NULL - assume translate */ ! 209: dev[D_ARG+1] = NULL; /* needed for for loop later to mark the end */ ! 210: dev[D_ARG] = "\\T"; ! 211: } ! 212: dev[D_ARG] = repphone(dev[D_ARG], flds[F_PHONE], ""); ! 213: if ((dcf = (*(ca->CA_caller))(flds, dev)) < 0) ! 214: return(dcf) ; ! 215: dev += 2; /* Skip to next CALLER and ARG */ ! 216: break; ! 217: } ! 218: } ! 219: if (dcf == -1) { ! 220: /* Here if not a built-in caller function */ ! 221: if (mlock(dev[D_LINE]) == FAIL) { /* Lock the line */ ! 222: DEBUG(5, "mlock %s failed\n", dev[D_LINE]); ! 223: Uerror = SS_LOCKED_DEVICE; ! 224: return(FAIL); ! 225: } ! 226: DEBUG(5, "mlock %s succeeded\n", dev[D_LINE]); ! 227: /* ! 228: * Open the line ! 229: */ ! 230: (void) sprintf(dcname, "/dev/%s", dev[D_LINE]); ! 231: /* take care of the possible partial open fd */ ! 232: (void) close(nullfd = open("/", 0)); ! 233: if (setjmp(Sjbuf)) { ! 234: (void) close(nullfd); ! 235: DEBUG(1, "generic open timeout\n", ""); ! 236: logent("generic open", "TIMEOUT"); ! 237: Uerror = SS_CANT_ACCESS_DEVICE; ! 238: goto bad; ! 239: } ! 240: (void) signal(SIGALRM, alarmtr); ! 241: (void) alarm(10); ! 242: dcf = open(dcname, 2); ! 243: (void) alarm(0); ! 244: if (dcf < 0) { ! 245: (void) close(nullfd); ! 246: DEBUG(1, "generic open failed, errno = %d\n", errno); ! 247: logent("generic open", "FAILED"); ! 248: Uerror = SS_CANT_ACCESS_DEVICE; ! 249: goto bad; ! 250: } ! 251: fixline(dcf, atoi(fdig(flds[F_CLASS])), D_DIRECT); ! 252: } ! 253: /* ! 254: * Now loop through the remaining callers and chat ! 255: * according to scripts in dialers file. ! 256: */ ! 257: for (; dev[D_CALLER] != NULL; dev += 2) { ! 258: register int w; ! 259: /* ! 260: * Scan Dialers file to find an entry ! 261: */ ! 262: if ((w = gdial(dev[D_CALLER], args, D_MAX)) < 1) { ! 263: DEBUG(1, "%s not found in Dialers file\n", dev[D_CALLER]); ! 264: logent("generic call to gdial", "FAILED"); ! 265: Uerror = SS_CANT_ACCESS_DEVICE; ! 266: goto bad; ! 267: } ! 268: if (w <= 2) /* do nothing - no chat */ ! 269: break; ! 270: /* ! 271: * Translate the phone number ! 272: */ ! 273: if (dev[D_ARG] == NULL) { ! 274: /* if NULL - assume no translation */ ! 275: dev[D_ARG+1] = NULL; /* needed for for loop to mark the end */ ! 276: dev[D_ARG] = "\\D"; ! 277: } ! 278: ! 279: phonecl = repphone(dev[D_ARG], flds[F_PHONE], args[1]); ! 280: exphone(phonecl, phoneex); ! 281: translate(args[1], phoneex); ! 282: /* ! 283: * Chat ! 284: */ ! 285: if (chat(w-2, &args[2], dcf, phonecl, phoneex) != SUCCESS) { ! 286: Uerror = SS_CHAT_FAILED; ! 287: goto bad; ! 288: } ! 289: } ! 290: /* ! 291: * Success at last! ! 292: */ ! 293: strcpy(Dc, sdev[D_LINE]); ! 294: return(dcf); ! 295: bad: ! 296: (void)close(dcf); ! 297: delock(sdev[D_LINE]); ! 298: return(FAIL); ! 299: } ! 300: ! 301: /* ! 302: * translate the pairs of characters present in the first ! 303: * string whenever the first of the pair appears in the second ! 304: * string. ! 305: */ ! 306: static void ! 307: translate(ttab, str) ! 308: register char *ttab, *str; ! 309: { ! 310: register char *s; ! 311: ! 312: for(;*ttab && *(ttab+1); ttab += 2) ! 313: for(s=str;*s;s++) ! 314: if(*ttab == *s) ! 315: *s = *(ttab+1); ! 316: } ! 317: ! 318: #define MAXLINE 512 ! 319: /* ! 320: * Get the information about the dialer. ! 321: * gdial(type, arps, narps) ! 322: * type -> type of dialer (e.g., penril) ! 323: * arps -> array of pointers returned by gdial ! 324: * narps -> number of elements in array returned by gdial ! 325: * Return value: ! 326: * -1 -> Can't open DIALERFILE ! 327: * 0 -> requested type not found ! 328: * >0 -> success - number of fields filled in ! 329: */ ! 330: static ! 331: gdial(type, arps, narps) ! 332: register char *type, *arps[]; ! 333: register int narps; ! 334: { ! 335: static char info[MAXLINE]; ! 336: register FILE *ldial; ! 337: register na; ! 338: ! 339: DEBUG(2, "gdial(%s) called\n", type); ! 340: if ((ldial = fopen(DIALERFILE, "r")) == NULL) ! 341: return(-1); ! 342: while (fgets(info, sizeof(info), ldial) != NULL) { ! 343: if ((info[0] == '#') || (info[0] == ' ') || ! 344: (info[0] == '\t') || (info[0] == '\n')) ! 345: continue; ! 346: if ((na = getargs(info, arps, narps)) == 0) ! 347: continue; ! 348: if (EQUALS(arps[0], type)) { ! 349: (void)fclose(ldial); ! 350: bsfix(arps); ! 351: return(na); ! 352: } ! 353: } ! 354: (void)fclose(ldial); ! 355: return(0); ! 356: } ! 357: ! 358: ! 359: #ifdef DATAKIT ! 360: ! 361: /*** ! 362: * dkcall(flds, dev) make a DATAKIT VCS connection ! 363: * DATAKIT VCS is a trademark of AT&T ! 364: * ! 365: * return codes: ! 366: * >0 - file number - ok ! 367: * FAIL - failed ! 368: */ ! 369: ! 370: #include "dk.h" ! 371: ! 372: dkcall(flds, dev) ! 373: char *flds[], *dev[]; ! 374: { ! 375: register fd; ! 376: #ifdef V8 ! 377: extern int dkp_ld; ! 378: #endif ! 379: ! 380: char dialstring[64]; ! 381: ! 382: strcpy(dialstring, dev[D_ARG]); ! 383: ! 384: #ifndef STANDALONE ! 385: if(*flds[F_CLASS] < '0' || *flds[F_CLASS] > '9') ! 386: sprintf(dialstring, "%s.%s", dev[D_ARG], flds[F_CLASS]); ! 387: #endif ! 388: ! 389: DEBUG(4, "dkcall(%s)\n", dialstring); ! 390: ! 391: ! 392: #ifdef V8 ! 393: if (setjmp(Sjbuf)) { ! 394: Uerror = SS_DIAL_FAILED; ! 395: return(FAIL); ! 396: } ! 397: ! 398: (void) signal(SIGALRM, alarmtr); ! 399: (void) alarm(70); ! 400: DEBUG(4, "tdkdial(%s", dialstring); ! 401: DEBUG(4, ", %d)\n", atoi(flds[F_CLASS])); ! 402: if ((fd = tdkdial(dialstring, atoi(flds[F_CLASS]))) >= 0) ! 403: if (dkproto(fd, dkp_ld) < 0) ! 404: { ! 405: close(fd); ! 406: fd = -1; ! 407: } ! 408: (void) alarm(0); ! 409: #else ! 410: fd = dkdial(dialstring); ! 411: #endif ! 412: ! 413: (void) strcpy(Dc, "DK"); ! 414: if (fd < 0) { ! 415: Uerror = SS_DIAL_FAILED; ! 416: return(FAIL); ! 417: } ! 418: else ! 419: return(fd); ! 420: } ! 421: ! 422: #endif DATAKIT ! 423: ! 424: #ifdef TCP ! 425: ! 426: /*** ! 427: * tcpcall(flds, dev) make ethernet/socket connection ! 428: * ! 429: * return codes: ! 430: * >0 - file number - ok ! 431: * FAIL - failed ! 432: * ! 433: * the internet address is the phone number ! 434: * the port is the call device ! 435: */ ! 436: ! 437: #ifdef V8 ! 438: tcpcall(flds, dev) ! 439: char *flds[], *dev[]; ! 440: { ! 441: int ret; ! 442: int port; ! 443: extern int errno, sys_nerr; ! 444: extern char *sys_errlist[]; ! 445: struct in_service *sp; ! 446: struct tcpuser poot; ! 447: ! 448: poot.fport = atoi(dev[D_CALLDEV]); ! 449: if (poot.fport == 0) { ! 450: sp = in_service("uucp", "tcp", 0); ! 451: ASSERT(sp != NULL, "No uucp server", 0, 0); ! 452: poot.fport = sp->port; ! 453: } ! 454: if ((poot.faddr = in_address(dev[D_ARG])) == 0) { ! 455: logent("tcpopen", "no such host"); ! 456: Uerror = SS_BADSYSTEM; ! 457: return(FAIL); ! 458: } ! 459: DEBUG(4, "tcpdial host %s, ", dev[D_ARG]); ! 460: DEBUG(4, "port %d\n", poot.fport); ! 461: ! 462: ret = tcp_sock(); ! 463: if (ret < 0) { ! 464: if (errno < sys_nerr) { ! 465: DEBUG(5, "no socket: %s\n", sys_errlist[errno]); ! 466: logent("no socket", sys_errlist[errno]); ! 467: } ! 468: else { ! 469: DEBUG(5, "no socket, errno %d\n", errno); ! 470: logent("tcpopen", "NO SOCKET"); ! 471: } ! 472: Uerror = SS_NO_DEVICE; ! 473: return(FAIL); ! 474: } ! 475: if (setjmp(Sjbuf)) { ! 476: DEBUG(4, "timeout tcpopen\n", ""); ! 477: logent("tcpopen", "TIMEOUT"); ! 478: Uerror = SS_DIAL_FAILED; ! 479: return(FAIL); ! 480: } ! 481: (void) signal(SIGALRM, alarmtr); ! 482: (void) alarm(30); ! 483: DEBUG(7, "addr: %s\n", in_ntoa(poot.faddr)); ! 484: poot.lport = 0; ! 485: poot.param = 0; ! 486: poot.laddr = 0; ! 487: if (tcp_connect(ret, &poot) < 0) { ! 488: (void) alarm(0); ! 489: (void) close(ret); ! 490: if (errno < sys_nerr) { ! 491: DEBUG(5, "connect failed: %s\n", sys_errlist[errno]); ! 492: logent("connect failed", sys_errlist[errno]); ! 493: } ! 494: else { ! 495: DEBUG(5, "connect failed, errno %d\n", errno); ! 496: logent("tcpopen", "CONNECT FAILED"); ! 497: } ! 498: Uerror = SS_DIAL_FAILED; ! 499: return(FAIL); ! 500: } ! 501: (void) signal(SIGPIPE, SIG_IGN); /* watch out for broken ipc link...*/ ! 502: (void) alarm(0); ! 503: (void) strcpy(Dc, "IPC"); ! 504: return(ret); ! 505: } ! 506: #else ! 507: #ifdef BSD4_2 ! 508: tcpcall(flds, dev) ! 509: char *flds[], *dev[]; ! 510: { ! 511: int ret; ! 512: short port; ! 513: extern int errno, sys_nerr; ! 514: extern char *sys_errlist[]; ! 515: struct servent *sp; ! 516: struct hostent *hp; ! 517: struct sockaddr_in sin; ! 518: ! 519: port = atoi(dev[D_CALLDEV]); ! 520: if (port == 0) { ! 521: sp = getservbyname("uucp", "tcp"); ! 522: ASSERT(sp != NULL, "No uucp server", 0, 0); ! 523: port = sp->s_port; ! 524: } ! 525: else port = htons(port); ! 526: hp = gethostbyname(dev[D_ARG]); ! 527: if (hp == NULL) { ! 528: logent("tcpopen", "no such host"); ! 529: Uerror = SS_BADSYSTEM; ! 530: return(FAIL); ! 531: } ! 532: DEBUG(4, "tcpdial host %s, ", dev[D_ARG]); ! 533: DEBUG(4, "port %d\n", ntohs(port)); ! 534: ! 535: ret = socket(AF_INET, SOCK_STREAM, 0); ! 536: if (ret < 0) { ! 537: if (errno < sys_nerr) { ! 538: DEBUG(5, "no socket: %s\n", sys_errlist[errno]); ! 539: logent("no socket", sys_errlist[errno]); ! 540: } ! 541: else { ! 542: DEBUG(5, "no socket, errno %d\n", errno); ! 543: logent("tcpopen", "NO SOCKET"); ! 544: } ! 545: Uerror = SS_NO_DEVICE; ! 546: return(FAIL); ! 547: } ! 548: sin.sin_family = hp->h_addrtype; ! 549: bcopy(hp->h_addr, (caddr_t)&sin.sin_addr, hp->h_length); ! 550: sin.sin_port = port; ! 551: if (setjmp(Sjbuf)) { ! 552: DEBUG(4, "timeout tcpopen\n", ""); ! 553: logent("tcpopen", "TIMEOUT"); ! 554: Uerror = SS_NO_DEVICE; ! 555: return(FAIL); ! 556: } ! 557: (void) signal(SIGALRM, alarmtr); ! 558: (void) alarm(30); ! 559: DEBUG(7, "family: %d\n", sin.sin_family); ! 560: DEBUG(7, "port: %d\n", sin.sin_port); ! 561: DEBUG(7, "addr: %08x\n",*((int *) &sin.sin_addr)); ! 562: if (connect(ret, (caddr_t)&sin, sizeof (sin)) < 0) { ! 563: (void) alarm(0); ! 564: (void) close(ret); ! 565: if (errno < sys_nerr) { ! 566: DEBUG(5, "connect failed: %s\n", sys_errlist[errno]); ! 567: logent("connect failed", sys_errlist[errno]); ! 568: } ! 569: else { ! 570: DEBUG(5, "connect failed, errno %d\n", errno); ! 571: logent("tcpopen", "CONNECT FAILED"); ! 572: } ! 573: Uerror = SS_NO_DEVICE; ! 574: return(FAIL); ! 575: } ! 576: (void) signal(SIGPIPE, SIG_IGN); /* watch out for broken ipc link...*/ ! 577: (void) alarm(0); ! 578: (void) strcpy(Dc, "IPC"); ! 579: return(ret); ! 580: } ! 581: #endif ! 582: #endif ! 583: ! 584: ! 585: /*** ! 586: * unetcall(flds, dev) make ethernet connection ! 587: * ! 588: * return codes: ! 589: * >0 - file number - ok ! 590: * FAIL - failed ! 591: */ ! 592: ! 593: #ifdef UNET ! 594: unetcall(flds, dev) ! 595: char *flds[], *dev[]; ! 596: { ! 597: int ret; ! 598: int port; ! 599: extern int errno; ! 600: ! 601: port = atoi(dev[D_ARG]); ! 602: DEBUG(4, "unetdial host %s, ", flds[F_NAME]); ! 603: DEBUG(4, "port %d\n", port); ! 604: (void) alarm(30); ! 605: ret = tcpopen(flds[F_NAME], port, 0, TO_ACTIVE, "rw"); ! 606: (void) alarm(0); ! 607: endhnent(); /* wave magic wand at 3com and incant "eat it, bruce" */ ! 608: if (ret < 0) { ! 609: DEBUG(5, "tcpopen failed: errno %d\n", errno); ! 610: Uerror = SS_DIAL_FAILED; ! 611: return(FAIL); ! 612: } ! 613: (void) strcpy(Dc, "UNET"); ! 614: return(ret); ! 615: } ! 616: #endif UNET ! 617: ! 618: #endif /* TCP */ ! 619: ! 620: #ifdef CSERV ! 621: ! 622: #include <ipc.h> ! 623: ! 624: cscall(flds, dev) ! 625: char *flds[], *dev[]; ! 626: { ! 627: int fd; ! 628: register char *p; ! 629: char *rem; ! 630: extern int errno; ! 631: extern char *errstr; ! 632: ! 633: rem = dev[D_ARG]; ! 634: if (*dev[D_CALLDEV] == '.') { ! 635: for (p = rem; *p; p++) ! 636: if (*p == '.') { ! 637: *p = '!'; /* sad but true */ ! 638: break; ! 639: } ! 640: } ! 641: rem = ipcpath(rem, (char *)NULL, (char *)NULL); ! 642: DEBUG(4, "ipcopen(%s, ", rem); ! 643: DEBUG(4, "%s)\n", dev[D_LINE]); ! 644: if ((fd = ipcopen(rem, dev[D_LINE])) >= 0) ! 645: return (fd); ! 646: DEBUG(4, "ipcopen failed, error %d ", errno); ! 647: DEBUG(4, "%s\n", errstr); ! 648: /* should think more about errors */ ! 649: Uerror = SS_DIAL_FAILED; ! 650: return(FAIL); ! 651: } ! 652: #endif ! 653: ! 654: #ifdef SYTEK ! 655: ! 656: /**** ! 657: * sytcall(flds, dev) make a sytek connection ! 658: * ! 659: * return codes: ! 660: * >0 - file number - ok ! 661: * FAIL - failed ! 662: */ ! 663: ! 664: /*ARGSUSED*/ ! 665: sytcall(flds, dev) ! 666: char *flds[], *dev[]; ! 667: { ! 668: extern int errno; ! 669: int dcr, dcr2, nullfd, ret; ! 670: char dcname[20], command[BUFSIZ]; ! 671: ! 672: (void) sprintf(dcname, "/dev/%s", dev[D_LINE]); ! 673: DEBUG(4, "dc - %s, ", dcname); ! 674: dcr = open(dcname, O_WRONLY|O_NDELAY); ! 675: if (dcr < 0) { ! 676: Uerror = SS_DIAL_FAILED; ! 677: DEBUG(4, "OPEN FAILED %s\n", dcname); ! 678: delock(dev[D_LINE]); ! 679: return(FAIL); ! 680: } ! 681: ! 682: sytfixline(dcr, atoi(fdig(dev[D_CLASS])), D_DIRECT); ! 683: (void) sleep(2); ! 684: (void) sprintf(command,"\r\rcall %s\r",flds[F_PHONE]); ! 685: ret = write(dcr, command, strlen(command)); ! 686: (void) sleep(1); ! 687: DEBUG(4, "COM1 return = %d\n", ret); ! 688: sytfix2line(dcr); ! 689: (void) close(nullfd = open("/", 0)); ! 690: (void) signal(SIGALRM, alarmtr); ! 691: if (setjmp(Sjbuf)) { ! 692: DEBUG(4, "timeout sytek open\n", ""); ! 693: (void) close(nullfd); ! 694: (void) close(dcr2); ! 695: (void) close(dcr); ! 696: Uerror = SS_DIAL_FAILED; ! 697: delock(dev[D_LINE]); ! 698: return(FAIL); ! 699: } ! 700: (void) alarm(10); ! 701: dcr2 = open(dcname,O_RDWR); ! 702: (void) alarm(0); ! 703: (void) close(dcr); ! 704: if (dcr2 < 0) { ! 705: DEBUG(4, "OPEN 2 FAILED %s\n", dcname); ! 706: Uerror = SS_DIAL_FAILED; ! 707: (void) close(nullfd); /* kernel might think dc2 is open */ ! 708: delock(dev[D_LINE]); ! 709: return(FAIL); ! 710: } ! 711: return(dcr2); ! 712: } ! 713: ! 714: #endif SYTEK ! 715: ! 716: #ifdef DIAL801 ! 717: ! 718: /*** ! 719: * dial801(flds, dev) dial remote machine on 801/801 ! 720: * char *flds[], *dev[]; ! 721: * ! 722: * return codes: ! 723: * file descriptor - succeeded ! 724: * FAIL - failed ! 725: * ! 726: * unfortunately, open801() is different for usg and non-usg ! 727: */ ! 728: ! 729: /*ARGSUSED*/ ! 730: dial801(flds, dev) ! 731: char *flds[], *dev[]; ! 732: { ! 733: char dcname[20], dnname[20], phone[MAXPH+2], *fdig(); ! 734: int dcf = -1, speed; ! 735: ! 736: if (mlock(dev[D_LINE]) == FAIL) { ! 737: DEBUG(5, "mlock %s failed\n", dev[D_LINE]); ! 738: Uerror = SS_LOCKED_DEVICE; ! 739: return(FAIL); ! 740: } ! 741: (void) sprintf(dnname, "/dev/%s", dev[D_CALLDEV]); ! 742: (void) sprintf(phone, "%s%s", dev[D_ARG] , ACULAST); ! 743: (void) sprintf(dcname, "/dev/%s", dev[D_LINE]); ! 744: CDEBUG(1, "Use Port %s, ", dcname); ! 745: DEBUG(4, "acu - %s, ", dnname); ! 746: CDEBUG(1, "Phone Number %s\n", phone); ! 747: VERBOSE("Trying modem - %s, ", dcname); /* for cu */ ! 748: VERBOSE("acu - %s, ", dnname); /* for cu */ ! 749: VERBOSE("calling %s: ", phone); /* for cu */ ! 750: speed = atoi(fdig(dev[D_CLASS])); ! 751: dcf = open801(dcname, dnname, phone, speed); ! 752: if (dcf >= 0) { ! 753: fixline(dcf, speed, D_ACU); ! 754: (void) strcpy(Dc, dev[D_LINE]); /* for later unlock() */ ! 755: VERBOSE("SUCCEEDED\n", 0); ! 756: } else { ! 757: delock(dev[D_LINE]); ! 758: VERBOSE("FAILED\n", 0); ! 759: } ! 760: return(dcf); ! 761: } ! 762: ! 763: ! 764: #ifndef ATTSV ! 765: /*ARGSUSED*/ ! 766: open801(dcname, dnname, phone, speed) ! 767: char *dcname, *dnname, *phone; ! 768: { ! 769: int nw, lt, pid = -1, dcf = -1, nullfd, dnf = -1; ! 770: int rpid; ! 771: unsigned timelim; ! 772: ! 773: if ((dnf = open(dnname, 1)) < 0) { ! 774: DEBUG(5, "can't open %s\n", dnname); ! 775: Uerror = SS_CANT_ACCESS_DEVICE; ! 776: return(FAIL); ! 777: } ! 778: DEBUG(5, "%s is open\n", dnname); ! 779: ! 780: (void) close(nullfd = open("/dev/null", 0)); /* partial open hack */ ! 781: if (setjmp(Sjbuf)) { ! 782: DEBUG(4, "timeout modem open\n", ""); ! 783: logent("801 open", "TIMEOUT"); ! 784: (void) close(nullfd); ! 785: (void) close(dcf); ! 786: (void) close(dnf); ! 787: if (pid > 0) { ! 788: kill(pid, 9); ! 789: while ((rpid = wait((int *) 0)) > 0 && rpid != pid) ! 790: ; ! 791: } ! 792: Uerror = SS_DIAL_FAILED; ! 793: return(FAIL); ! 794: } ! 795: (void) signal(SIGALRM, alarmtr); ! 796: timelim = 5 * strlen(phone); ! 797: (void) alarm(timelim < 30 ? 30 : timelim); ! 798: if ((pid = fork()) == 0) { ! 799: sleep(2); ! 800: nw = write(dnf, phone, lt = strlen(phone)); ! 801: if (nw != lt) { ! 802: DEBUG(4, "ACU write error %d\n", errno); ! 803: logent("ACU write", "FAILED"); ! 804: exit(1); ! 805: } ! 806: DEBUG(4, "ACU write ok%s\n", ""); ! 807: exit(0); ! 808: } ! 809: /* open line - will return on carrier */ ! 810: dcf = open(dcname, 2); ! 811: ! 812: DEBUG(4, "dcf is %d\n", dcf); ! 813: if (dcf < 0) { /* handle like a timeout */ ! 814: (void) alarm(0); ! 815: longjmp(Sjbuf, 1); ! 816: } ! 817: ! 818: /* modem is open */ ! 819: while ((nw = wait(<)) != pid && nw != -1) ! 820: ; ! 821: (void) alarm(0); ! 822: ! 823: (void) close(dnf); /* no reason to keep the 801 open */ ! 824: if (lt != 0) { ! 825: DEBUG(4, "Fork Stat %o\n", lt); ! 826: (void) close(dcf); ! 827: Uerror = SS_DIAL_FAILED; ! 828: return(FAIL); ! 829: } ! 830: return(dcf); ! 831: } ! 832: ! 833: #else ! 834: ! 835: open801(dcname, dnname, phone, speed) ! 836: char *dcname, *dnname, *phone; ! 837: { ! 838: int nw, lt, dcf = -1, nullfd, dnf = -1, ret; ! 839: unsigned timelim; ! 840: ! 841: (void) close(nullfd = open("/", 0)); /* partial open hack */ ! 842: if (setjmp(Sjbuf)) { ! 843: DEBUG(4, "DN write %s\n", "timeout"); ! 844: (void) close(dnf); ! 845: (void) close(dcf); ! 846: (void) close(nullfd); ! 847: Uerror = SS_DIAL_FAILED; ! 848: return(FAIL); ! 849: } ! 850: (void) signal(SIGALRM, alarmtr); ! 851: timelim = 5 * strlen(phone); ! 852: (void) alarm(timelim < 30 ? 30 : timelim); ! 853: ! 854: if ((dnf = open(dnname, O_WRONLY)) < 0 ) { ! 855: DEBUG(5, "can't open %s\n", dnname); ! 856: Uerror = SS_CANT_ACCESS_DEVICE; ! 857: return(FAIL); ! 858: } ! 859: DEBUG(5, "%s is open\n", dnname); ! 860: if ( (dcf = open(dcname, O_RDWR | O_NDELAY)) < 0 ) { ! 861: DEBUG(5, "can't open %s\n", dcname); ! 862: Uerror = SS_CANT_ACCESS_DEVICE; ! 863: return(FAIL); ! 864: } ! 865: ! 866: DEBUG(4, "dcf is %d\n", dcf); ! 867: fixline(dcf, speed, D_ACU); ! 868: nw = write(dnf, phone, lt = strlen(phone)); ! 869: if (nw != lt) { ! 870: (void) alarm(0); ! 871: DEBUG(4, "ACU write error %d\n", errno); ! 872: (void) close(dnf); ! 873: (void) close(dcf); ! 874: Uerror = SS_DIAL_FAILED; ! 875: return(FAIL); ! 876: } else ! 877: DEBUG(4, "ACU write ok%s\n", ""); ! 878: ! 879: (void) close(dnf); ! 880: (void) close(nullfd = open("/", 0)); /* partial open hack */ ! 881: ret = open(dcname, 2); /* wait for carrier */ ! 882: (void) alarm(0); ! 883: (void) close(ret); /* close 2nd modem open() */ ! 884: if (ret < 0) { /* open() interrupted by alarm */ ! 885: DEBUG(4, "Line open %s\n", "failed"); ! 886: Uerror = SS_DIAL_FAILED; ! 887: (void) close(nullfd); /* close partially opened modem */ ! 888: return(FAIL); ! 889: } ! 890: (void) fcntl(dcf,F_SETFL, fcntl(dcf, F_GETFL, 0) & ~O_NDELAY); ! 891: return(dcf); ! 892: } ! 893: #endif ! 894: ! 895: #endif ! 896: ! 897: #ifdef V8 ! 898: Dialout(flds) ! 899: char *flds[]; ! 900: { ! 901: int fd; ! 902: char phone[MAXPH+2]; ! 903: ! 904: exphone(flds[F_PHONE], phone); ! 905: ! 906: DEBUG(4, "call dialout(%s", phone); ! 907: DEBUG(4, ", %s)\n", flds[F_CLASS]); ! 908: fd = dialout(phone, flds[F_CLASS]); ! 909: if (fd >= 0) ! 910: fixline(fd, 0, D_ACU); ! 911: else if (fd == -1) ! 912: Uerror = SS_NO_DEVICE; ! 913: else if (fd == -3) ! 914: Uerror = SS_DIAL_FAILED; ! 915: else if (fd == -9) ! 916: Uerror = SS_DEVICE_FAILED; ! 917: ! 918: (void) strcpy(Dc, "Dialout"); ! 919: ! 920: return(fd); ! 921: } ! 922: #endif DIAL801
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.