Return to disp.c CVS log

Up to [Research Unix] / researchv10no / netfs / libnetb

Annotation of researchv10no/netfs/libnetb/disp.c, revision 1.1

1.1     ! root        1: #include "netb.h"
        !             2: #include "nberrno.h"
        !             3: #include "rf.h"
        !             4: 
        !             5: /*
        !             6:  * netb functions
        !             7:  */
        !             8: 
        !             9: static int illcmd();
        !            10: int _rfput(), _rfupdate(), _rfread(), _rfwrite();
        !            11: int _rfnamei(), _rfstat(), _rfdir(), _rftrunc();
        !            12: 
        !            13: static (*functab[])() = {
        !            14:        illcmd,         /* (0) illegal */
        !            15:        _rfput,         /* (1) put */
        !            16:        illcmd,         /* (2) get */
        !            17:        _rfupdate,      /* (3) update */
        !            18:        _rfread,        /* (4) read */
        !            19:        _rfwrite,       /* (5) write */
        !            20:        _rfnamei,       /* (6) namei */
        !            21:        _rfstat,        /* (7) stat */
        !            22:        illcmd,         /* (8) ioctl */
        !            23:        _rftrunc,       /* (9) trunc */
        !            24:        _rfdir, /* (10) dirread */
        !            25: };
        !            26: 
        !            27: #define        MAXCMD  10
        !            28: 
        !            29: /*
        !            30:  * names only for debugging output
        !            31:  */
        !            32: static char *funcnames[] = {
        !            33:        "ill", "put", "get", "upd", "read",
        !            34:        "write", "namei", "stat", "ioctl", "trunc", "dir"
        !            35: };
        !            36: 
        !            37: static char *ninames[] = {
        !            38:        "reg", "del", "creat", "xcreat", "link", "mkdir", "rmdir"
        !            39: };
        !            40: #define        MAXNI   6
        !            41: 
        !            42: extern int cuid, cgid;
        !            43: 
        !            44: static slide();
        !            45: 
        !            46: _rfscan(fd, buf, size)
        !            47: int fd;
        !            48: char *buf;
        !            49: int size;
        !            50: {
        !            51:        register unsigned char *sp;
        !            52:        register int blen, mlen;
        !            53:        register int n, c;
        !            54: 
        !            55:        sp = (unsigned char *)buf;
        !            56:        blen = 0;
        !            57:        for (;;) {
        !            58:                if (blen < SNBSIZE) {
        !            59:                        n = _rfgread(fd, buf+blen, size-blen, SNBSIZE);
        !            60:                        if (n < SNBSIZE)
        !            61:                                break;
        !            62:                        blen += n;
        !            63:                }
        !            64:                c = frnetchar(sp, SNB_CMD);
        !            65:                if (c < 0 || c > MAXCMD)
        !            66:                        c = 0;
        !            67:                mlen = frnetlong(sp, SNB_LEN);
        !            68:                if (rfdebug)
        !            69:                        rflog("%ld: %s: cmd %d tag x%lx flag %d len %ld\n",
        !            70:                                frnetlong(sp, SNB_TRANNUM), funcnames[c],
        !            71:                                frnetchar(sp, SNB_CMD), frnetlong(sp, SNB_TAG),
        !            72:                                frnetchar(sp, SNB_FLAGS), mlen);
        !            73:                if (frnetchar(sp, SNB_VERSION) != NETB)
        !            74:                        rfpanic("ill version: %d\n", frnetchar(sp, SNB_VERSION));
        !            75:                if (mlen > size)
        !            76:                        rfpanic("msg too long: %d\n", mlen);
        !            77:                if (mlen > blen) {
        !            78:                        n = _rfgread(fd, buf+blen, size-blen, mlen-blen);
        !            79:                        if (n < mlen - blen)
        !            80:                                break;
        !            81:                        blen += n;
        !            82:                }
        !            83:                if (rfdebug
        !            84:                &&  c == NBNAMI && frnetchar(sp, SNB_FLAGS) <= MAXNI) {
        !            85:                        rflog("\tnamei: %s '%.*s'\n", ninames[frnetchar(sp, SNB_FLAGS)],
        !            86:                                mlen - SNMSIZE, sp + SNMSIZE);
        !            87:                }
        !            88:                cuid = frnetshort(sp, SNB_UID);
        !            89:                cgid = frnetshort(sp, SNB_GID);
        !            90:                rfuid = _rfsuid(cuid);
        !            91:                rfgid = _rfsgid(cgid);
        !            92:                (*functab[c])(fd, sp, mlen);
        !            93:                blen -= mlen;
        !            94:                if (blen != 0) {        /* leftover stuff in buffer; shouldn't happen */
        !            95:                        rflog("%d bytes excess read\n", blen);
        !            96:                        slide(buf+mlen, n, mlen);
        !            97:                }
        !            98:        }
        !            99:        if (n)
        !           100:                rfpanic("bad read: %d\n", n);
        !           101: }
        !           102: 
        !           103: static
        !           104: slide(buf, len, dist)
        !           105: char *buf;
        !           106: register int len;
        !           107: int dist;
        !           108: {
        !           109:        register char *fr, *to;
        !           110: 
        !           111:        fr = buf;
        !           112:        to = buf - dist;
        !           113:        while (--len >= 0)
        !           114:                *to++ = *fr++;
        !           115: }
        !           116: 
        !           117: static
        !           118: illcmd(fd, sp)
        !           119: int fd;
        !           120: unsigned char *sp;
        !           121: {
        !           122:        unsigned char rbuf[RNBSIZE];
        !           123: 
        !           124:        tonetshort(rbuf, RNB_ERRNO, NBEINVAL);
        !           125:        _rfresp(fd, sp, rbuf, RNBSIZE);
        !           126: }
        !           127: 
        !           128: /*
        !           129:  * send a response
        !           130:  */
        !           131: 
        !           132: _rfresp(fd, sp, rp, len)
        !           133: int fd;
        !           134: register unsigned char *sp, *rp;
        !           135: int len;
        !           136: {
        !           137: 
        !           138:        if (rfdebug)
        !           139:                rflog("\t_rfresp: %ld: errno %d flags %d len %ld\n",
        !           140:                        frnetlong(sp, SNB_TRANNUM), frnetshort(rp, RNB_ERRNO),
        !           141:                        frnetchar(rp, RNB_FLAGS), len);
        !           142:        tonetlong(rp, RNB_TRANNUM, frnetlong(sp, SNB_TRANNUM));
        !           143:        tonetlong(rp, RNB_LEN, len);
        !           144:        if (write(fd, (char *)rp, len) != len)
        !           145:                rfpanic("bad _rfresp write\n", 0);
        !           146: }

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