Return to rfmkpac.c CVS log

Up to [XINU] / xinu / sys

Annotation of xinu/sys/rfmkpac.c, revision 1.1

1.1     ! root        1: /* rfmkpac.c - rfmkpac */
        !             2: 
        !             3: #include <conf.h>
        !             4: #include <kernel.h>
        !             5: #include <network.h>
        !             6: 
        !             7: static struct  fpacket packet;
        !             8: 
        !             9: /*------------------------------------------------------------------------
        !            10:  *  rfmkpac  --  make a remote file request packet and send it
        !            11:  *------------------------------------------------------------------------
        !            12:  */
        !            13: rfmkpac(rop, rname, rpos, buff, len)
        !            14: int    rop;
        !            15: char   *rname;
        !            16: long   *rpos;
        !            17: char   *buff;
        !            18: int    len;
        !            19: {
        !            20:        struct  fphdr   *fptr;
        !            21:        int     reqlen, rplylen;
        !            22: 
        !            23:        wait(Rf.rmutex);
        !            24:        fptr = (struct fphdr *) &packet;
        !            25:        fptr->f_op = hs2net(rop);
        !            26:        fptr->f_pos = hl2net(*rpos);
        !            27:        fptr->f_count = hs2net(len);
        !            28:        strncpy(fptr->f_name, rname, RNAMLEN);
        !            29:        reqlen = rplylen = FPHLEN + len;
        !            30:        switch (rop) {
        !            31: 
        !            32:            case FS_WRITE:
        !            33:            case FS_RENAME:
        !            34:                if (len > RDATLEN) {
        !            35:                        signal(Rf.rmutex);
        !            36:                        return(SYSERR);
        !            37:                        }       
        !            38:                blkcopy(packet.fpdata, buff, len);
        !            39:                rplylen = FPHLEN;
        !            40:                break;
        !            41: 
        !            42:            case FS_CLOSE:
        !            43:            case FS_OPEN:
        !            44:            case FS_UNLINK:
        !            45:            case FS_MKDIR:
        !            46:            case FS_RMDIR:
        !            47:            case FS_ACCESS:
        !            48:                rplylen = FPHLEN;
        !            49:                /* fall through */
        !            50:                
        !            51:            case FS_READ:
        !            52:                if (len > RDATLEN) {
        !            53:                        signal(Rf.rmutex);
        !            54:                        return(SYSERR);
        !            55:                }
        !            56:                reqlen = FPHLEN;
        !            57:                break;
        !            58: 
        !            59:            default:
        !            60:                ;
        !            61:        }
        !            62:        if (rfsend(fptr, reqlen, rplylen) == SYSERR ||
        !            63:            net2hs(fptr->f_op) == FS_ERROR) {
        !            64:                signal(Rf.rmutex);
        !            65:                return(SYSERR);
        !            66:        }
        !            67:        switch (rop) {
        !            68: 
        !            69:            case FS_READ:
        !            70:                blkcopy(buff, packet.fpdata, len);
        !            71:                /* fall through */
        !            72: 
        !            73:            case FS_WRITE:
        !            74:                *rpos = net2hl(fptr->f_pos);
        !            75:                len = net2hs(fptr->f_count);
        !            76:                break;
        !            77: 
        !            78:            default:
        !            79:                len = OK;
        !            80:        }
        !            81:        signal(Rf.rmutex);
        !            82:        return(len);
        !            83: }

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