Return to async.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / 9 / boot

Annotation of lucent/sys/src/9/boot/async.c, revision 1.1

1.1     ! root        1: #include <u.h>
        !             2: #include <libc.h>
        !             3: #include <../boot/boot.h>
        !             4: 
        !             5: static void    configasync(char*, char*);
        !             6: static void    connect(int, int);
        !             7: static void    kill(int);
        !             8: 
        !             9: void
        !            10: config9600(Method *mp)
        !            11: {
        !            12:        configasync("B9600", mp->arg);
        !            13: }
        !            14: 
        !            15: int
        !            16: auth9600(void)
        !            17: {
        !            18:        return dkauth();
        !            19: }
        !            20: 
        !            21: int
        !            22: connect9600(void)
        !            23: {
        !            24:        return dkconnect();
        !            25: }
        !            26: 
        !            27: void
        !            28: config19200(Method *mp)
        !            29: {
        !            30:        configasync("B19200", mp->arg);
        !            31: }
        !            32: 
        !            33: int
        !            34: auth19200(void)
        !            35: {
        !            36:        return dkauth();
        !            37: }
        !            38: 
        !            39: int
        !            40: connect19200(void)
        !            41: {
        !            42:        return dkconnect();
        !            43: }
        !            44: 
        !            45: 
        !            46: static void
        !            47: configasync(char *baud, char *dev)
        !            48: {
        !            49:        int cfd, dfd;
        !            50:        char devname[NAMELEN];
        !            51:        char eianame[NAMELEN];
        !            52:        char port[5];
        !            53: 
        !            54:        if(*sys == '/' || *sys == '#')
        !            55:                dev = sys;
        !            56:        else if(dev == 0)
        !            57:                dev = "#t/eia0";
        !            58:        if(readfile("#e/modemport", port, sizeof(port)) == 0){
        !            59:                sprint(devname, "#t/eia%d", atoi(port));
        !            60:                dev = devname;
        !            61:        }
        !            62:        sprint(eianame, "%sctl", dev);
        !            63:        cfd = open(eianame, ORDWR);
        !            64:        if(cfd < 0)
        !            65:                fatal(eianame);
        !            66:        sendmsg(cfd, baud);
        !            67: 
        !            68:        sprint(eianame, "%s", dev);
        !            69:        dfd = open(eianame, ORDWR);
        !            70:        if(dfd < 0)
        !            71:                fatal(eianame);
        !            72:        connect(dfd, cfd);
        !            73:        close(dfd);
        !            74:        sendmsg(cfd, "push async");
        !            75:        sendmsg(cfd, "push dkmux");
        !            76:        sendmsg(cfd, "config 1 16 restart dk 4");
        !            77:        close(cfd);
        !            78: }
        !            79: 
        !            80: enum
        !            81: {
        !            82:        CtrlD   = 0x4,
        !            83:        CtrlE   = 0x5,
        !            84:        CtrlO   = 0xf,
        !            85:        Cr      = 13,
        !            86:        View    = 0x80,
        !            87: };
        !            88: 
        !            89: static void
        !            90: connect(int fd, int cfd)
        !            91: {
        !            92:        char xbuf[128];
        !            93:        int i, pid, n, ctl;
        !            94: 
        !            95:        print("Connect to file system now, type ctrl-d when done.\n");
        !            96:        print("...(Use the view or down arrow key to send a break)\n");
        !            97:        print("...(Use ctrl-e to set even parity or ctrl-o for odd)\n");
        !            98: 
        !            99:        switch(pid = fork()) {
        !           100:        case -1:
        !           101:                fatal("fork failed");
        !           102:        case 0:
        !           103:                for(;;) {
        !           104:                        n = read(fd, xbuf, sizeof(xbuf));
        !           105:                        if(n < 0) {
        !           106:                                errstr(xbuf);
        !           107:                                print("[remote read error (%s)]\n", xbuf);
        !           108:                                for(;;);
        !           109:                        }
        !           110:                        for(i = 0; i < n; i++)
        !           111:                                if(xbuf[i] == Cr)
        !           112:                                        xbuf[i] = ' ';
        !           113:                        write(1, xbuf, n);
        !           114:                }
        !           115:                break;
        !           116:        default:
        !           117:                ctl = open("#c/consctl", OWRITE);
        !           118:                if(ctl < 0)
        !           119:                        fatal("opening consctl");
        !           120:                write(ctl, "rawon", 5);
        !           121: 
        !           122:                for(;;){
        !           123:                        read(0, xbuf, 1);
        !           124:                        switch(xbuf[0]&0xff) {
        !           125:                        case CtrlD:     /* done */
        !           126:                                kill(pid);
        !           127:                                close(ctl);
        !           128:                                return;
        !           129:                        case CtrlE:     /* set even parity */
        !           130:                                write(cfd, "pe", 2);
        !           131:                                break;
        !           132:                        case CtrlO:     /* set odd parity */
        !           133:                                write(cfd, "po", 2);
        !           134:                                break;
        !           135:                        case View:      /* send a break */
        !           136:                                write(cfd, "k250", 4);
        !           137:                                break;
        !           138:                        default:
        !           139:                                n = write(fd, xbuf, 1);
        !           140:                                if(n < 0) {
        !           141:                                        errstr(xbuf);
        !           142:                                        kill(pid);
        !           143:                                        close(ctl);
        !           144:                                        print("[remote write error (%s)]\n", xbuf);
        !           145:                                }
        !           146:                        }
        !           147:                }
        !           148:        }
        !           149: }
        !           150: 
        !           151: static void
        !           152: kill(int pid)
        !           153: {
        !           154:        char xbuf[32];
        !           155:        int f;
        !           156: 
        !           157:        sprint(xbuf, "#p/%d/note", pid);
        !           158:        f = open(xbuf, OWRITE);
        !           159:        write(f, "die", 3);
        !           160:        close(f);
        !           161: }

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