Return to biz22.c CVS log

Up to [CSRG BSD Unix] / 43BSD / usr.bin / tip / aculib

Annotation of 43BSD/usr.bin/tip/aculib/biz22.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1983 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #ifndef lint
        !             8: static char sccsid[] = "@(#)biz22.c    5.1 (Berkeley) 6/6/85";
        !             9: #endif not lint
        !            10: 
        !            11: #include "tip.h"
        !            12: 
        !            13: #define DISCONNECT_CMD "\20\04"        /* disconnection string */
        !            14: 
        !            15: static int sigALRM();
        !            16: static int timeout = 0;
        !            17: static jmp_buf timeoutbuf;
        !            18: 
        !            19: /*
        !            20:  * Dial up on a BIZCOMP Model 1022 with either
        !            21:  *     tone dialing (mod = "V")
        !            22:  *     pulse dialing (mod = "W")
        !            23:  */
        !            24: static int
        !            25: biz_dialer(num, mod)
        !            26:        char *num, *mod;
        !            27: {
        !            28:        register int connected = 0;
        !            29:        char cbuf[40];
        !            30: 
        !            31:        if (boolean(value(VERBOSE)))
        !            32:                printf("\nstarting call...");
        !            33:        /*
        !            34:         * Disable auto-answer and configure for tone/pulse
        !            35:         *  dialing
        !            36:         */
        !            37:        if (cmd("\02K\r")) {
        !            38:                printf("can't initialize bizcomp...");
        !            39:                return (0);
        !            40:        }
        !            41:        strcpy(cbuf, "\02.\r");
        !            42:        cbuf[1] = *mod;
        !            43:        if (cmd(cbuf)) {
        !            44:                printf("can't set dialing mode...");
        !            45:                return (0);
        !            46:        }
        !            47:        strcpy(cbuf, "\02D");
        !            48:        strcat(cbuf, num);
        !            49:        strcat(cbuf, "\r");
        !            50:        write(FD, cbuf, strlen(cbuf));
        !            51:        if (!detect("7\r")) {
        !            52:                printf("can't get dial tone...");
        !            53:                return (0);
        !            54:        }
        !            55:        if (boolean(value(VERBOSE)))
        !            56:                printf("ringing...");
        !            57:        /*
        !            58:         * The reply from the BIZCOMP should be:
        !            59:         *      2 \r or 7 \r    failure
        !            60:         *      1 \r            success
        !            61:         */
        !            62:        connected = detect("1\r");
        !            63: #ifdef ACULOG
        !            64:        if (timeout) {
        !            65:                char line[80];
        !            66: 
        !            67:                sprintf(line, "%d second dial timeout",
        !            68:                        number(value(DIALTIMEOUT)));
        !            69:                logent(value(HOST), num, "biz1022", line);
        !            70:        }
        !            71: #endif
        !            72:        if (timeout)
        !            73:                biz22_disconnect();     /* insurance */
        !            74:        return (connected);
        !            75: }
        !            76: 
        !            77: biz22w_dialer(num, acu)
        !            78:        char *num, *acu;
        !            79: {
        !            80: 
        !            81:        return (biz_dialer(num, "W"));
        !            82: }
        !            83: 
        !            84: biz22f_dialer(num, acu)
        !            85:        char *num, *acu;
        !            86: {
        !            87: 
        !            88:        return (biz_dialer(num, "V"));
        !            89: }
        !            90: 
        !            91: biz22_disconnect()
        !            92: {
        !            93:        int rw = 2;
        !            94: 
        !            95:        write(FD, DISCONNECT_CMD, 4);
        !            96:        sleep(2);
        !            97:        ioctl(FD, TIOCFLUSH, &rw);
        !            98: }
        !            99: 
        !           100: biz22_abort()
        !           101: {
        !           102: 
        !           103:        write(FD, "\02", 1);
        !           104: }
        !           105: 
        !           106: static int
        !           107: sigALRM()
        !           108: {
        !           109: 
        !           110:        timeout = 1;
        !           111:        longjmp(timeoutbuf, 1);
        !           112: }
        !           113: 
        !           114: static int
        !           115: cmd(s)
        !           116:        register char *s;
        !           117: {
        !           118:        char c;
        !           119:        int (*f)();
        !           120: 
        !           121:        write(FD, s, strlen(s));
        !           122:        f = signal(SIGALRM, sigALRM);
        !           123:        if (setjmp(timeoutbuf)) {
        !           124:                biz22_abort();
        !           125:                signal(SIGALRM, f);
        !           126:                return (1);
        !           127:        }
        !           128:        alarm(number(value(DIALTIMEOUT)));
        !           129:        read(FD, &c, 1);
        !           130:        alarm(0);
        !           131:        signal(SIGALRM, f);
        !           132:        c &= 0177;
        !           133:        return (c != '\r');
        !           134: }
        !           135: 
        !           136: static int
        !           137: detect(s)
        !           138:        register char *s;
        !           139: {
        !           140:        char c;
        !           141:        int (*f)();
        !           142: 
        !           143:        f = signal(SIGALRM, sigALRM);
        !           144:        timeout = 0;
        !           145:        while (*s) {
        !           146:                if (setjmp(timeoutbuf)) {
        !           147:                        biz22_abort();
        !           148:                        break;
        !           149:                }
        !           150:                alarm(number(value(DIALTIMEOUT)));
        !           151:                read(FD, &c, 1);
        !           152:                alarm(0);
        !           153:                c &= 0177;
        !           154:                if (c != *s++)
        !           155:                        return (0);
        !           156:        }
        !           157:        signal(SIGALRM, f);
        !           158:        return (timeout == 0);
        !           159: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.