Return to hys24.c CVS log

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

Annotation of 43BSDReno/usr.bin/uucp/aculib/hys24.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)hys24.c    1.6     (Berkeley) 6/27/90";
        !             3: #endif !lint
        !             4: 
        !             5: #include "../condevs.h"
        !             6: 
        !             7: /*
        !             8:  * hyspopn24(telno, flds, dev) connect to hayes smartmodem (pulse call)
        !             9:  * hystopn24(telno, flds, dev) connect to hayes smartmodem (tone call)
        !            10:  *
        !            11:  * return codes: >0  -  file number  -  ok CF_DIAL,CF_DEVICE  -  failed 
        !            12:  */
        !            13: 
        !            14: #include <sys/file.h>
        !            15: #include <sys/ioctl.h>
        !            16: 
        !            17: hyspopn24(telno, flds, dev)
        !            18: char *telno, *flds[];
        !            19: struct Devices *dev;
        !            20: {
        !            21:        return hysopn24(telno, flds, dev, 0);
        !            22: }
        !            23: 
        !            24: hystopn24(telno, flds, dev)
        !            25: char *telno, *flds[];
        !            26: struct Devices *dev;
        !            27: {
        !            28:        return hysopn24(telno, flds, dev, 1);
        !            29: }
        !            30: 
        !            31: /* ARGSUSED */
        !            32: hysopn24(telno, flds, dev, toneflag)
        !            33: char *telno;
        !            34: char *flds[];
        !            35: struct Devices *dev;
        !            36: int toneflag;
        !            37: {
        !            38:        int dh = -1;
        !            39:        int result, ix, speed;
        !            40:        char *ii;
        !            41:        extern errno;
        !            42:        char dcname[20];
        !            43:        char resultbuf[16];
        !            44: 
        !            45:        sprintf(dcname, "/dev/%s", dev->D_line);
        !            46:        DEBUG(4, "dc - %s\n", dcname);
        !            47:        if (setjmp(Sjbuf)) {
        !            48:                logent(dcname, "TIMEOUT");
        !            49:                if (dh >= 0)
        !            50:                        hyscls24(dh, 0);
        !            51:                return CF_DIAL;
        !            52:        }
        !            53:        signal(SIGALRM, alarmtr);
        !            54:        getnextfd();
        !            55:        alarm(10);
        !            56:        dh = open(dcname, 2);   /* read/write */
        !            57:        alarm(0);
        !            58: 
        !            59:        for (ii = telno; *ii; ii++)
        !            60:                if (*ii == '=')
        !            61:                        *ii = ',';
        !            62: 
        !            63:        /* modem is open */
        !            64:        next_fd = -1;
        !            65:        if (dh >= 0) {
        !            66:                ioctl(dh, TIOCHPCL, 0);
        !            67:                fixline(dh, dev->D_speed);
        !            68:                if (dochat(dev, flds, dh)) {
        !            69:                        logent(dcname, "CHAT FAILED");
        !            70:                        hyscls24(dh, 0);
        !            71:                        return CF_DIAL;
        !            72:                }
        !            73:                hyscls24(dh, 1);/* make sure the line is reset */
        !            74:                write(dh, "AT&F&D3&C1E0M0X3QV0Y\r", 21);
        !            75:                if (expect("0\r", dh) != 0) {
        !            76:                        logent(dcname, "HSM not responding OK");
        !            77:                        hyscls24(dh, 0);
        !            78:                        return CF_DIAL;
        !            79:                }
        !            80:                if (toneflag)
        !            81:                        write(dh, "\rATDT", 5);
        !            82:                else
        !            83:                        write(dh, "\rATDP", 5);
        !            84:                write(dh, telno, strlen(telno));
        !            85:                write(dh, "\r", 1);
        !            86: 
        !            87:                if (setjmp(Sjbuf)) {
        !            88:                        logent(dcname, "Modem Hung");
        !            89:                        if (dh >= 0)
        !            90:                                hyscls24(dh, 0);
        !            91:                        return CF_DIAL;
        !            92:                }
        !            93:                signal(SIGALRM, alarmtr);
        !            94:                alarm(120);
        !            95:                do {
        !            96:                        for (ix = 0; ix < 16; ix++) {
        !            97:                                read(dh, resultbuf + ix, 1);
        !            98:                                DEBUG(6, "character read = 0x%X \n", resultbuf[ix]);
        !            99:                                if ((0x7f & resultbuf[ix]) == 0xd)
        !           100:                                        break;
        !           101:                        }
        !           102: 
        !           103:                        result = atol(resultbuf);
        !           104:                        switch (result) {
        !           105:                        case 0:
        !           106:                                logent("HSM Spurious OK response", _FAILED);
        !           107:                                speed = 0;
        !           108:                                break;
        !           109:                        case 1:
        !           110:                                logent("HSM connected at 300 baud!", _FAILED);
        !           111:                                speed = -1;
        !           112:                                break;
        !           113:                        case 2:
        !           114:                                speed = 0;
        !           115:                                DEBUG(4, "Ringing", 0);
        !           116:                                break;
        !           117:                        case 3:
        !           118:                                logent("HSM No Carrier", _FAILED);
        !           119:                                speed = -1;
        !           120:                                break;
        !           121:                        case 4:
        !           122:                                logent("HSM Error", _FAILED);
        !           123:                                speed = -1;
        !           124:                                break;
        !           125:                        case 5:
        !           126:                                speed = 1200;
        !           127:                                break;
        !           128:                        case 6:
        !           129:                                logent("HSM No dialtone", _FAILED);
        !           130:                                speed = -1;
        !           131:                                break;
        !           132:                        case 7:
        !           133:                                logent("HSM detected BUSY", _FAILED);
        !           134:                                speed = -1;
        !           135:                                break;
        !           136:                        case 8:
        !           137:                                logent("HSM No quiet answer", _FAILED);
        !           138:                                speed = -1;
        !           139:                                break;
        !           140:                        case 10:
        !           141:                                speed = 2400;
        !           142:                                break;
        !           143:                        default:
        !           144:                                logent("HSM Unknown response", _FAILED);
        !           145:                                speed = -1;
        !           146:                                break;
        !           147:                        }
        !           148: 
        !           149:                } while (speed == 0);
        !           150: 
        !           151:                alarm(0);
        !           152: 
        !           153:                if (speed < 0) {
        !           154:                        strcpy(devSel, dev->D_line);
        !           155:                        hyscls24(dh, 0);
        !           156:                        return CF_DIAL;
        !           157:                } else if (speed != dev->D_speed) {
        !           158:                        DEBUG(4, "changing line speed to %d baud\n", speed);
        !           159:                        fixline(dh, speed);
        !           160:                }
        !           161:        }
        !           162:        if (dh < 0) {
        !           163:                logent(dcname, "CAN'T OPEN");
        !           164:                return dh;
        !           165:        }
        !           166:        DEBUG(4, "hayes ok\n", CNULL);
        !           167:        return dh;
        !           168: }
        !           169: 
        !           170: hyscls24(fd, flag)
        !           171: int fd, flag;
        !           172: {
        !           173:        char dcname[20];
        !           174:        int fff = 1;
        !           175: 
        !           176:        if (fd > 0) {
        !           177:                sprintf(dcname, "/dev/%s", devSel);
        !           178:                if (flag)
        !           179:                        DEBUG(4, "Resetting fd = %d\n", fd);
        !           180:                else
        !           181:                        DEBUG(4, "Hanging up fd = %d\n", fd);
        !           182:                /*
        !           183:                 * Since we have a getty sleeping on this line, when it wakes
        !           184:                 * up it sends all kinds of garbage to the modem. 
        !           185:                 * Unfortunatly, the modem likes to execute the previous
        !           186:                 * command when it sees the garbage.  The previous command
        !           187:                 * was to dial the phone, so let's make the last command
        !           188:                 * reset the modem. 
        !           189:                 */
        !           190:                if (!flag)
        !           191:                        fixline(fd, 2400);
        !           192:                write(fd, "\r", 1);
        !           193:                sleep(2);
        !           194:                write(fd, "+++", 3);
        !           195:                sleep(3);
        !           196:                write(fd, "\rATH\rATZ\r", 9);
        !           197:                sleep(2);
        !           198:                ioctl(fd, TIOCFLUSH, &fff);
        !           199: 
        !           200:                if (!flag) {
        !           201:                        close(fd);
        !           202:                        delock(devSel);
        !           203:                }
        !           204:        }
        !           205: }

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