![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to courier.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 / tip / aculib|
Return to courier.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / tip / aculib |
1.1 ! root 1: /* ! 2: * Copyright (c) 1986 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted ! 6: * provided that: (1) source distributions retain this entire copyright ! 7: * notice and comment, and (2) distributions including binaries display ! 8: * the following acknowledgement: ``This product includes software ! 9: * developed by the University of California, Berkeley and its contributors'' ! 10: * in the documentation or other materials provided with the distribution ! 11: * and in all advertising materials mentioning features or use of this ! 12: * software. Neither the name of the University nor the names of its ! 13: * contributors may be used to endorse or promote products derived ! 14: * from this software without specific prior written permission. ! 15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 18: */ ! 19: ! 20: #ifndef lint ! 21: static char sccsid[] = "@(#)courier.c 5.5 (Berkeley) 6/1/90"; ! 22: #endif /* not lint */ ! 23: ! 24: #define write cour_write ! 25: /* ! 26: * Routines for calling up on a Courier modem. ! 27: * Derived from Hayes driver. ! 28: */ ! 29: #include "tip.h" ! 30: #include <stdio.h> ! 31: ! 32: #define MAXRETRY 5 ! 33: ! 34: static void sigALRM(); ! 35: static int timeout = 0; ! 36: static int connected = 0; ! 37: static jmp_buf timeoutbuf, intbuf; ! 38: static int (*osigint)(); ! 39: ! 40: cour_dialer(num, acu) ! 41: register char *num; ! 42: char *acu; ! 43: { ! 44: register char *cp; ! 45: #ifdef ACULOG ! 46: char line[80]; ! 47: #endif ! 48: if (boolean(value(VERBOSE))) ! 49: printf("Using \"%s\"\n", acu); ! 50: ! 51: ioctl(FD, TIOCHPCL, 0); ! 52: /* ! 53: * Get in synch. ! 54: */ ! 55: if (!coursync()) { ! 56: badsynch: ! 57: printf("can't synchronize with courier\n"); ! 58: #ifdef ACULOG ! 59: logent(value(HOST), num, "courier", "can't synch up"); ! 60: #endif ! 61: return (0); ! 62: } ! 63: write(FD, "AT E0\r", 6); /* turn off echoing */ ! 64: sleep(1); ! 65: #ifdef DEBUG ! 66: if (boolean(value(VERBOSE))) ! 67: verbose_read(); ! 68: #endif ! 69: ioctl(FD, TIOCFLUSH, 0); /* flush any clutter */ ! 70: write(FD, "AT C1 E0 H0 Q0 X6 V1\r", 21); ! 71: if (!cour_swallow("\r\nOK\r\n")) ! 72: goto badsynch; ! 73: fflush(stdout); ! 74: write(FD, "AT D", 4); ! 75: for (cp = num; *cp; cp++) ! 76: if (*cp == '=') ! 77: *cp = ','; ! 78: write(FD, num, strlen(num)); ! 79: write(FD, "\r", 1); ! 80: connected = cour_connect(); ! 81: #ifdef ACULOG ! 82: if (timeout) { ! 83: sprintf(line, "%d second dial timeout", ! 84: number(value(DIALTIMEOUT))); ! 85: logent(value(HOST), num, "cour", line); ! 86: } ! 87: #endif ! 88: if (timeout) ! 89: cour_disconnect(); ! 90: return (connected); ! 91: } ! 92: ! 93: cour_disconnect() ! 94: { ! 95: /* first hang up the modem*/ ! 96: ioctl(FD, TIOCCDTR, 0); ! 97: sleep(1); ! 98: ioctl(FD, TIOCSDTR, 0); ! 99: coursync(); /* reset */ ! 100: close(FD); ! 101: } ! 102: ! 103: cour_abort() ! 104: { ! 105: write(FD, "\r", 1); /* send anything to abort the call */ ! 106: cour_disconnect(); ! 107: } ! 108: ! 109: static void ! 110: sigALRM() ! 111: { ! 112: printf("\07timeout waiting for reply\n"); ! 113: timeout = 1; ! 114: longjmp(timeoutbuf, 1); ! 115: } ! 116: ! 117: static int ! 118: cour_swallow(match) ! 119: register char *match; ! 120: { ! 121: sig_t f; ! 122: char c; ! 123: ! 124: f = signal(SIGALRM, sigALRM); ! 125: timeout = 0; ! 126: do { ! 127: if (*match =='\0') { ! 128: signal(SIGALRM, f); ! 129: return (1); ! 130: } ! 131: if (setjmp(timeoutbuf)) { ! 132: signal(SIGALRM, f); ! 133: return (0); ! 134: } ! 135: alarm(number(value(DIALTIMEOUT))); ! 136: read(FD, &c, 1); ! 137: alarm(0); ! 138: c &= 0177; ! 139: #ifdef DEBUG ! 140: if (boolean(value(VERBOSE))) ! 141: putchar(c); ! 142: #endif ! 143: } while (c == *match++); ! 144: #ifdef DEBUG ! 145: if (boolean(value(VERBOSE))) ! 146: fflush(stdout); ! 147: #endif ! 148: signal(SIGALRM, SIG_DFL); ! 149: return (0); ! 150: } ! 151: ! 152: struct baud_msg { ! 153: char *msg; ! 154: int baud; ! 155: } baud_msg[] = { ! 156: "", B300, ! 157: " 1200", B1200, ! 158: " 2400", B2400, ! 159: 0, 0, ! 160: }; ! 161: ! 162: static int ! 163: cour_connect() ! 164: { ! 165: char c; ! 166: int nc, nl, n; ! 167: struct sgttyb sb; ! 168: char dialer_buf[64]; ! 169: struct baud_msg *bm; ! 170: sig_t f; ! 171: ! 172: if (cour_swallow("\r\n") == 0) ! 173: return (0); ! 174: f = signal(SIGALRM, sigALRM); ! 175: again: ! 176: nc = 0; nl = sizeof(dialer_buf)-1; ! 177: bzero(dialer_buf, sizeof(dialer_buf)); ! 178: timeout = 0; ! 179: for (nc = 0, nl = sizeof(dialer_buf)-1 ; nl > 0 ; nc++, nl--) { ! 180: if (setjmp(timeoutbuf)) ! 181: break; ! 182: alarm(number(value(DIALTIMEOUT))); ! 183: n = read(FD, &c, 1); ! 184: alarm(0); ! 185: if (n <= 0) ! 186: break; ! 187: c &= 0x7f; ! 188: if (c == '\r') { ! 189: if (cour_swallow("\n") == 0) ! 190: break; ! 191: if (!dialer_buf[0]) ! 192: goto again; ! 193: if (strcmp(dialer_buf, "RINGING") == 0 && ! 194: boolean(value(VERBOSE))) { ! 195: #ifdef DEBUG ! 196: printf("%s\r\n", dialer_buf); ! 197: #endif ! 198: goto again; ! 199: } ! 200: if (strncmp(dialer_buf, "CONNECT", ! 201: sizeof("CONNECT")-1) != 0) ! 202: break; ! 203: for (bm = baud_msg ; bm ; bm++) ! 204: if (strcmp(bm->msg, ! 205: dialer_buf+sizeof("CONNECT")-1) == 0) { ! 206: if (ioctl(FD, TIOCGETP, &sb) < 0) { ! 207: perror("TIOCGETP"); ! 208: goto error; ! 209: } ! 210: sb.sg_ispeed = sb.sg_ospeed = bm->baud; ! 211: if (ioctl(FD, TIOCSETP, &sb) < 0) { ! 212: perror("TIOCSETP"); ! 213: goto error; ! 214: } ! 215: signal(SIGALRM, f); ! 216: #ifdef DEBUG ! 217: if (boolean(value(VERBOSE))) ! 218: printf("%s\r\n", dialer_buf); ! 219: #endif ! 220: return (1); ! 221: } ! 222: break; ! 223: } ! 224: dialer_buf[nc] = c; ! 225: #ifdef notdef ! 226: if (boolean(value(VERBOSE))) ! 227: putchar(c); ! 228: #endif ! 229: } ! 230: error1: ! 231: printf("%s\r\n", dialer_buf); ! 232: error: ! 233: signal(SIGALRM, f); ! 234: return (0); ! 235: } ! 236: ! 237: /* ! 238: * This convoluted piece of code attempts to get ! 239: * the courier in sync. ! 240: */ ! 241: static int ! 242: coursync() ! 243: { ! 244: int already = 0; ! 245: int len; ! 246: char buf[40]; ! 247: ! 248: while (already++ < MAXRETRY) { ! 249: ioctl(FD, TIOCFLUSH, 0); /* flush any clutter */ ! 250: write(FD, "\rAT Z\r", 6); /* reset modem */ ! 251: bzero(buf, sizeof(buf)); ! 252: sleep(1); ! 253: ioctl(FD, FIONREAD, &len); ! 254: if (len) { ! 255: len = read(FD, buf, sizeof(buf)); ! 256: #ifdef DEBUG ! 257: buf[len] = '\0'; ! 258: printf("coursync: (\"%s\")\n\r", buf); ! 259: #endif ! 260: if (index(buf, '0') || ! 261: (index(buf, 'O') && index(buf, 'K'))) ! 262: return(1); ! 263: } ! 264: /* ! 265: * If not strapped for DTR control, ! 266: * try to get command mode. ! 267: */ ! 268: sleep(1); ! 269: write(FD, "+++", 3); ! 270: sleep(1); ! 271: /* ! 272: * Toggle DTR to force anyone off that might have left ! 273: * the modem connected. ! 274: */ ! 275: ioctl(FD, TIOCCDTR, 0); ! 276: sleep(1); ! 277: ioctl(FD, TIOCSDTR, 0); ! 278: } ! 279: write(FD, "\rAT Z\r", 6); ! 280: return (0); ! 281: } ! 282: ! 283: #undef write ! 284: ! 285: cour_write(fd, cp, n) ! 286: int fd; ! 287: char *cp; ! 288: int n; ! 289: { ! 290: struct sgttyb sb; ! 291: #ifdef notdef ! 292: if (boolean(value(VERBOSE))) ! 293: write(1, cp, n); ! 294: #endif ! 295: ioctl(fd, TIOCGETP, &sb); ! 296: ioctl(fd, TIOCSETP, &sb); ! 297: cour_nap(); ! 298: for ( ; n-- ; cp++) { ! 299: write(fd, cp, 1); ! 300: ioctl(fd, TIOCGETP, &sb); ! 301: ioctl(fd, TIOCSETP, &sb); ! 302: cour_nap(); ! 303: } ! 304: } ! 305: ! 306: #ifdef DEBUG ! 307: verbose_read() ! 308: { ! 309: int n = 0; ! 310: char buf[BUFSIZ]; ! 311: ! 312: if (ioctl(FD, FIONREAD, &n) < 0) ! 313: return; ! 314: if (n <= 0) ! 315: return; ! 316: if (read(FD, buf, n) != n) ! 317: return; ! 318: write(1, buf, n); ! 319: } ! 320: #endif ! 321: ! 322: /* ! 323: * Code stolen from /usr/src/lib/libc/gen/sleep.c ! 324: */ ! 325: #include <sys/time.h> ! 326: ! 327: #define mask(s) (1<<((s)-1)) ! 328: #define setvec(vec, a) \ ! 329: vec.sv_handler = a; vec.sv_mask = vec.sv_onstack = 0 ! 330: ! 331: static napms = 50; /* Give the courier 50 milliseconds between characters */ ! 332: ! 333: static int ringring; ! 334: ! 335: cour_nap() ! 336: { ! 337: ! 338: static void cour_napx(); ! 339: int omask; ! 340: struct itimerval itv, oitv; ! 341: register struct itimerval *itp = &itv; ! 342: struct sigvec vec, ovec; ! 343: ! 344: timerclear(&itp->it_interval); ! 345: timerclear(&itp->it_value); ! 346: if (setitimer(ITIMER_REAL, itp, &oitv) < 0) ! 347: return; ! 348: setvec(ovec, SIG_DFL); ! 349: omask = sigblock(mask(SIGALRM)); ! 350: itp->it_value.tv_sec = napms/1000; ! 351: itp->it_value.tv_usec = ((napms%1000)*1000); ! 352: setvec(vec, cour_napx); ! 353: ringring = 0; ! 354: (void) sigvec(SIGALRM, &vec, &ovec); ! 355: (void) setitimer(ITIMER_REAL, itp, (struct itimerval *)0); ! 356: while (!ringring) ! 357: sigpause(omask &~ mask(SIGALRM)); ! 358: (void) sigvec(SIGALRM, &ovec, (struct sigvec *)0); ! 359: (void) setitimer(ITIMER_REAL, &oitv, (struct itimerval *)0); ! 360: (void) sigsetmask(omask); ! 361: } ! 362: ! 363: static void ! 364: cour_napx() ! 365: { ! 366: ringring = 1; ! 367: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.