Return to demux.c CVS log

Up to [Research Unix] / researchv9 / jerq / src / mux / term

Annotation of researchv9/jerq/src/mux/term/demux.c, revision 1.1

1.1     ! root        1: #include <jerq.h>
        !             2: #include <layer.h>
        !             3: #include <jioctl.h>
        !             4: #include <queue.h>
        !             5: #include <tty.h>
        !             6: #include "../msgs.h"
        !             7: #include "jerqproc.h"
        !             8: #include "pconfig.h"
        !             9: #include "proto.h"
        !            10: #include "packets.h"
        !            11: 
        !            12: extern struct Proc *kbdproc;
        !            13: extern char *itox();
        !            14: extern short scrltimeout;
        !            15: int rebootflag;
        !            16: 
        !            17: demux(){
        !            18:        while(!rebootflag){
        !            19:                while(RCVQUEUE.c_cc==0)
        !            20:                        sw(0);
        !            21:                precv((char)qgetc(&RCVQUEUE));
        !            22:        }
        !            23:        nap(60);
        !            24:        reboot();
        !            25: }
        !            26: 
        !            27: reboot(){
        !            28:        (*(void (*)())(*(long *)0x71C010))();
        !            29: }
        !            30: int
        !            31: recvchars(l, p, n)
        !            32:        int l;
        !            33:        char *p;
        !            34:        int n;
        !            35: {
        !            36:        register struct Proc *pp;
        !            37:        register char *s;
        !            38:        register unsigned char *cp;
        !            39:        register int i;
        !            40: 
        !            41:        if(l==0){       /* that's me!! */
        !            42:                doctl(p, n);
        !            43:                Pcdata=C_UNBLK; /* only needed for UTS */
        !            44:                return 0;
        !            45:        }
        !            46:        pp= &proctab[l];
        !            47:        if(!(pp->state&BUSY))
        !            48:                return 0;       /* why bother? */
        !            49:        if((i=n)>0){
        !            50:                if(i>(sizeof(pp->cbuf)-pp->nchars))
        !            51:                        return 1;       /* oops! */
        !            52:                cp=pp->cbufpin;
        !            53:                s=p;
        !            54:                do{
        !            55:                        pp->nchars++;
        !            56:                        *cp++= *s++;
        !            57:                        if(cp>=&pp->cbuf[sizeof(pp->cbuf)])
        !            58:                                cp=pp->cbuf;
        !            59:                }while(--i>0);
        !            60:                pp->cbufpin=cp;
        !            61:        }
        !            62:        if(pp->nchars<=CBSIZE && !(pp->state&BLOCKED))
        !            63:                Pcdata=C_UNBLK;
        !            64:        else if(++pconvs[l].user>NPCBUFS)       /* Inc. # of packets blocked */
        !            65:                pconvs[l].user=NPCBUFS;
        !            66:        setrun(pp);
        !            67:        return 0;
        !            68: }
        !            69: 
        !            70: doctl(s, n)
        !            71:        register char *s;
        !            72: {
        !            73:        char cmd=s[0];
        !            74:        register struct Proc *p= &proctab[s[1]];
        !            75:        extern boot(), windowproc();
        !            76:        extern int end;
        !            77: 
        !            78:        switch(cmd){
        !            79:        case JEXIT&0xFF:
        !            80:                Psend(0, (char *)0, 0, C_EXIT);
        !            81:                break;
        !            82:        case JDELETE&0xFF:
        !            83:                delete(p->layer);
        !            84:                break;
        !            85:        case JTTYC:
        !            86:                if(n!=12){      /* sort of sizeof(struct ttycmesg) */
        !            87: #                      ifdef   DEBUG
        !            88:                        error("JTTYC n!=sizeof ttycmesg", itox((unsigned long)n));
        !            89: #                      endif
        !            90:                        return;
        !            91:                }
        !            92:                copyb(&s[2], &p->ttychars, sizeof (struct ttychars));
        !            93:                break;
        !            94:        case JTIMO&0xFF:
        !            95:                if(n<3){
        !            96: #                      ifdef   DEBUG
        !            97:                        error("JTIMO n!=3", itox((unsigned long)n));
        !            98: #                      endif
        !            99:                        return;
        !           100:                }
        !           101:                Prtimeout=s[1];
        !           102:                Pxtimeout=s[2];
        !           103:                scrltimeout=10*s[2];
        !           104:                if(n>3)
        !           105:                        shellproc(s+3, n-3)
;
        !           106:                break;
        !           107:        case JBOOT&0xFF:
        !           108:        case JTERM&0xFF:
        !           109:        case JZOMBOOT&0xFF:
        !           110: #              ifdef   DEBUG
        !           111:                if(n!=2){
        !           112:                        error("doctl n!=2", itox((unsigned long)n));
        !           113:                        return;
        !           114:                }
        !           115: #              endif
        !           116:                if(s[1]==0){    /* i.e. demux */
        !           117:                        rebootflag++;
        !           118:                        break;
        !           119:                }
        !           120:                freemem(p);
        !           121:                shutdown(p);
        !           122:                p->nchars=0;
        !           123:                p->cbufpout = p->cbufpin;
        !           124:                restart(p, cmd==(JTERM&0xFF)? windowproc : boot);
        !           125:                if(cmd==(JZOMBOOT&0xFF))
        !           126:                        p->state|=ZOMBOOT;
        !           127:                setrun(p);
        !           128:                break;
        !           129:        default:
        !           130:                error("unk ctl", itox((unsigned long)cmd));
        !           131:        }
        !           132: }
        !           133: copyb(a, b, n)
        !           134:        register char *a, *b;
        !           135:        register n;
        !           136: {
        !           137:        while(n--)
        !           138:                *b++=*a++;
        !           139: }
        !           140: 
        !           141: #define INSET  3
        !           142: 
        !           143: static char cmd[MAXPKTDSIZE+1]; static int ncmd;
        !           144: 
        !           145: shellproc(s, n)
        !           146:        char *s;
        !           147: {
        !           148:        Rectangle r;
        !           149:        int sendcmd(); register struct Proc *p;
        !           150: 
        !           151:        r.origin.x = XMAX-9-65*9;
        !           152:        r.origin.y = YMAX-9-17*14;
        !           153:        r.corner.x = XMAX-9;
        !           154:        r.corner.y = YMAX-9;
        !           155: 
        !           156:        copyb(s, cmd, ncmd = n);
        !           157:        cmd[ncmd++] = '\n';
        !           158: 
        !           159:        if(p=newproc(sendcmd)){ /* Assignment = */
        !           160:                p->rect=inset(r, INSET);
        !           161:                if(p->layer=newlayer(r)){
        !           162:                        muxnewwind(p, C_NEW);
        !           163:                        tolayer(p->layer);
        !           164:                        setrun(p);
        !           165:                }else
        !           166:                        p->state=0;
        !           167:        }
        !           168: }
        !           169: sendcmd()
        !           170: {
        !           171:        void sendnchars(), sendchar();
        !           172:        rectf((Bitmap *)P->layer, P->rect, F_STORE);
        !           173:        sleep(20);
        !           174:        sendnchars(ncmd, cmd);
        !           175:        delim();
        !           176:        sleep(20);
        !           177:        Uexit();
        !           178: }

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