![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to conn.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / uucp|
Return to conn.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / uucp |
1.1 ! root 1: /* conn 2.1 5/23/79 19:07:44 */ ! 2: #define CONN ! 3: #include "uucp.h" ! 4: #include <signal.h> ! 5: #include <sgtty.h> ! 6: #include <setjmp.h> ! 7: #include <ctype.h> ! 8: #include <sys/types.h> ! 9: #include <time.h> ! 10: ! 11: static char SiD[] = "@(#)conn 2.1"; ! 12: ! 13: #ifdef DATAKIT ! 14: #include <dk.h> ! 15: #endif ! 16: ! 17: ! 18: #define F_NAME 0 ! 19: #define F_TIME 1 ! 20: #define F_LINE 2 ! 21: #define F_SPEED 3 ! 22: #define F_PHONE 4 ! 23: #define F_LOGIN 5 ! 24: ! 25: jmp_buf Sjbuf; ! 26: int alarmtr(); ! 27: #define INVOKE(a, r) ret = a; if (ret<0) return(r); ! 28: /******* ! 29: * conn(system) ! 30: * char *system; ! 31: * ! 32: * conn - place a telephone call to system and ! 33: * login, etc. ! 34: * ! 35: * return codes: ! 36: * CF_SYSTEM: don't know system ! 37: * CF_TIME: wrong time to call ! 38: * CF_DIAL: call failed ! 39: * CF_LOGIN: login/password dialog failed ! 40: * ! 41: * >0 - file no. - connect ok ! 42: * ! 43: */ ! 44: ! 45: conn(system) ! 46: char *system; ! 47: { ! 48: int ret, nf; ! 49: int fn; ! 50: char *flds[50]; ! 51: DEBUG(4, "gdial %s\n", "called"); ! 52: INVOKE(gdial(), CF_DIAL) ! 53: DEBUG(4, "finds %s\n", "called"); ! 54: INVOKE(nf = finds(system, flds), nf) ! 55: DEBUG(4, "getto %s\n", "called"); ! 56: INVOKE(fn = getto(flds), CF_DIAL) ! 57: DEBUG(4, "login %s\n", "called"); ! 58: INVOKE(login(nf, flds, fn), CF_LOGIN) ! 59: return(fn); ! 60: } ! 61: ! 62: /*** ! 63: * char * ! 64: * lastc(s) return pointer to last character ! 65: * char *s; ! 66: * ! 67: */ ! 68: ! 69: char * ! 70: lastc(s) ! 71: char *s; ! 72: { ! 73: while (*s != '\0') s++; ! 74: return(s); ! 75: } ! 76: ! 77: #define MAXDEV 10 ! 78: #define MAXDCH MAXDEV*20 ! 79: #define MAXCODE 30 ! 80: #define MAXCCH MAXCODE*20 ! 81: /* This array tells us about possible acu's, etc. */ ! 82: struct Devices { ! 83: char *D_type; ! 84: char *D_line; ! 85: char *D_calldev; ! 86: int D_speed; ! 87: } Devs [MAXDEV]; ! 88: ! 89: char Devbuff[MAXDCH]; ! 90: ! 91: struct Codes { ! 92: char *C_locs; ! 93: char *C_prefix; ! 94: } Dialcodes [MAXCODE]; ! 95: ! 96: char Codebuff[MAXCCH]; ! 97: int Dcfull = 0; ! 98: ! 99: ! 100: /*** ! 101: * gdial() get device and dial info ! 102: * ! 103: * return codes: 0 | FAIL ! 104: */ ! 105: ! 106: gdial() ! 107: { ! 108: char *flds[10], *lt; ! 109: char *lb = Devbuff; ! 110: char *lc = Codebuff; ! 111: FILE *fn; ! 112: int nr; ! 113: struct Devices *pd; ! 114: struct Codes *pc; ! 115: if (Dcfull) return(0); ! 116: ! 117: fn = fopen(Devfile, "r"); ! 118: ASSERT(fn != NULL, "CAN'T OPEN %s", Devfile); ! 119: for (pd = Devs; fgets(lb, 200, fn); pd++) { ! 120: lt = lastc(lb); ! 121: nr = getargs(lb, flds); ! 122: ASSERT(nr == 4, "BAD LINE %s", lb); ! 123: pd->D_type = flds[0]; ! 124: pd->D_line = flds[1]; ! 125: pd->D_calldev = flds[2]; ! 126: pd->D_speed = atoi(flds[3]); ! 127: lb = lt; ! 128: ASSERT(lb < Devbuff + MAXDCH, "TOO LONG %s", Devbuff); ! 129: ASSERT(pd < Devs + MAXDEV, "TOO MANY DEVICES %d", MAXCODE); ! 130: } ! 131: pd->D_line = NULL; ! 132: fclose(fn); ! 133: ASSERT(pd > Devs, "BAD FILE %s", Devfile); ! 134: /* Now dialcodes, same way */ ! 135: fn = fopen(Dialfile, "r"); ! 136: ASSERT(fn != NULL, "CAN'T OPEN %s", Dialfile); ! 137: for (pc = Dialcodes; fgets(lc, 200, fn); pc++) { ! 138: lt = lastc(lc); ! 139: nr = getargs(lc, flds); ! 140: if (nr == 1) flds[nr++] = ""; ! 141: ASSERT(nr == 2, "BAD LINE %s", lc); ! 142: pc->C_locs = flds[0]; ! 143: pc->C_prefix = flds[1]; ! 144: lc = lt; ! 145: ASSERT(lc < Codebuff + MAXCCH, "TOO LONG %s", Codebuff); ! 146: ASSERT(pc < Dialcodes + MAXCODE, "MANY DEVICES %d", MAXCODE); ! 147: } ! 148: pc->C_locs = 0; ! 149: fclose(fn); ! 150: return(0); ! 151: } ! 152: ! 153: ! 154: /*** ! 155: * ckdev(type, speed, ndev) ! 156: * char *type, *speed; ! 157: * int ndev; ! 158: * ! 159: * ckdev - return the device number in table Devs for ! 160: * a device with proper attributes. ! 161: * ! 162: * return codes: >= 0 (ok) | FAIL ! 163: */ ! 164: ! 165: ckdev(type, speed, ndev) ! 166: char *type, *speed; ! 167: int ndev; ! 168: { ! 169: int sp; ! 170: struct Devices *pd; ! 171: ! 172: sp = atoi(speed); ! 173: for (pd = &Devs[ndev]; pd->D_line != NULL; pd++) { ! 174: if (sp != pd->D_speed) ! 175: continue; ! 176: if ((strcmp(pd->D_type, type) == SAME) ! 177: && !mlock(pd->D_line)) ! 178: return(ndev = pd - Devs); ! 179: if ((strcmp(pd->D_line, type) == SAME) ! 180: && !mlock(type)) ! 181: return(ndev = pd - Devs); ! 182: } ! 183: return(FAIL); ! 184: } ! 185: ! 186: ! 187: /*** ! 188: * getto(flds) connect to remote machine ! 189: * char *flds[]; ! 190: * ! 191: * return codes: ! 192: * >0 - file number - ok ! 193: * FAIL - failed ! 194: */ ! 195: ! 196: getto(flds) ! 197: char *flds[]; ! 198: { ! 199: DEBUG(F_PHONE, "call: no. %s ", flds[4]); ! 200: DEBUG(4, "for sys %s ", flds[F_NAME]); ! 201: ! 202: if (prefix("ACU", flds[F_LINE])) ! 203: return(call(flds)); ! 204: ! 205: #ifdef DATAKIT ! 206: else if (prefix("DK", flds[F_LINE])) ! 207: return(dkcall(flds)); ! 208: #endif ! 209: ! 210: else ! 211: return(direct(flds)); ! 212: } ! 213: ! 214: /*** ! 215: * call(flds) call remote machine ! 216: * char *flds[]; ! 217: * ! 218: * "flds" contains the call information (name, date, type, speed, ! 219: * phone no. ... ! 220: * Ndev has the device no. ! 221: * ! 222: * return codes: ! 223: * >0 - file number - ok ! 224: * FAIL - failed ! 225: */ ! 226: ! 227: call(flds) ! 228: char *flds[]; ! 229: { ! 230: char *pno, pref[20], phone[20]; ! 231: char *s1, *s2; ! 232: int dcr, i; ! 233: struct Codes *pc; ! 234: ! 235: pno = flds[F_PHONE]; ! 236: s1 = pref; s2 = pno; ! 237: while (isalpha(*s2)) ! 238: *s1++ = *s2++; ! 239: *s1 = '\0'; ! 240: for (pc = Dialcodes; pc->C_locs; pc++) ! 241: if (strcmp(pc->C_locs, pref) == SAME) { ! 242: s1 = pc->C_prefix; ! 243: break; ! 244: } ! 245: sprintf(phone, "%s%s", s1, s2); ! 246: for (i = 0; i < TRYCALLS; i++) { ! 247: DEBUG(4, "Dial %s\n", phone); ! 248: dcr = dialup(phone, flds); ! 249: DEBUG(4, "dcr returned as %d\n", dcr); ! 250: if (dcr != FAIL) ! 251: break; ! 252: } ! 253: return(dcr); ! 254: ! 255: } ! 256: ! 257: /* file descriptor for call unit */ ! 258: int Dnf = 0; ! 259: ! 260: /*** ! 261: * dialup(ph, flds) dial remote machine ! 262: * char *ph; ! 263: * char *flds[]; ! 264: * ! 265: * return codes: ! 266: * file descriptor - succeeded ! 267: * FAIL - failed ! 268: */ ! 269: ! 270: dialup(ph, flds) ! 271: char *ph; ! 272: char *flds[]; ! 273: { ! 274: #ifdef DIALOUT ! 275: int dcf; ! 276: if ((dcf = dialout(ph, flds[F_SPEED])) < 0) ! 277: return(FAIL); ! 278: return(dcf); ! 279: #endif ! 280: ! 281: #ifndef DIALOUT ! 282: char dcname[20], dnname[20], phone[20]; ! 283: struct Devices *pd; ! 284: int nw, lt, pid, dcf, ndev, timelim; ! 285: extern int Error; ! 286: ! 287: for (ndev = 0;;ndev++) { ! 288: ndev = ckdev(flds[F_LINE], flds[F_SPEED], ndev); ! 289: if (ndev < 0) { ! 290: logent("AVAILABLE DEVICE", "NO"); ! 291: DEBUG(4, "NO AVAILABLE DEVICE %s\n", ""); ! 292: return(FAIL); ! 293: } ! 294: pd = &Devs[ndev]; ! 295: sprintf(dnname, "/dev/%s", pd->D_calldev); ! 296: /* open call unit */ ! 297: Dnf = open(dnname, 1); ! 298: if (Dnf >= 0) ! 299: break; ! 300: delock(pd->D_line); ! 301: } ! 302: sprintf(dcname, "/dev/%s", pd->D_line); ! 303: sprintf(phone, "%s%s", ph, ACULAST); ! 304: DEBUG(4, "dc - %s, ", dcname); ! 305: DEBUG(4, "acu - %s\n", dnname); ! 306: if (setjmp(Sjbuf)) { ! 307: DEBUG(1, "DN write %s\n", "timeout"); ! 308: logent("DIALUP DN write", "TIMEOUT"); ! 309: kill(pid, 9); ! 310: delock(pd->D_line); ! 311: close(Dnf); ! 312: return(FAIL); ! 313: } ! 314: signal(SIGALRM, alarmtr); ! 315: timelim = 5 * strlen(phone); ! 316: alarm(timelim < 30 ? 30 : timelim); ! 317: if ((pid = fork()) == 0) { ! 318: sleep(2); ! 319: fclose(stdin); ! 320: fclose(stdout); ! 321: nw = write(Dnf, phone, lt = strlen(phone)); ! 322: if (nw != lt) { ! 323: DEBUG(1, "ACU write %s\n", "error"); ! 324: logent("DIALUP ACU write", "FAILED"); ! 325: exit(1); ! 326: } ! 327: DEBUG(4, "ACU write ok%s\n", ""); ! 328: exit(0); ! 329: } ! 330: /* open line - will return on carrier */ ! 331: dcf = open(dcname, 2); ! 332: DEBUG(4, "dcf is %d\n", dcf); ! 333: if (dcf < 0) { ! 334: DEBUG(1, "Line open %s\n", "failed"); ! 335: logent("DIALUP LINE open", "FAILED"); ! 336: alarm(0); ! 337: kill(pid, 9); ! 338: close(Dnf); ! 339: return(FAIL); ! 340: } ! 341: ioctl(dcf, TIOCHPCL, 0); ! 342: while ((nw = wait(<)) != pid && nw != -1) ! 343: ; ! 344: alarm(0); ! 345: fflush(stdout); ! 346: fixline(dcf, pd->D_speed); ! 347: DEBUG(4, "Forked %d ", pid); ! 348: DEBUG(4, "Wait got %d ", nw); ! 349: DEBUG(4, "Status %o\n", lt); ! 350: if (lt != 0) { ! 351: close(dcf); ! 352: close(Dnf); ! 353: return(FAIL); ! 354: } ! 355: return(dcf); ! 356: #endif ! 357: } ! 358: ! 359: ! 360: /*** ! 361: * clsacu() close call unit ! 362: * ! 363: * return codes: none ! 364: */ ! 365: ! 366: clsacu() ! 367: { ! 368: if (Dnf > 0) { ! 369: close(Dnf); ! 370: sleep(5); ! 371: Dnf = 0; ! 372: } ! 373: return; ! 374: } ! 375: ! 376: ! 377: /*** ! 378: * direct(flds) connect to hardware line ! 379: * char *flds[]; ! 380: * ! 381: * return codes: ! 382: * >0 - file number - ok ! 383: * FAIL - failed ! 384: */ ! 385: ! 386: direct(flds) ! 387: char *flds[]; ! 388: { ! 389: int dcr, ndev; ! 390: char dcname[20]; ! 391: ! 392: ndev = 0; ! 393: if ((ndev = ckdev(flds[F_LINE], flds[F_SPEED], ndev)) < 0) { ! 394: logent("DEVICE", "NOT AVAILABLE"); ! 395: return(FAIL); ! 396: } ! 397: sprintf(dcname, "/dev/%s", Devs[ndev].D_line); ! 398: signal(SIGALRM, alarmtr); ! 399: alarm(10); ! 400: if (setjmp(Sjbuf)) ! 401: return(FAIL); ! 402: dcr = open(dcname, 2); /* read/write */ ! 403: alarm(0); ! 404: if (dcr < 0) ! 405: return(FAIL); ! 406: fflush(stdout); ! 407: fixline(dcr, Devs[ndev].D_speed); ! 408: return(dcr); ! 409: } ! 410: ! 411: #ifdef DATAKIT ! 412: ! 413: #define DKTRIES 2 ! 414: ! 415: /*** ! 416: * dkcall(flds) make datakit connection ! 417: * ! 418: * return codes: ! 419: * >0 - file number - ok ! 420: * FAIL - failed ! 421: */ ! 422: ! 423: dkcall(flds) ! 424: char *flds[]; ! 425: { ! 426: int dkphone; ! 427: register char *cp; ! 428: register ret, i; ! 429: ! 430: if (setjmp(Sjbuf)) ! 431: return(FAIL); ! 432: signal(SIGALRM, alarmtr); ! 433: dkphone = 0; ! 434: cp = flds[F_PHONE]; ! 435: while(*cp) ! 436: dkphone = 10 * dkphone + (*cp++ - '0'); ! 437: DEBUG(4, "dkphone (%d) ", dkphone); ! 438: for (i = 0; i < DKTRIES; i++) { ! 439: ret = dkdial(D_UU, dkphone, 0); ! 440: DEBUG(4, "dkdial (%d)\n", ret); ! 441: if (ret > -1) ! 442: break; ! 443: } ! 444: return(ret); ! 445: } ! 446: #endif ! 447: ! 448: #define MAXC 300 ! 449: ! 450: /*** ! 451: * finds(sysnam, flds) set system attribute vector ! 452: * char *sysnam, *flds[]; ! 453: * ! 454: * return codes: ! 455: * >0 - number of arguments in vector - succeeded ! 456: * CF_SYSTEM - system name not found ! 457: * CF_TIME - wrong time to call ! 458: */ ! 459: ! 460: finds(sysnam, flds) ! 461: char *sysnam, *flds[]; ! 462: { ! 463: FILE *fsys; ! 464: static char info[MAXC]; ! 465: char **fnp; ! 466: int na; ! 467: int fnd = 0; ! 468: ! 469: for (fnp = Sysfiles; *fnp != NULL && !fnd; fnp++) { ! 470: fsys = fopen(*fnp, "r"); ! 471: if (fsys == NULL) ! 472: continue; ! 473: while (!fnd && (fgets(info, MAXC, fsys) != NULL)) { ! 474: na = getargs(info, flds); ! 475: if (prefix(sysnam, flds[F_NAME])) ! 476: fnd = 1; ! 477: } ! 478: fclose(fsys); ! 479: } ! 480: if (fnd == 0) ! 481: return(CF_SYSTEM); ! 482: /* format of fields ! 483: * 0 name; ! 484: * 1 time ! 485: * 2 acu/hardwired ! 486: * 3 speed ! 487: * etc ! 488: */ ! 489: if (ifdate(flds[F_TIME]) == 0) { ! 490: DEBUG(1, "Wrong time to call %s\n", sysnam); ! 491: logent(sysnam, "WRONG TIME TO CALL"); ! 492: return(CF_TIME); ! 493: } ! 494: return(na); ! 495: } ! 496: ! 497: ! 498: /*** ! 499: * login(nf, flds, dcr) do log conversation ! 500: * char *flds[]; ! 501: * int nf; ! 502: * ! 503: * return codes: 0 | FAIL ! 504: */ ! 505: ! 506: login(nf, flds, fn) ! 507: char *flds[]; ! 508: int nf, fn; ! 509: { ! 510: char *want, *altern; ! 511: extern char *index(); ! 512: int k, ok; ! 513: ! 514: ASSERT(nf > 4, "TOO FEW LOG FIELDS %d", nf); ! 515: for (k = F_LOGIN; k < nf; k += 2) { ! 516: want = flds[k]; ! 517: ok = FAIL; ! 518: while (ok != 0) { ! 519: altern = index(want, '-'); ! 520: if (altern != NULL) ! 521: *altern++ = '\0'; ! 522: DEBUG(4, "wanted %s ", want); ! 523: ok = expect(want, fn); ! 524: DEBUG(4, "got %s\n", ok ? "?" : "that"); ! 525: if (ok == 0) ! 526: break; ! 527: if (altern == NULL) { ! 528: logent("LOGIN", "FAILED"); ! 529: return(FAIL); ! 530: } ! 531: want = index(altern, '-'); ! 532: if (want != NULL) ! 533: *want++ = '\0'; ! 534: sendthem(altern, fn); ! 535: } ! 536: sleep(2); ! 537: sendthem(flds[k+1], fn); ! 538: } ! 539: return(0); ! 540: } ! 541: ! 542: ! 543: struct sg_spds {int sp_val, sp_name;} spds[] = { ! 544: { 300, B300}, ! 545: {1200, B1200}, ! 546: {4800, B4800}, ! 547: {9600, B9600}, ! 548: {0, 0} }; ! 549: ! 550: /*** ! 551: * fixline(tty, spwant) set speed/echo/mode... ! 552: * int tty, spwant; ! 553: * ! 554: * return codes: none ! 555: */ ! 556: ! 557: fixline(tty, spwant) ! 558: int tty, spwant; ! 559: { ! 560: struct sgttyb ttbuf; ! 561: struct sg_spds *ps; ! 562: int speed = -1; ! 563: int ret; ! 564: ! 565: for (ps = spds; ps->sp_val; ps++) ! 566: if (ps->sp_val == spwant) ! 567: speed = ps->sp_name; ! 568: ASSERT(speed >= 0, "BAD SPEED %d", speed); ! 569: ioctl(tty, TIOCGETP, &ttbuf); ! 570: ttbuf.sg_flags =(ANYP|RAW); ! 571: ttbuf.sg_ispeed = ttbuf.sg_ospeed = speed; ! 572: DEBUG(4, "Speed: want %d ", spwant); ! 573: DEBUG(4, "use %o ", speed); ! 574: DEBUG(4, "ps %d\n", ps-spds); ! 575: ret = ioctl(tty, TIOCSETP, &ttbuf); ! 576: ASSERT(ret >= 0, "RETURN FROM STTY %d", ret); ! 577: ioctl(tty, TIOCHPCL, 0); ! 578: ioctl(tty, TIOCEXCL, 0); ! 579: return; ! 580: } ! 581: ! 582: ! 583: #define MR 300 ! 584: ! 585: int Error = 0; ! 586: ! 587: /*** ! 588: * expect(str, fn) look for expected string ! 589: * char *str; ! 590: * ! 591: * return codes: ! 592: * 0 - found ! 593: * FAIL - lost line or too many characters read ! 594: * some character - timed out ! 595: */ ! 596: ! 597: expect(str, fn) ! 598: char *str; ! 599: int fn; ! 600: { ! 601: static char rdvec[MR]; ! 602: char *rp = rdvec; ! 603: int nextch = 0, kr; ! 604: ! 605: if (strcmp(str, "\"\"") == SAME) ! 606: return(0); ! 607: *rp = 0; ! 608: if (setjmp(Sjbuf)) { ! 609: return(FAIL); ! 610: } ! 611: signal(SIGALRM, alarmtr); ! 612: while (notin(str, rdvec)) { ! 613: alarm(MAXCHARTIME); ! 614: kr = read(fn, &nextch, 1); ! 615: if (kr <= 0) { ! 616: DEBUG(4, "kr - %d\n", kr); ! 617: alarm(0); ! 618: DEBUG(4, "lost line kr - %d, ", kr); ! 619: DEBUG(4, "fn - %d\n", fn); ! 620: logent("LOGIN", "LOST LINE"); ! 621: return(FAIL); ! 622: } ! 623: { ! 624: int c; ! 625: c = nextch & 0177; ! 626: DEBUG(4, "%c", c > 040 ? c : '_'); ! 627: } ! 628: if ((*rp = nextch & 0177) != '\0') ! 629: rp++; ! 630: *rp = '\0'; ! 631: if (rp >= rdvec + MR) ! 632: return(FAIL); ! 633: } ! 634: alarm(0); ! 635: return(0); ! 636: } ! 637: ! 638: ! 639: /*** ! 640: * alarmtr() - catch alarm routine for "expect". ! 641: */ ! 642: ! 643: alarmtr() ! 644: { ! 645: longjmp(Sjbuf, 1); ! 646: } ! 647: ! 648: ! 649: /*** ! 650: * sendthem(str, fn) send line of login sequence ! 651: * char *str; ! 652: * ! 653: * return codes: none ! 654: */ ! 655: ! 656: sendthem(str, fn) ! 657: char *str; ! 658: int fn; ! 659: { ! 660: int nw, ns; ! 661: int nulls; ! 662: ! 663: if (prefix("BREAK", str)) { ! 664: sscanf(&str[5], "%1d", &nulls); ! 665: if (nulls <= 0 || nulls > 10) ! 666: nulls = 3; ! 667: /* send break */ ! 668: DEBUG(5, "%s,", str); ! 669: DEBUG(5, "%d\n", nulls); ! 670: genbrk(fn, nulls); ! 671: return; ! 672: } ! 673: ! 674: if (strcmp(str, "EOT") == SAME) { ! 675: write(fn, EOTMSG, strlen(EOTMSG)); ! 676: return; ! 677: } ! 678: if (strcmp(str, "") != SAME) { ! 679: nw = write(fn, str, ns = strlen(str)); ! 680: ASSERT(nw == ns, "BAD WRITE $s", str); ! 681: } ! 682: write(fn, "\n", 1); ! 683: return; ! 684: } ! 685: ! 686: #define BSPEED B150 ! 687: ! 688: /*** ! 689: * genbrk send a break ! 690: * ! 691: * return codes; none ! 692: */ ! 693: ! 694: genbrk(fn, bnulls) ! 695: { ! 696: struct sgttyb ttbuf; ! 697: int ret, sospeed; ! 698: ! 699: ret = ioctl(fn, TIOCGETP, &ttbuf); ! 700: DEBUG(5, "ioctl ret %d\n", ret); ! 701: sospeed = ttbuf.sg_ospeed; ! 702: ttbuf.sg_ospeed = BSPEED; ! 703: ret = ioctl(fn, TIOCSETP, &ttbuf); ! 704: DEBUG(5, "ioctl ret %d\n", ret); ! 705: ret = write(fn, "\0\0\0\0\0\0\0\0\0\0\0\0", bnulls); ! 706: ASSERT(ret > 0, "BAD WRITE genbrk %d", ret); ! 707: ttbuf.sg_ospeed = sospeed; ! 708: ret = ioctl(fn, TIOCSETP, &ttbuf); ! 709: ret = write(fn, "@", 1); ! 710: ASSERT(ret > 0, "BAD WRITE genbrk %d", ret); ! 711: DEBUG(4, "sent BREAK nulls - %d\n", bnulls); ! 712: return; ! 713: } ! 714: ! 715: ! 716: /*** ! 717: * notin(sh, lg) check for occurrence of substring "sh" ! 718: * char *sh, *lg; ! 719: * ! 720: * return codes: ! 721: * 0 - found the string ! 722: * 1 - not in the string ! 723: */ ! 724: ! 725: notin(sh, lg) ! 726: char *sh, *lg; ! 727: { ! 728: while (*lg != '\0') { ! 729: if (prefix(sh, lg)) ! 730: return(0); ! 731: else ! 732: lg++; ! 733: } ! 734: return(1); ! 735: } ! 736: ! 737: ! 738: /******* ! 739: * ifdate(s) ! 740: * char *s; ! 741: * ! 742: * ifdate - this routine will check a string (s) ! 743: * like "MoTu0800-1730" to see if the present ! 744: * time is within the given limits. ! 745: * ! 746: * String alternatives: ! 747: * Wk - Mo thru Fr ! 748: * zero or one time means all day ! 749: * Any - any day ! 750: * ! 751: * return codes: ! 752: * 0 - not within limits ! 753: * 1 - within limits ! 754: */ ! 755: ! 756: ifdate(s) ! 757: char *s; ! 758: { ! 759: static char *days[]={ ! 760: "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa", 0 ! 761: }; ! 762: long clock; ! 763: int i, tl, th, tn, dayok=0; ! 764: struct tm *localtime(); ! 765: struct tm *tp; ! 766: ! 767: time(&clock); ! 768: tp = localtime(&clock); ! 769: while (isalpha(*s)) { ! 770: for (i = 0; days[i]; i++) { ! 771: if (prefix(days[i], s)) ! 772: if (tp->tm_wday == i) ! 773: dayok = 1; ! 774: } ! 775: ! 776: if (prefix("Wk", s)) ! 777: if (tp->tm_wday >= 1 && tp->tm_wday <= 5) ! 778: dayok = 1; ! 779: if (prefix("Any", s)) ! 780: dayok = 1; ! 781: s++; ! 782: } ! 783: ! 784: if (dayok == 0) ! 785: return(0); ! 786: i = sscanf(s, "%d-%d", &tl, &th); ! 787: tn = tp->tm_hour * 100 + tp->tm_min; ! 788: if (i < 2) ! 789: return(1); ! 790: if (tn >= tl && tn <= th) ! 791: return(1); ! 792: return(0); ! 793: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.