Return to connld.c CVS log

Up to [Research Unix] / researchv10no / sys / io

Annotation of researchv10no/sys/io/connld.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * connector l.d.:  install on a stream-mounted file.
        !             3:  * Opens on the file send new, unique pipe to the
        !             4:  * server and return the other end of the pipe.
        !             5:  */
        !             6: 
        !             7: #include "sys/param.h"
        !             8: #include "sys/stream.h"
        !             9: #include "sys/filio.h"
        !            10: #include "sys/conf.h"
        !            11: #include "sys/file.h"
        !            12: #include "sys/inode.h"
        !            13: 
        !            14: #define        STIPRI  28
        !            15: long   connopen(), connnull();
        !            16: int    connput(), nulldev(), conngput();
        !            17: 
        !            18: static struct qinit connrinit = { connput, 0, connopen, nulldev, 0, 0 };
        !            19: static struct qinit connwinit = { connput, 0, connopen, nulldev, 0, 0 };
        !            20: struct streamtab connstream = { &connrinit, &connwinit };
        !            21: 
        !            22: static struct qinit connrgrab = { conngput, 0, connnull, nulldev, 0, 0 };
        !            23: static struct qinit connwgrab = { connput, 0, connnull, nulldev, 0, 0 };
        !            24: static struct streamtab connginfo = { &connrgrab, &connwgrab };
        !            25: 
        !            26: long
        !            27: connopen(q, dev)
        !            28: register struct queue *q;
        !            29: {
        !            30:        struct inode *ip1, *ip2;
        !            31:        register struct file *fp, *nfp;
        !            32:        register s;
        !            33:        register struct block *bp;
        !            34:        register struct queue *nq;
        !            35:        register ioc;
        !            36: 
        !            37:        if ((int)q->ptr == 0) {         /* the open on push does nothing */
        !            38:                q->ptr = (caddr_t)1;
        !            39:                return(1);
        !            40:        }
        !            41:        /* make pipe, send one end to other side */
        !            42:        if ((fp = allocfile()) == NULL)
        !            43:                return(0);
        !            44:        if (makepipe(&ip1, &ip2)==0) {
        !            45:                fp->f_count = 0;
        !            46:                return(0);
        !            47:        }
        !            48:        fp->f_inode = ip2;
        !            49:        fp->f_flag = FREAD|FWRITE;
        !            50:        fp->f_count--;
        !            51:        nq = RD(ip1->i_sptr->wrq);
        !            52:        if (sndfile(WR(q), fp)==0) {
        !            53:                stclose(ip1, 1);
        !            54:                iput(ip1);
        !            55:                stclose(ip2, 1);
        !            56:                iput(ip2);
        !            57:                return(0);
        !            58:        }
        !            59:        if (qattach(&connginfo, nq, (dev_t)0)==0) {
        !            60:                stclose(ip1, 1);
        !            61:                iput(ip1);
        !            62:                return(0);
        !            63:        }
        !            64:        nq = backq(nq);
        !            65:        /* wait for reply */
        !            66:        s = spl6();
        !            67:        while ((bp = getq(nq))==NULL) {
        !            68:                if (tsleep((caddr_t)nq, STIPRI, 0) != TS_OK) {
        !            69:                        stclose(ip1, 1);
        !            70:                        iput(ip1);
        !            71:                        return(0);
        !            72:                }
        !            73:        }
        !            74:        splx(s);
        !            75: 
        !            76:        switch(bp->type) {
        !            77: 
        !            78:        case M_HANGUP:
        !            79:                freeb(bp);
        !            80:                stclose(ip1, 1);
        !            81:                iput(ip1);
        !            82:                return(0);
        !            83: 
        !            84:        case M_PASS:    /* accept, and provide a newer file */
        !            85:                stclose(ip1, 1);
        !            86:                iput(ip1);
        !            87:                nfp = ((struct kpassfd *)bp->rptr)->f.fp;
        !            88:                ip1 = nfp->f_inode;
        !            89:                ip1->i_count++;
        !            90:                closef(nfp);
        !            91:                return((long)ip1);
        !            92: 
        !            93:        case M_IOCTL:
        !            94:                ioc = stiocom(bp);
        !            95:                if (ioc==FIOACCEPT || ioc==FIOREJECT) {
        !            96:                        bp->type = M_IOCACK;
        !            97:                        bp->wptr = bp->rptr;
        !            98:                        qreply(nq, bp);
        !            99:                        if (ioc==FIOREJECT) {
        !           100:                                stclose(ip1, 1);
        !           101:                                iput(ip1);
        !           102:                                return(0);
        !           103:                        }
        !           104:                        while (bp = getq(nq))
        !           105:                                (*nq->next->qinfo->putp)(nq->next, bp);
        !           106:                        qdetach(nq, 1);
        !           107:                        return((long)ip1);
        !           108:                }
        !           109:        default:                /* flow through */
        !           110:                (*nq->next->qinfo->putp)(nq->next, bp);
        !           111:                while (bp = getq(nq))
        !           112:                        (*nq->next->qinfo->putp)(nq->next, bp);
        !           113:                qdetach(nq, 1);
        !           114:                return((long)ip1);
        !           115:        }
        !           116: }
        !           117: 
        !           118: /*
        !           119:  * probably needless
        !           120:  */
        !           121: 
        !           122: long
        !           123: connnull()
        !           124: {
        !           125:        return (1);
        !           126: }
        !           127: 
        !           128: connput(q, bp)
        !           129: register struct queue *q;
        !           130: register struct block *bp;
        !           131: {
        !           132:        switch (bp->type) {
        !           133: 
        !           134:        case M_HANGUP:
        !           135:        case M_IOCTL:
        !           136:        case M_IOCACK:
        !           137:        case M_IOCNAK:
        !           138:        case M_PASS:
        !           139:                (*q->next->qinfo->putp)(q->next, bp);
        !           140:                return;
        !           141:        }
        !           142:        freeb(bp);
        !           143: }
        !           144: 
        !           145: conngput(q, bp)
        !           146: register struct queue *q;
        !           147: register struct block *bp;
        !           148: {
        !           149:        putq(q, bp);
        !           150:        wakeup((caddr_t)q);
        !           151: }

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