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

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.