@jsonjoy.com/json-pack 1.17.0 → 1.19.0

package/lib/nfs/v4/Nfsv4Decoder.js

@@ -0,0 +1,884 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Nfsv4Decoder = void 0;
+const tslib_1 = require("tslib");
+const Reader_1 = require("@jsonjoy.com/buffers/lib/Reader");
+const XdrDecoder_1 = require("../../xdr/XdrDecoder");
+const errors_1 = require("./errors");
+const msg = tslib_1.__importStar(require("./messages"));
+const structs = tslib_1.__importStar(require("./structs"));
+class Nfsv4Decoder {
+    constructor(reader = new Reader_1.Reader()) {
+        this.xdr = new XdrDecoder_1.XdrDecoder(reader);
+    }
+    decodeCompound(reader, isRequest) {
+        this.xdr.reader = reader;
+        const startPos = reader.x;
+        try {
+            if (isRequest) {
+                return this.decodeCompoundRequest();
+            }
+            else {
+                return this.decodeCompoundResponse();
+            }
+        }
+        catch (err) {
+            if (err instanceof RangeError) {
+                reader.x = startPos;
+                return undefined;
+            }
+            throw err;
+        }
+    }
+    decodeCompoundRequest() {
+        const xdr = this.xdr;
+        const tag = xdr.readString();
+        const minorversion = xdr.readUnsignedInt();
+        const argarray = [];
+        const count = xdr.readUnsignedInt();
+        for (let i = 0; i < count; i++) {
+            const op = xdr.readUnsignedInt();
+            const request = this.decodeRequest(op);
+            if (request)
+                argarray.push(request);
+        }
+        return new msg.Nfsv4CompoundRequest(tag, minorversion, argarray);
+    }
+    decodeCompoundResponse() {
+        const xdr = this.xdr;
+        const status = xdr.readUnsignedInt();
+        const tag = xdr.readString();
+        const resarray = [];
+        const count = xdr.readUnsignedInt();
+        for (let i = 0; i < count; i++) {
+            const op = xdr.readUnsignedInt();
+            const response = this.decodeResponse(op);
+            if (response)
+                resarray.push(response);
+        }
+        return new msg.Nfsv4CompoundResponse(status, tag, resarray);
+    }
+    decodeRequest(op) {
+        switch (op) {
+            case 3:
+                return this.decodeAccessRequest();
+            case 4:
+                return this.decodeCloseRequest();
+            case 5:
+                return this.decodeCommitRequest();
+            case 6:
+                return this.decodeCreateRequest();
+            case 7:
+                return this.decodeDelegpurgeRequest();
+            case 8:
+                return this.decodeDelegreturnRequest();
+            case 9:
+                return this.decodeGetattrRequest();
+            case 10:
+                return this.decodeGetfhRequest();
+            case 11:
+                return this.decodeLinkRequest();
+            case 12:
+                return this.decodeLockRequest();
+            case 13:
+                return this.decodeLocktRequest();
+            case 14:
+                return this.decodeLockuRequest();
+            case 15:
+                return this.decodeLookupRequest();
+            case 16:
+                return this.decodeLookuppRequest();
+            case 17:
+                return this.decodeNverifyRequest();
+            case 18:
+                return this.decodeOpenRequest();
+            case 19:
+                return this.decodeOpenattrRequest();
+            case 20:
+                return this.decodeOpenConfirmRequest();
+            case 21:
+                return this.decodeOpenDowngradeRequest();
+            case 22:
+                return this.decodePutfhRequest();
+            case 23:
+                return this.decodePutpubfhRequest();
+            case 24:
+                return this.decodePutrootfhRequest();
+            case 25:
+                return this.decodeReadRequest();
+            case 26:
+                return this.decodeReaddirRequest();
+            case 27:
+                return this.decodeReadlinkRequest();
+            case 28:
+                return this.decodeRemoveRequest();
+            case 29:
+                return this.decodeRenameRequest();
+            case 30:
+                return this.decodeRenewRequest();
+            case 31:
+                return this.decodeRestorefhRequest();
+            case 32:
+                return this.decodeSavefhRequest();
+            case 33:
+                return this.decodeSecinfoRequest();
+            case 34:
+                return this.decodeSetattrRequest();
+            case 35:
+                return this.decodeSetclientidRequest();
+            case 36:
+                return this.decodeSetclientidConfirmRequest();
+            case 37:
+                return this.decodeVerifyRequest();
+            case 38:
+                return this.decodeWriteRequest();
+            case 39:
+                return this.decodeReleaseLockOwnerRequest();
+            case 10044:
+                return this.decodeIllegalRequest();
+            default:
+                throw new errors_1.Nfsv4DecodingError(`Unknown operation: ${op}`);
+        }
+    }
+    decodeResponse(op) {
+        switch (op) {
+            case 3:
+                return this.decodeAccessResponse();
+            case 4:
+                return this.decodeCloseResponse();
+            case 5:
+                return this.decodeCommitResponse();
+            case 6:
+                return this.decodeCreateResponse();
+            case 7:
+                return this.decodeDelegpurgeResponse();
+            case 8:
+                return this.decodeDelegreturnResponse();
+            case 9:
+                return this.decodeGetattrResponse();
+            case 10:
+                return this.decodeGetfhResponse();
+            case 11:
+                return this.decodeLinkResponse();
+            case 12:
+                return this.decodeLockResponse();
+            case 13:
+                return this.decodeLocktResponse();
+            case 14:
+                return this.decodeLockuResponse();
+            case 15:
+                return this.decodeLookupResponse();
+            case 16:
+                return this.decodeLookuppResponse();
+            case 17:
+                return this.decodeNverifyResponse();
+            case 18:
+                return this.decodeOpenResponse();
+            case 19:
+                return this.decodeOpenattrResponse();
+            case 20:
+                return this.decodeOpenConfirmResponse();
+            case 21:
+                return this.decodeOpenDowngradeResponse();
+            case 22:
+                return this.decodePutfhResponse();
+            case 23:
+                return this.decodePutpubfhResponse();
+            case 24:
+                return this.decodePutrootfhResponse();
+            case 25:
+                return this.decodeReadResponse();
+            case 26:
+                return this.decodeReaddirResponse();
+            case 27:
+                return this.decodeReadlinkResponse();
+            case 28:
+                return this.decodeRemoveResponse();
+            case 29:
+                return this.decodeRenameResponse();
+            case 30:
+                return this.decodeRenewResponse();
+            case 31:
+                return this.decodeRestorefhResponse();
+            case 32:
+                return this.decodeSavefhResponse();
+            case 33:
+                return this.decodeSecinfoResponse();
+            case 34:
+                return this.decodeSetattrResponse();
+            case 35:
+                return this.decodeSetclientidResponse();
+            case 36:
+                return this.decodeSetclientidConfirmResponse();
+            case 37:
+                return this.decodeVerifyResponse();
+            case 38:
+                return this.decodeWriteResponse();
+            case 39:
+                return this.decodeReleaseLockOwnerResponse();
+            case 10044:
+                return this.decodeIllegalResponse();
+            default:
+                throw new errors_1.Nfsv4DecodingError(`Unknown operation: ${op}`);
+        }
+    }
+    readFh() {
+        const data = this.xdr.readVarlenOpaque();
+        return new structs.Nfsv4Fh(data);
+    }
+    readVerifier() {
+        const data = this.xdr.readOpaque(8);
+        return new structs.Nfsv4Verifier(data);
+    }
+    readTime() {
+        const xdr = this.xdr;
+        const seconds = xdr.readHyper();
+        const nseconds = xdr.readUnsignedInt();
+        return new structs.Nfsv4Time(seconds, nseconds);
+    }
+    readStateid() {
+        const xdr = this.xdr;
+        const seqid = xdr.readUnsignedInt();
+        const other = xdr.readOpaque(12);
+        return new structs.Nfsv4Stateid(seqid, other);
+    }
+    readBitmap() {
+        const xdr = this.xdr;
+        const count = xdr.readUnsignedInt();
+        const mask = [];
+        for (let i = 0; i < count; i++)
+            mask.push(xdr.readUnsignedInt());
+        return new structs.Nfsv4Bitmap(mask);
+    }
+    readFattr() {
+        const attrmask = this.readBitmap();
+        const attrVals = this.xdr.readVarlenOpaque();
+        return new structs.Nfsv4Fattr(attrmask, attrVals);
+    }
+    readChangeInfo() {
+        const xdr = this.xdr;
+        const atomic = xdr.readBoolean();
+        const before = xdr.readUnsignedHyper();
+        const after = xdr.readUnsignedHyper();
+        return new structs.Nfsv4ChangeInfo(atomic, before, after);
+    }
+    readClientAddr() {
+        const xdr = this.xdr;
+        const rNetid = xdr.readString();
+        const rAddr = xdr.readString();
+        return new structs.Nfsv4ClientAddr(rNetid, rAddr);
+    }
+    readCbClient() {
+        const cbProgram = this.xdr.readUnsignedInt();
+        const cbLocation = this.readClientAddr();
+        return new structs.Nfsv4CbClient(cbProgram, cbLocation);
+    }
+    readClientId() {
+        const verifier = this.readVerifier();
+        const id = this.xdr.readVarlenOpaque();
+        return new structs.Nfsv4ClientId(verifier, id);
+    }
+    readOpenOwner() {
+        const xdr = this.xdr;
+        const clientid = xdr.readUnsignedHyper();
+        const owner = xdr.readVarlenOpaque();
+        return new structs.Nfsv4OpenOwner(clientid, owner);
+    }
+    readLockOwner() {
+        const xdr = this.xdr;
+        const clientid = xdr.readUnsignedHyper();
+        const owner = xdr.readVarlenOpaque();
+        return new structs.Nfsv4LockOwner(clientid, owner);
+    }
+    readOpenToLockOwner() {
+        const xdr = this.xdr;
+        const openSeqid = xdr.readUnsignedInt();
+        const openStateid = this.readStateid();
+        const lockSeqid = xdr.readUnsignedInt();
+        const lockOwner = this.readLockOwner();
+        return new structs.Nfsv4OpenToLockOwner(openSeqid, openStateid, lockSeqid, lockOwner);
+    }
+    readLockOwnerInfo() {
+        const xdr = this.xdr;
+        const newLockOwner = xdr.readBoolean();
+        if (newLockOwner) {
+            const openToLockOwner = this.readOpenToLockOwner();
+            return new structs.Nfsv4LockOwnerInfo(true, new structs.Nfsv4LockNewOwner(openToLockOwner));
+        }
+        else {
+            const lockStateid = this.readStateid();
+            const lockSeqid = xdr.readUnsignedInt();
+            return new structs.Nfsv4LockOwnerInfo(false, new structs.Nfsv4LockExistingOwner(lockStateid, lockSeqid));
+        }
+    }
+    readOpenClaim() {
+        const xdr = this.xdr;
+        const claimType = xdr.readUnsignedInt();
+        switch (claimType) {
+            case 0: {
+                const file = xdr.readString();
+                return new structs.Nfsv4OpenClaim(claimType, new structs.Nfsv4OpenClaimNull(file));
+            }
+            case 1: {
+                const delegateType = xdr.readUnsignedInt();
+                return new structs.Nfsv4OpenClaim(claimType, new structs.Nfsv4OpenClaimPrevious(delegateType));
+            }
+            case 2: {
+                const delegateStateid = this.readStateid();
+                const file = xdr.readString();
+                return new structs.Nfsv4OpenClaim(claimType, new structs.Nfsv4OpenClaimDelegateCur(delegateStateid, file));
+            }
+            case 3: {
+                const file = xdr.readString();
+                return new structs.Nfsv4OpenClaim(claimType, new structs.Nfsv4OpenClaimDelegatePrev(file));
+            }
+            default:
+                throw new errors_1.Nfsv4DecodingError(`Unknown open claim type: ${claimType}`);
+        }
+    }
+    readOpenDelegation() {
+        const xdr = this.xdr;
+        const delegationType = xdr.readUnsignedInt();
+        switch (delegationType) {
+            case 0:
+                return new structs.Nfsv4OpenDelegation(delegationType);
+            case 1: {
+                const stateid = this.readStateid();
+                const recall = xdr.readBoolean();
+                const aceCount = xdr.readUnsignedInt();
+                const permissions = [];
+                for (let i = 0; i < aceCount; i++) {
+                    permissions.push(this.readAce());
+                }
+                return new structs.Nfsv4OpenDelegation(delegationType, new structs.Nfsv4OpenReadDelegation(stateid, recall, permissions));
+            }
+            case 2: {
+                const stateid = this.readStateid();
+                const recall = xdr.readBoolean();
+                const spaceLimit = xdr.readUnsignedHyper();
+                const aceCount = xdr.readUnsignedInt();
+                const permissions = [];
+                for (let i = 0; i < aceCount; i++) {
+                    permissions.push(this.readAce());
+                }
+                return new structs.Nfsv4OpenDelegation(delegationType, new structs.Nfsv4OpenWriteDelegation(stateid, recall, spaceLimit, permissions));
+            }
+            default:
+                throw new errors_1.Nfsv4DecodingError(`Unknown delegation type: ${delegationType}`);
+        }
+    }
+    readAce() {
+        const xdr = this.xdr;
+        const type = xdr.readUnsignedInt();
+        const flag = xdr.readUnsignedInt();
+        const accessMask = xdr.readUnsignedInt();
+        const who = xdr.readString();
+        return new structs.Nfsv4Ace(type, flag, accessMask, who);
+    }
+    readSecInfoFlavor() {
+        const xdr = this.xdr;
+        const flavor = xdr.readUnsignedInt();
+        if (flavor === 6) {
+            const oid = xdr.readVarlenOpaque();
+            const qop = xdr.readUnsignedInt();
+            const service = xdr.readUnsignedInt();
+            const flavorInfo = new structs.Nfsv4RpcSecGssInfo(oid, qop, service);
+            return new structs.Nfsv4SecInfoFlavor(flavor, flavorInfo);
+        }
+        return new structs.Nfsv4SecInfoFlavor(flavor);
+    }
+    decodeAccessRequest() {
+        const access = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4AccessRequest(access);
+    }
+    decodeAccessResponse() {
+        const xdr = this.xdr;
+        const status = xdr.readUnsignedInt();
+        if (status === 0) {
+            const supported = xdr.readUnsignedInt();
+            const access = xdr.readUnsignedInt();
+            return new msg.Nfsv4AccessResponse(status, new msg.Nfsv4AccessResOk(supported, access));
+        }
+        return new msg.Nfsv4AccessResponse(status);
+    }
+    decodeCloseRequest() {
+        const xdr = this.xdr;
+        const seqid = xdr.readUnsignedInt();
+        const openStateid = this.readStateid();
+        return new msg.Nfsv4CloseRequest(seqid, openStateid);
+    }
+    decodeCloseResponse() {
+        const status = this.xdr.readUnsignedInt();
+        if (status === 0) {
+            const openStateid = this.readStateid();
+            return new msg.Nfsv4CloseResponse(status, new msg.Nfsv4CloseResOk(openStateid));
+        }
+        return new msg.Nfsv4CloseResponse(status);
+    }
+    decodeCommitRequest() {
+        const xdr = this.xdr;
+        const offset = xdr.readUnsignedHyper();
+        const count = xdr.readUnsignedInt();
+        return new msg.Nfsv4CommitRequest(offset, count);
+    }
+    decodeCommitResponse() {
+        const status = this.xdr.readUnsignedInt();
+        if (status === 0) {
+            const writeverf = this.readVerifier();
+            return new msg.Nfsv4CommitResponse(status, new msg.Nfsv4CommitResOk(writeverf));
+        }
+        return new msg.Nfsv4CommitResponse(status);
+    }
+    decodeCreateRequest() {
+        const xdr = this.xdr;
+        const type = xdr.readUnsignedInt();
+        let objtype;
+        const objname = xdr.readString();
+        const createattrs = this.readFattr();
+        switch (type) {
+            case 5: {
+                const linkdata = xdr.readString();
+                objtype = new structs.Nfsv4CreateType(type, new structs.Nfsv4CreateTypeLink(linkdata, createattrs));
+                break;
+            }
+            case 3:
+            case 4: {
+                const specdata1 = xdr.readUnsignedInt();
+                const specdata2 = xdr.readUnsignedInt();
+                const devdata = new structs.Nfsv4SpecData(specdata1, specdata2);
+                objtype = new structs.Nfsv4CreateType(type, new structs.Nfsv4CreateTypeDevice(devdata, createattrs));
+                break;
+            }
+            default:
+                objtype = new structs.Nfsv4CreateType(type, new structs.Nfsv4CreateTypeOther(createattrs));
+        }
+        return new msg.Nfsv4CreateRequest(objtype, objname);
+    }
+    decodeCreateResponse() {
+        const status = this.xdr.readUnsignedInt();
+        if (status === 0) {
+            const cinfo = this.readChangeInfo();
+            const attrset = this.readBitmap();
+            return new msg.Nfsv4CreateResponse(status, new msg.Nfsv4CreateResOk(cinfo, attrset));
+        }
+        return new msg.Nfsv4CreateResponse(status);
+    }
+    decodeDelegpurgeRequest() {
+        const clientid = this.xdr.readUnsignedHyper();
+        return new msg.Nfsv4DelegpurgeRequest(clientid);
+    }
+    decodeDelegpurgeResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4DelegpurgeResponse(status);
+    }
+    decodeDelegreturnRequest() {
+        const delegStateid = this.readStateid();
+        return new msg.Nfsv4DelegreturnRequest(delegStateid);
+    }
+    decodeDelegreturnResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4DelegreturnResponse(status);
+    }
+    decodeGetattrRequest() {
+        const attrRequest = this.readBitmap();
+        return new msg.Nfsv4GetattrRequest(attrRequest);
+    }
+    decodeGetattrResponse() {
+        const status = this.xdr.readUnsignedInt();
+        if (status === 0) {
+            const objAttributes = this.readFattr();
+            return new msg.Nfsv4GetattrResponse(status, new msg.Nfsv4GetattrResOk(objAttributes));
+        }
+        return new msg.Nfsv4GetattrResponse(status);
+    }
+    decodeGetfhRequest() {
+        return new msg.Nfsv4GetfhRequest();
+    }
+    decodeGetfhResponse() {
+        const status = this.xdr.readUnsignedInt();
+        if (status === 0) {
+            const object = this.readFh();
+            return new msg.Nfsv4GetfhResponse(status, new msg.Nfsv4GetfhResOk(object));
+        }
+        return new msg.Nfsv4GetfhResponse(status);
+    }
+    decodeLinkRequest() {
+        const newname = this.xdr.readString();
+        return new msg.Nfsv4LinkRequest(newname);
+    }
+    decodeLinkResponse() {
+        const status = this.xdr.readUnsignedInt();
+        if (status === 0) {
+            const cinfo = this.readChangeInfo();
+            return new msg.Nfsv4LinkResponse(status, new msg.Nfsv4LinkResOk(cinfo));
+        }
+        return new msg.Nfsv4LinkResponse(status);
+    }
+    decodeLockRequest() {
+        const xdr = this.xdr;
+        const locktype = xdr.readUnsignedInt();
+        const reclaim = xdr.readBoolean();
+        const offset = xdr.readUnsignedHyper();
+        const length = xdr.readUnsignedHyper();
+        const locker = this.readLockOwnerInfo();
+        return new msg.Nfsv4LockRequest(locktype, reclaim, offset, length, locker);
+    }
+    decodeLockResponse() {
+        const xdr = this.xdr;
+        const status = xdr.readUnsignedInt();
+        if (status === 0) {
+            const lockStateid = this.readStateid();
+            return new msg.Nfsv4LockResponse(status, new msg.Nfsv4LockResOk(lockStateid));
+        }
+        else if (status === 10010) {
+            const offset = xdr.readUnsignedHyper();
+            const length = xdr.readUnsignedHyper();
+            const locktype = xdr.readUnsignedInt();
+            const owner = this.readLockOwner();
+            return new msg.Nfsv4LockResponse(status, undefined, new msg.Nfsv4LockResDenied(offset, length, locktype, owner));
+        }
+        return new msg.Nfsv4LockResponse(status);
+    }
+    decodeLocktRequest() {
+        const xdr = this.xdr;
+        const locktype = xdr.readUnsignedInt();
+        const offset = xdr.readUnsignedHyper();
+        const length = xdr.readUnsignedHyper();
+        const owner = this.readLockOwner();
+        return new msg.Nfsv4LocktRequest(locktype, offset, length, owner);
+    }
+    decodeLocktResponse() {
+        const xdr = this.xdr;
+        const status = xdr.readUnsignedInt();
+        if (status === 10010) {
+            const offset = xdr.readUnsignedHyper();
+            const length = xdr.readUnsignedHyper();
+            const locktype = xdr.readUnsignedInt();
+            const owner = this.readLockOwner();
+            return new msg.Nfsv4LocktResponse(status, new msg.Nfsv4LocktResDenied(offset, length, locktype, owner));
+        }
+        return new msg.Nfsv4LocktResponse(status);
+    }
+    decodeLockuRequest() {
+        const xdr = this.xdr;
+        const locktype = xdr.readUnsignedInt();
+        const seqid = xdr.readUnsignedInt();
+        const lockStateid = this.readStateid();
+        const offset = xdr.readUnsignedHyper();
+        const length = xdr.readUnsignedHyper();
+        return new msg.Nfsv4LockuRequest(locktype, seqid, lockStateid, offset, length);
+    }
+    decodeLockuResponse() {
+        const status = this.xdr.readUnsignedInt();
+        if (status === 0) {
+            const lockStateid = this.readStateid();
+            return new msg.Nfsv4LockuResponse(status, new msg.Nfsv4LockuResOk(lockStateid));
+        }
+        return new msg.Nfsv4LockuResponse(status);
+    }
+    decodeLookupRequest() {
+        const objname = this.xdr.readString();
+        return new msg.Nfsv4LookupRequest(objname);
+    }
+    decodeLookupResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4LookupResponse(status);
+    }
+    decodeLookuppRequest() {
+        return new msg.Nfsv4LookuppRequest();
+    }
+    decodeLookuppResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4LookuppResponse(status);
+    }
+    decodeNverifyRequest() {
+        const objAttributes = this.readFattr();
+        return new msg.Nfsv4NverifyRequest(objAttributes);
+    }
+    decodeNverifyResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4NverifyResponse(status);
+    }
+    decodeOpenRequest() {
+        const xdr = this.xdr;
+        const seqid = xdr.readUnsignedInt();
+        const shareAccess = xdr.readUnsignedInt();
+        const shareDeny = xdr.readUnsignedInt();
+        const owner = this.readOpenOwner();
+        const openhow = xdr.readUnsignedInt();
+        const claim = this.readOpenClaim();
+        return new msg.Nfsv4OpenRequest(seqid, shareAccess, shareDeny, owner, openhow, claim);
+    }
+    decodeOpenResponse() {
+        const xdr = this.xdr;
+        const status = xdr.readUnsignedInt();
+        if (status === 0) {
+            const stateid = this.readStateid();
+            const cinfo = this.readChangeInfo();
+            const rflags = xdr.readUnsignedInt();
+            const attrset = this.readBitmap();
+            const delegation = this.readOpenDelegation();
+            return new msg.Nfsv4OpenResponse(status, new msg.Nfsv4OpenResOk(stateid, cinfo, rflags, attrset, delegation));
+        }
+        return new msg.Nfsv4OpenResponse(status);
+    }
+    decodeOpenattrRequest() {
+        const createdir = this.xdr.readBoolean();
+        return new msg.Nfsv4OpenattrRequest(createdir);
+    }
+    decodeOpenattrResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4OpenattrResponse(status);
+    }
+    decodeOpenConfirmRequest() {
+        const openStateid = this.readStateid();
+        const seqid = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4OpenConfirmRequest(openStateid, seqid);
+    }
+    decodeOpenConfirmResponse() {
+        const status = this.xdr.readUnsignedInt();
+        if (status === 0) {
+            const openStateid = this.readStateid();
+            return new msg.Nfsv4OpenConfirmResponse(status, new msg.Nfsv4OpenConfirmResOk(openStateid));
+        }
+        return new msg.Nfsv4OpenConfirmResponse(status);
+    }
+    decodeOpenDowngradeRequest() {
+        const xdr = this.xdr;
+        const openStateid = this.readStateid();
+        const seqid = xdr.readUnsignedInt();
+        const shareAccess = xdr.readUnsignedInt();
+        const shareDeny = xdr.readUnsignedInt();
+        return new msg.Nfsv4OpenDowngradeRequest(openStateid, seqid, shareAccess, shareDeny);
+    }
+    decodeOpenDowngradeResponse() {
+        const status = this.xdr.readUnsignedInt();
+        if (status === 0) {
+            const openStateid = this.readStateid();
+            return new msg.Nfsv4OpenDowngradeResponse(status, new msg.Nfsv4OpenDowngradeResOk(openStateid));
+        }
+        return new msg.Nfsv4OpenDowngradeResponse(status);
+    }
+    decodePutfhRequest() {
+        const object = this.readFh();
+        return new msg.Nfsv4PutfhRequest(object);
+    }
+    decodePutfhResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4PutfhResponse(status);
+    }
+    decodePutpubfhRequest() {
+        return new msg.Nfsv4PutpubfhRequest();
+    }
+    decodePutpubfhResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4PutpubfhResponse(status);
+    }
+    decodePutrootfhRequest() {
+        return new msg.Nfsv4PutrootfhRequest();
+    }
+    decodePutrootfhResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4PutrootfhResponse(status);
+    }
+    decodeReadRequest() {
+        const xdr = this.xdr;
+        const stateid = this.readStateid();
+        const offset = xdr.readUnsignedHyper();
+        const count = xdr.readUnsignedInt();
+        return new msg.Nfsv4ReadRequest(stateid, offset, count);
+    }
+    decodeReadResponse() {
+        const xdr = this.xdr;
+        const status = xdr.readUnsignedInt();
+        if (status === 0) {
+            const eof = xdr.readBoolean();
+            const data = xdr.readVarlenOpaque();
+            return new msg.Nfsv4ReadResponse(status, new msg.Nfsv4ReadResOk(eof, data));
+        }
+        return new msg.Nfsv4ReadResponse(status);
+    }
+    decodeReaddirRequest() {
+        const xdr = this.xdr;
+        const cookie = xdr.readUnsignedHyper();
+        const cookieverf = this.readVerifier();
+        const dircount = xdr.readUnsignedInt();
+        const maxcount = xdr.readUnsignedInt();
+        const attrRequest = this.readBitmap();
+        return new msg.Nfsv4ReaddirRequest(cookie, cookieverf, dircount, maxcount, attrRequest);
+    }
+    decodeReaddirResponse() {
+        const xdr = this.xdr;
+        const status = xdr.readUnsignedInt();
+        if (status === 0) {
+            const cookieverf = this.readVerifier();
+            const entries = [];
+            while (xdr.readBoolean()) {
+                const cookie = xdr.readUnsignedHyper();
+                const name = xdr.readString();
+                const attrs = this.readFattr();
+                entries.push(new structs.Nfsv4Entry(cookie, name, attrs));
+            }
+            const eof = xdr.readBoolean();
+            return new msg.Nfsv4ReaddirResponse(status, new msg.Nfsv4ReaddirResOk(cookieverf, entries, eof));
+        }
+        return new msg.Nfsv4ReaddirResponse(status);
+    }
+    decodeReadlinkRequest() {
+        return new msg.Nfsv4ReadlinkRequest();
+    }
+    decodeReadlinkResponse() {
+        const xdr = this.xdr;
+        const status = xdr.readUnsignedInt();
+        if (status === 0) {
+            const link = xdr.readString();
+            return new msg.Nfsv4ReadlinkResponse(status, new msg.Nfsv4ReadlinkResOk(link));
+        }
+        return new msg.Nfsv4ReadlinkResponse(status);
+    }
+    decodeRemoveRequest() {
+        const target = this.xdr.readString();
+        return new msg.Nfsv4RemoveRequest(target);
+    }
+    decodeRemoveResponse() {
+        const status = this.xdr.readUnsignedInt();
+        if (status === 0) {
+            const cinfo = this.readChangeInfo();
+            return new msg.Nfsv4RemoveResponse(status, new msg.Nfsv4RemoveResOk(cinfo));
+        }
+        return new msg.Nfsv4RemoveResponse(status);
+    }
+    decodeRenameRequest() {
+        const xdr = this.xdr;
+        const oldname = xdr.readString();
+        const newname = xdr.readString();
+        return new msg.Nfsv4RenameRequest(oldname, newname);
+    }
+    decodeRenameResponse() {
+        const xdr = this.xdr;
+        const status = xdr.readUnsignedInt();
+        if (status === 0) {
+            const sourceCinfo = this.readChangeInfo();
+            const targetCinfo = this.readChangeInfo();
+            return new msg.Nfsv4RenameResponse(status, new msg.Nfsv4RenameResOk(sourceCinfo, targetCinfo));
+        }
+        return new msg.Nfsv4RenameResponse(status);
+    }
+    decodeRenewRequest() {
+        const clientid = this.xdr.readUnsignedHyper();
+        return new msg.Nfsv4RenewRequest(clientid);
+    }
+    decodeRenewResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4RenewResponse(status);
+    }
+    decodeRestorefhRequest() {
+        return new msg.Nfsv4RestorefhRequest();
+    }
+    decodeRestorefhResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4RestorefhResponse(status);
+    }
+    decodeSavefhRequest() {
+        return new msg.Nfsv4SavefhRequest();
+    }
+    decodeSavefhResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4SavefhResponse(status);
+    }
+    decodeSecinfoRequest() {
+        const name = this.xdr.readString();
+        return new msg.Nfsv4SecinfoRequest(name);
+    }
+    decodeSecinfoResponse() {
+        const xdr = this.xdr;
+        const status = xdr.readUnsignedInt();
+        if (status === 0) {
+            const count = xdr.readUnsignedInt();
+            const flavors = [];
+            for (let i = 0; i < count; i++)
+                flavors.push(this.readSecInfoFlavor());
+            return new msg.Nfsv4SecinfoResponse(status, new msg.Nfsv4SecinfoResOk(flavors));
+        }
+        return new msg.Nfsv4SecinfoResponse(status);
+    }
+    decodeSetattrRequest() {
+        const stateid = this.readStateid();
+        const objAttributes = this.readFattr();
+        return new msg.Nfsv4SetattrRequest(stateid, objAttributes);
+    }
+    decodeSetattrResponse() {
+        const status = this.xdr.readUnsignedInt();
+        const attrset = this.readBitmap();
+        return new msg.Nfsv4SetattrResponse(status, new msg.Nfsv4SetattrResOk(attrset));
+    }
+    decodeSetclientidRequest() {
+        const client = this.readClientId();
+        const callback = this.readCbClient();
+        const callbackIdent = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4SetclientidRequest(client, callback, callbackIdent);
+    }
+    decodeSetclientidResponse() {
+        const xdr = this.xdr;
+        const status = xdr.readUnsignedInt();
+        if (status === 0) {
+            const clientid = xdr.readUnsignedHyper();
+            const setclientidConfirm = this.readVerifier();
+            return new msg.Nfsv4SetclientidResponse(status, new msg.Nfsv4SetclientidResOk(clientid, setclientidConfirm));
+        }
+        return new msg.Nfsv4SetclientidResponse(status);
+    }
+    decodeSetclientidConfirmRequest() {
+        const clientid = this.xdr.readUnsignedHyper();
+        const setclientidConfirm = this.readVerifier();
+        return new msg.Nfsv4SetclientidConfirmRequest(clientid, setclientidConfirm);
+    }
+    decodeSetclientidConfirmResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4SetclientidConfirmResponse(status);
+    }
+    decodeVerifyRequest() {
+        const objAttributes = this.readFattr();
+        return new msg.Nfsv4VerifyRequest(objAttributes);
+    }
+    decodeVerifyResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4VerifyResponse(status);
+    }
+    decodeWriteRequest() {
+        const xdr = this.xdr;
+        const stateid = this.readStateid();
+        const offset = xdr.readUnsignedHyper();
+        const stable = xdr.readUnsignedInt();
+        const data = xdr.readVarlenOpaque();
+        return new msg.Nfsv4WriteRequest(stateid, offset, stable, data);
+    }
+    decodeWriteResponse() {
+        const xdr = this.xdr;
+        const status = xdr.readUnsignedInt();
+        if (status === 0) {
+            const count = xdr.readUnsignedInt();
+            const committed = xdr.readUnsignedInt();
+            const writeverf = this.readVerifier();
+            return new msg.Nfsv4WriteResponse(status, new msg.Nfsv4WriteResOk(count, committed, writeverf));
+        }
+        return new msg.Nfsv4WriteResponse(status);
+    }
+    decodeReleaseLockOwnerRequest() {
+        const lockOwner = this.readLockOwner();
+        return new msg.Nfsv4ReleaseLockOwnerRequest(lockOwner);
+    }
+    decodeReleaseLockOwnerResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4ReleaseLockOwnerResponse(status);
+    }
+    decodeIllegalRequest() {
+        return new msg.Nfsv4IllegalRequest();
+    }
+    decodeIllegalResponse() {
+        const status = this.xdr.readUnsignedInt();
+        return new msg.Nfsv4IllegalResponse(status);
+    }
+}
+exports.Nfsv4Decoder = Nfsv4Decoder;
+//# sourceMappingURL=Nfsv4Decoder.js.map