SysTutorials

Linux Manual Pages › Section 3

packet-nfs-nfs4(3)

packet.nfs.nfs4 – NFSv4 decoding module

Classes

class ACCESS4args(baseobj.BaseObj)

struct ACCESS4args {
 /* CURRENT_FH: object */
 access4 access;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ACCESS4res(baseobj.BaseObj)

union switch ACCESS4res (nfsstat4 status) {
 case const.NFS4_OK:
 ACCESS4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ACCESS4resok(baseobj.BaseObj)

struct ACCESS4resok {
 access4 supported;
 access4 access;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ALLOCATE4args(baseobj.BaseObj)

struct ALLOCATE4args {
 /* CURRENT_FH: file */
 stateid4 stateid;
 offset4 offset;
 length4 length;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ALLOCATE4res(baseobj.BaseObj)

struct ALLOCATE4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class BACKCHANNEL_CTL4args(baseobj.BaseObj)

struct BACKCHANNEL_CTL4args {
 uint32_t cb_program;
 callback_sec_parms4 sec_parms<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class BACKCHANNEL_CTL4res(baseobj.BaseObj)

struct BACKCHANNEL_CTL4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class BIND_CONN_TO_SESSION4args(baseobj.BaseObj)

struct BIND_CONN_TO_SESSION4args {
 sessionid4 sessionid;
 channel_dir_from_client4 dir;
 bool rdma_mode;
};
Methods defined here:
---------------------
__init__(self, unpack)

class BIND_CONN_TO_SESSION4res(baseobj.BaseObj)

union switch BIND_CONN_TO_SESSION4res (nfsstat4 status) {
 case const.NFS4_OK:
 BIND_CONN_TO_SESSION4resok resok;
};
Methods defined here:
---------------------
__init__(self, unpack)

class BIND_CONN_TO_SESSION4resok(baseobj.BaseObj)

struct BIND_CONN_TO_SESSION4resok {
 sessionid4 sessionid;
 channel_dir_from_server4 dir;
 bool rdma_mode;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_COMPOUND4args(packet.nfs.nfsbase.NFSbase)

struct CB_COMPOUND4args {
 utf8str_cs tag;
 uint32_t minorversion;
 uint32_t callback_ident;
 nfs_cb_argop4 array<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_COMPOUND4res(packet.nfs.nfsbase.NFSbase)

struct CB_COMPOUND4res {
 nfsstat4 status;
 utf8str_cs tag;
 nfs_cb_resop4 array<>;
};
Methods defined here:
---------------------
__init__(self, unpack, minorversion)

class CB_GETATTR4args(baseobj.BaseObj)

struct CB_GETATTR4args {
 nfs_fh4 fh;
 bitmap4 request;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_GETATTR4res(baseobj.BaseObj)

union switch CB_GETATTR4res (nfsstat4 status) {
 case const.NFS4_OK:
 CB_GETATTR4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_GETATTR4resok(baseobj.BaseObj)

struct CB_GETATTR4resok {
 fattr4 attributes;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_ILLEGAL4res(baseobj.BaseObj)

struct CB_ILLEGAL4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_LAYOUTRECALL4args(baseobj.BaseObj)

struct CB_LAYOUTRECALL4args {
 layouttype4 type;
 layoutiomode4 iomode;
 bool changed;
 layoutrecall4 recall;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_LAYOUTRECALL4res(baseobj.BaseObj)

struct CB_LAYOUTRECALL4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_NOTIFY4args(baseobj.BaseObj)

struct CB_NOTIFY4args {
 stateid4 stateid;
 nfs_fh4 fh;
 notify4 changes<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_NOTIFY4res(baseobj.BaseObj)

struct CB_NOTIFY4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_NOTIFY_DEVICEID4args(baseobj.BaseObj)

struct CB_NOTIFY_DEVICEID4args {
 notify4 changes<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_NOTIFY_DEVICEID4res(baseobj.BaseObj)

struct CB_NOTIFY_DEVICEID4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_NOTIFY_LOCK4args(baseobj.BaseObj)

struct CB_NOTIFY_LOCK4args {
 nfs_fh4 fh;
 lock_owner4 lock_owner;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_NOTIFY_LOCK4res(baseobj.BaseObj)

struct CB_NOTIFY_LOCK4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_OFFLOAD4args(baseobj.BaseObj)

struct CB_OFFLOAD4args {
 nfs_fh4 fh;
 stateid4 stateid;
 offload_info4 info;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_OFFLOAD4res(baseobj.BaseObj)

struct CB_OFFLOAD4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_PUSH_DELEG4args(baseobj.BaseObj)

struct CB_PUSH_DELEG4args {
 nfs_fh4 fh;
 open_delegation4 delegation;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_PUSH_DELEG4res(baseobj.BaseObj)

struct CB_PUSH_DELEG4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_RECALL4args(baseobj.BaseObj)

struct CB_RECALL4args {
 stateid4 stateid;
 bool truncate;
 nfs_fh4 fh;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_RECALL4res(baseobj.BaseObj)

struct CB_RECALL4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_RECALLABLE_OBJ_AVAIL4args(baseobj.BaseObj)

CB_RECALLABLE_OBJ_AVAIL4args = class CB_RECALL_ANY4args(baseobj.BaseObj)

class CB_RECALLABLE_OBJ_AVAIL4res(baseobj.BaseObj)

struct CB_RECALLABLE_OBJ_AVAIL4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_RECALL_ANY4args(baseobj.BaseObj)

struct CB_RECALL_ANY4args {
 uint32_t objects_to_keep;
 bitmap4 mask;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_RECALL_ANY4res(baseobj.BaseObj)

struct CB_RECALL_ANY4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_RECALL_SLOT4args(baseobj.BaseObj)

struct CB_RECALL_SLOT4args {
 slotid4 target_highest_slotid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_RECALL_SLOT4res(baseobj.BaseObj)

struct CB_RECALL_SLOT4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_SEQUENCE4args(baseobj.BaseObj)

struct CB_SEQUENCE4args {
 sessionid4 sessionid;
 sequenceid4 sequenceid;
 slotid4 slotid;
 slotid4 highest_slotid;
 bool cachethis;
 referring_call_list4 referring_call_lists<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_SEQUENCE4res(baseobj.BaseObj)

union switch CB_SEQUENCE4res (nfsstat4 status) {
 case const.NFS4_OK:
 CB_SEQUENCE4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_SEQUENCE4resok(baseobj.BaseObj)

struct CB_SEQUENCE4resok {
 sessionid4 sessionid;
 sequenceid4 sequenceid;
 slotid4 slotid;
 slotid4 highest_slotid;
 slotid4 target_highest_slotid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_WANTS_CANCELLED4args(baseobj.BaseObj)

struct CB_WANTS_CANCELLED4args {
 bool contended;
 bool resourced;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CB_WANTS_CANCELLED4res(baseobj.BaseObj)

struct CB_WANTS_CANCELLED4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CLONE4args(baseobj.BaseObj)

struct CLONE4args {
 /*
 * SAVED_FH: source file
 * CURRENT_FH: destination file
 */
 stateid4 src_stateid;
 stateid4 dst_stateid;
 offset4 src_offset;
 offset4 dst_offset;
 length4 count;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CLONE4res(baseobj.BaseObj)

struct CLONE4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CLOSE4args(baseobj.BaseObj)

struct CLOSE4args {
 /* CURRENT_FH: object */
 seqid4 seqid;
 stateid4 stateid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CLOSE4res(baseobj.BaseObj)

union switch CLOSE4res (nfsstat4 status) {
 case const.NFS4_OK:
 stateid4 stateid;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class COMMIT4args(baseobj.BaseObj)

struct COMMIT4args {
 /* CURRENT_FH: file */
 offset4 offset;
 count4 count;
};
Methods defined here:
---------------------
__init__(self, unpack)

class COMMIT4res(baseobj.BaseObj)

union switch COMMIT4res (nfsstat4 status) {
 case const.NFS4_OK:
 COMMIT4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class COMMIT4resok(baseobj.BaseObj)

struct COMMIT4resok {
 verifier4 verifier;
};
Methods defined here:
---------------------
__init__(self, unpack)

class COMPOUND4args(packet.nfs.nfsbase.NFSbase)

struct COMPOUND4args {
 utf8str_cs tag;
 uint32_t minorversion;
 nfs_argop4 array<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class COMPOUND4res(packet.nfs.nfsbase.NFSbase)

struct COMPOUND4res {
 nfsstat4 status;
 utf8str_cs tag;
 nfs_resop4 array<>;
};
Methods defined here:
---------------------
__init__(self, unpack, minorversion)

class COPY4args(baseobj.BaseObj)

struct COPY4args {
 /*
 * SAVED_FH: source file
 * CURRENT_FH: destination file
 */
 stateid4 src_stateid;
 stateid4 dst_stateid;
 offset4 src_offset;
 offset4 dst_offset;
 length4 count;
 bool consecutive;
 bool synchronous;
 netloc4 src_servers<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class COPY4res(baseobj.BaseObj)

union switch COPY4res (nfsstat4 status) {
 case const.NFS4_OK:
 COPY4resok resok;
 case const.NFS4ERR_OFFLOAD_NO_REQS:
 copy_requirements4 requirements;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class COPY4resok(baseobj.BaseObj)

struct COPY4resok {
 write_response4 response;
 copy_requirements4 requirements;
};
Methods defined here:
---------------------
__init__(self, unpack)

class COPY_NOTIFY4args(baseobj.BaseObj)

struct COPY_NOTIFY4args {
 /* CURRENT_FH: source file */
 stateid4 stateid;
 netloc4 dst_server;
};
Methods defined here:
---------------------
__init__(self, unpack)

class COPY_NOTIFY4res(baseobj.BaseObj)

union switch COPY_NOTIFY4res (nfsstat4 status) {
 case const.NFS4_OK:
 COPY_NOTIFY4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class COPY_NOTIFY4resok(baseobj.BaseObj)

struct COPY_NOTIFY4resok {
 nfstime4 lease_time;
 stateid4 stateid;
 netloc4 src_servers<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CREATE4args(baseobj.BaseObj)

struct CREATE4args {
 /* CURRENT_FH: directory for creation */
 createtype4 type;
 component4 name;
 fattr4 attributes;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CREATE4res(baseobj.BaseObj)

union switch CREATE4res (nfsstat4 status) {
 case const.NFS4_OK:
 /* new CURRENTFH: created object */
 CREATE4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CREATE4resok(baseobj.BaseObj)

struct CREATE4resok {
 change_info4 cinfo;
 bitmap4 attrset; /* attributes set */
};
Methods defined here:
---------------------
__init__(self, unpack)

class CREATE_SESSION4args(baseobj.BaseObj)

struct CREATE_SESSION4args {
 clientid4 clientid;
 sequenceid4 sequenceid;
 uint32_t flags;
 channel_attrs4 fore_chan_attrs;
 channel_attrs4 back_chan_attrs;
 uint32_t cb_program;
 callback_sec_parms4 sec_parms<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CREATE_SESSION4res(baseobj.BaseObj)

union switch CREATE_SESSION4res (nfsstat4 status) {
 case const.NFS4_OK:
 CREATE_SESSION4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class CREATE_SESSION4resok(baseobj.BaseObj)

struct CREATE_SESSION4resok {
 sessionid4 sessionid;
 sequenceid4 sequenceid;
 uint32_t flags;
 channel_attrs4 fore_chan_attrs;
 channel_attrs4 back_chan_attrs;
};
Methods defined here:
---------------------
__init__(self, unpack)

class DEALLOCATE4args(baseobj.BaseObj)

struct DEALLOCATE4args {
 /* CURRENT_FH: file */
 stateid4 stateid;
 offset4 offset;
 length4 length;
};
Methods defined here:
---------------------
__init__(self, unpack)

class DEALLOCATE4res(baseobj.BaseObj)

struct DEALLOCATE4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class DELEGPURGE4args(baseobj.BaseObj)

struct DELEGPURGE4args {
 clientid4 clientid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class DELEGPURGE4res(baseobj.BaseObj)

struct DELEGPURGE4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class DELEGRETURN4args(baseobj.BaseObj)

struct DELEGRETURN4args {
 /* CURRENT_FH: delegated object */
 stateid4 stateid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class DELEGRETURN4res(baseobj.BaseObj)

struct DELEGRETURN4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class DESTROY_CLIENTID4args(baseobj.BaseObj)

struct DESTROY_CLIENTID4args {
 clientid4 clientid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class DESTROY_CLIENTID4res(baseobj.BaseObj)

struct DESTROY_CLIENTID4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class DESTROY_SESSION4args(baseobj.BaseObj)

struct DESTROY_SESSION4args {
 sessionid4 sessionid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class DESTROY_SESSION4res(baseobj.BaseObj)

struct DESTROY_SESSION4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class EXCHANGE_ID4args(baseobj.BaseObj)

struct EXCHANGE_ID4args {
 client_owner4 clientowner;
 uint32_t flags;
 state_protect4_a state_protect;
 nfs_impl_id4 client_impl_id<1>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class EXCHANGE_ID4res(baseobj.BaseObj)

union switch EXCHANGE_ID4res (nfsstat4 status) {
 case const.NFS4_OK:
 EXCHANGE_ID4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class EXCHANGE_ID4resok(baseobj.BaseObj)

struct EXCHANGE_ID4resok {
 clientid4 clientid;
 sequenceid4 sequenceid;
 uint32_t flags;
 state_protect4_r state_protect;
 server_owner4 server_owner;
 opaque server_scope<NFS4_OPAQUE_LIMIT>;
 nfs_impl_id4 server_impl_id<1>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class FREE_STATEID4args(baseobj.BaseObj)

struct FREE_STATEID4args {
 stateid4 stateid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class FREE_STATEID4res(baseobj.BaseObj)

struct FREE_STATEID4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GETATTR4args(baseobj.BaseObj)

struct GETATTR4args {
 /* CURRENT_FH: object */
 bitmap4 request;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GETATTR4res(baseobj.BaseObj)

union switch GETATTR4res (nfsstat4 status) {
 case const.NFS4_OK:
 GETATTR4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GETATTR4resok(baseobj.BaseObj)

struct GETATTR4resok {
 fattr4 attributes;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GETDEVICEINFO4args(baseobj.BaseObj)

struct GETDEVICEINFO4args {
 deviceid4 deviceid;
 layouttype4 type;
 count4 maxcount;
 bitmap4 notification;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GETDEVICEINFO4res(baseobj.BaseObj)

union switch GETDEVICEINFO4res (nfsstat4 status) {
 case const.NFS4_OK:
 GETDEVICEINFO4resok resok;
 case const.NFS4ERR_TOOSMALL:
 count4 mincount;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GETDEVICEINFO4resok(baseobj.BaseObj)

struct GETDEVICEINFO4resok {
 device_addr4 device_addr;
 bitmap4 notification;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GETDEVICELIST4args(baseobj.BaseObj)

struct GETDEVICELIST4args {
 /* CURRENT_FH: object belonging to the file system */
 layouttype4 type;
 /* number of deviceIDs to return */
 count4 maxdevices;
 nfs_cookie4 cookie;
 verifier4 verifier;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GETDEVICELIST4res(baseobj.BaseObj)

union switch GETDEVICELIST4res (nfsstat4 status) {
 case const.NFS4_OK:
 GETDEVICELIST4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GETDEVICELIST4resok(baseobj.BaseObj)

struct GETDEVICELIST4resok {
 nfs_cookie4 cookie;
 verifier4 verifier;
 deviceid4 deviceid_list<>;
 bool eof;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GETFH4res(baseobj.BaseObj)

union switch GETFH4res (nfsstat4 status) {
 case const.NFS4_OK:
 GETFH4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GETFH4resok(baseobj.BaseObj)

struct GETFH4resok {
 nfs_fh4 fh;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GET_DIR_DELEGATION4args(baseobj.BaseObj)

struct GET_DIR_DELEGATION4args {
 /* CURRENT_FH: delegated directory */
 bool deleg_avail;
 bitmap4 notification;
 attr_notice4 child_attr_delay;
 attr_notice4 attr_delay;
 bitmap4 child_attributes;
 bitmap4 attributes;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GET_DIR_DELEGATION4res(baseobj.BaseObj)

union switch GET_DIR_DELEGATION4res (nfsstat4 status) {
 case const.NFS4_OK:
 GET_DIR_DELEGATION4res_non_fatal resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GET_DIR_DELEGATION4res_non_fatal(baseobj.BaseObj)

union switch GET_DIR_DELEGATION4res_non_fatal (gddrnf4_status status) {
 case const.GDD4_OK:
 GET_DIR_DELEGATION4resok resok;
 case const.GDD4_UNAVAIL:
 bool signal;
};
Methods defined here:
---------------------
__init__(self, unpack)

class GET_DIR_DELEGATION4resok(baseobj.BaseObj)

struct GET_DIR_DELEGATION4resok {
 verifier4 verifier;
 /* Stateid for get_dir_delegation */
 stateid4 stateid;
 /* Which notifications can the server support */
 bitmap4 notification;
 bitmap4 child_attributes;
 bitmap4 attributes;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ILLEGAL4res(baseobj.BaseObj)

struct ILLEGAL4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class IO_ADVISE4args(baseobj.BaseObj)

struct IO_ADVISE4args {
 /* CURRENT_FH: file */
 stateid4 stateid;
 offset4 offset;
 length4 count;
 bitmap4 hints;
};
Methods defined here:
---------------------
__init__(self, unpack)

class IO_ADVISE4res(baseobj.BaseObj)

union switch IO_ADVISE4res (nfsstat4 status) {
 case const.NFS4_OK:
 IO_ADVISE4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class IO_ADVISE4resok(baseobj.BaseObj)

struct IO_ADVISE4resok {
 bitmap4 hints;
};
Methods defined here:
---------------------
__init__(self, unpack)

class IO_ADVISE_type4(packet.utils.Enum)

enum IO_ADVISE_type4

class LAYOUTCOMMIT4args(baseobj.BaseObj)

struct LAYOUTCOMMIT4args {
 /* CURRENT_FH: file */
 offset4 offset;
 length4 length;
 bool reclaim;
 stateid4 stateid;
 newoffset4 last_write_offset;
 newtime4 time_modify;
 layoutupdate4 layoutupdate;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LAYOUTCOMMIT4res(baseobj.BaseObj)

union switch LAYOUTCOMMIT4res (nfsstat4 status) {
 case const.NFS4_OK:
 LAYOUTCOMMIT4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LAYOUTCOMMIT4resok(baseobj.BaseObj)

struct LAYOUTCOMMIT4resok {
 newsize4 newsize;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LAYOUTERROR4args(baseobj.BaseObj)

struct LAYOUTERROR4args {
 /* CURRENT_FH: file */
 offset4 offset;
 length4 length;
 stateid4 stateid;
 device_error4 errors<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LAYOUTERROR4res(baseobj.BaseObj)

struct LAYOUTERROR4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LAYOUTGET4args(baseobj.BaseObj)

struct LAYOUTGET4args {
 /* CURRENT_FH: file */
 bool avail;
 layouttype4 type;
 layoutiomode4 iomode;
 offset4 offset;
 length4 length;
 length4 minlength;
 stateid4 stateid;
 count4 maxcount;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LAYOUTGET4res(baseobj.BaseObj)

union switch LAYOUTGET4res (nfsstat4 status) {
 case const.NFS4_OK:
 LAYOUTGET4resok resok;
 case const.NFS4ERR_LAYOUTTRYLATER:
 /* Server will signal layout availability */
 bool signal;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LAYOUTGET4resok(baseobj.BaseObj)

struct LAYOUTGET4resok {
 bool return_on_close;
 stateid4 stateid;
 layout4 layout<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LAYOUTRETURN4args(baseobj.BaseObj)

struct LAYOUTRETURN4args {
 /* CURRENT_FH: file */
 bool reclaim;
 layouttype4 type;
 layoutiomode4 iomode;
 layoutreturn4 layoutreturn;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LAYOUTRETURN4res(baseobj.BaseObj)

union switch LAYOUTRETURN4res (nfsstat4 status) {
 case const.NFS4_OK:
 layoutreturn_stateid stateid;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LAYOUTSTATS4args(baseobj.BaseObj)

struct LAYOUTSTATS4args {
 /* CURRENT_FH: file */
 offset4 offset;
 length4 length;
 stateid4 stateid;
 io_info4 read;
 io_info4 write;
 deviceid4 deviceid;
 layoutupdate4 layoutupdate;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LAYOUTSTATS4res(baseobj.BaseObj)

struct LAYOUTSTATS4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LINK4args(baseobj.BaseObj)

struct LINK4args {
 /*
 * SAVED_FH: source object
 * CURRENT_FH: target directory
 */
 component4 name;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LINK4res(baseobj.BaseObj)

union switch LINK4res (nfsstat4 status) {
 case const.NFS4_OK:
 LINK4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LINK4resok(baseobj.BaseObj)

struct LINK4resok {
 change_info4 cinfo;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LOCK4args(baseobj.BaseObj)

struct LOCK4args {
 /* CURRENT_FH: file */
 nfs_lock_type4 locktype;
 bool reclaim;
 offset4 offset;
 length4 length;
 locker4 locker;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LOCK4denied(baseobj.BaseObj)

struct LOCK4denied {
 offset4 offset;
 length4 length;
 nfs_lock_type4 locktype;
 lock_owner4 owner;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LOCK4res(baseobj.BaseObj)

union switch LOCK4res (nfsstat4 status) {
 case const.NFS4_OK:
 LOCK4resok resok;
 case const.NFS4ERR_DENIED:
 LOCK4denied denied;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LOCK4resok(baseobj.BaseObj)

struct LOCK4resok {
 stateid4 stateid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LOCKT4args(baseobj.BaseObj)

struct LOCKT4args {
 /* CURRENT_FH: file */
 nfs_lock_type4 locktype;
 offset4 offset;
 length4 length;
 lock_owner4 owner;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LOCKT4res(baseobj.BaseObj)

union switch LOCKT4res (nfsstat4 status) {
 case const.NFS4ERR_DENIED:
 LOCK4denied denied;
 case const.NFS4_OK:
 void;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LOCKU4args(baseobj.BaseObj)

struct LOCKU4args {
 /* CURRENT_FH: file */
 nfs_lock_type4 locktype;
 seqid4 seqid;
 stateid4 stateid;
 offset4 offset;
 length4 length;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LOCKU4res(baseobj.BaseObj)

union switch LOCKU4res (nfsstat4 status) {
 case const.NFS4_OK:
 stateid4 stateid;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LOOKUP4args(baseobj.BaseObj)

struct LOOKUP4args {
 /* CURRENT_FH: directory */
 component4 name;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LOOKUP4res(baseobj.BaseObj)

struct LOOKUP4res {
 /* New CURRENT_FH: object */
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class LOOKUPP4res(baseobj.BaseObj)

struct LOOKUPP4res {
 /* new CURRENT_FH: parent directory */
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class NVERIFY4args(baseobj.BaseObj)

struct NVERIFY4args {
 /* CURRENT_FH: object */
 fattr4 attributes;
};
Methods defined here:
---------------------
__init__(self, unpack)

class NVERIFY4res(baseobj.BaseObj)

struct NVERIFY4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OFFLOAD_CANCEL4args(baseobj.BaseObj)

struct OFFLOAD_CANCEL4args {
 /* CURRENT_FH: file to cancel */
 stateid4 stateid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OFFLOAD_CANCEL4res(baseobj.BaseObj)

struct OFFLOAD_CANCEL4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OFFLOAD_STATUS4args(baseobj.BaseObj)

struct OFFLOAD_STATUS4args {
 /* CURRENT_FH: destination file */
 stateid4 stateid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OFFLOAD_STATUS4res(baseobj.BaseObj)

union switch OFFLOAD_STATUS4res (nfsstat4 status) {
 case const.NFS4_OK:
 OFFLOAD_STATUS4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OFFLOAD_STATUS4resok(baseobj.BaseObj)

struct OFFLOAD_STATUS4resok {
 length4 count;
 nfsstat4 complete<1>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OPEN4args(baseobj.BaseObj)

struct OPEN4args {
 seqid4 seqid;
 uint32_t access;
 uint32_t deny;
 open_owner4 owner;
 openflag4 openhow;
 open_claim4 claim;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OPEN4res(baseobj.BaseObj)

union switch OPEN4res (nfsstat4 status) {
 case const.NFS4_OK:
 /* New CURRENT_FH: opened file */
 OPEN4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OPEN4resok(baseobj.BaseObj)

struct OPEN4resok {
 stateid4 stateid; /* Stateid for open */
 change_info4 cinfo; /* Directory Change Info */
 uint32_t rflags; /* Result flags */
 bitmap4 attrset; /* attribute set for create */
 open_delegation4 delegation; /* Info on any open delegation */
};
Methods defined here:
---------------------
__init__(self, unpack)

class OPENATTR4args(baseobj.BaseObj)

struct OPENATTR4args {
 /* CURRENT_FH: object */
 bool createdir;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OPENATTR4res(baseobj.BaseObj)

struct OPENATTR4res {
 /*
 * If status is NFS4_OK,
 * new CURRENT_FH: named attribute directory
 */
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OPEN_CONFIRM4args(baseobj.BaseObj)

struct OPEN_CONFIRM4args {
 /* CURRENT_FH: opened file */
 stateid4 stateid;
 seqid4 seqid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OPEN_CONFIRM4res(baseobj.BaseObj)

union switch OPEN_CONFIRM4res (nfsstat4 status) {
 case const.NFS4_OK:
 OPEN_CONFIRM4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OPEN_CONFIRM4resok(baseobj.BaseObj)

struct OPEN_CONFIRM4resok {
 stateid4 stateid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OPEN_DOWNGRADE4args(baseobj.BaseObj)

struct OPEN_DOWNGRADE4args {
 /* CURRENT_FH: opened file */
 stateid4 stateid;
 seqid4 seqid;
 uint32_t access;
 uint32_t deny;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OPEN_DOWNGRADE4res(baseobj.BaseObj)

union switch OPEN_DOWNGRADE4res (nfsstat4 status) {
 case const.NFS4_OK:
 OPEN_DOWNGRADE4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class OPEN_DOWNGRADE4resok(baseobj.BaseObj)

struct OPEN_DOWNGRADE4resok {
 stateid4 stateid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class PUTFH4args(baseobj.BaseObj)

struct PUTFH4args {
 nfs_fh4 fh;
};
Methods defined here:
---------------------
__init__(self, unpack)

class PUTFH4res(baseobj.BaseObj)

struct PUTFH4res {
 /*
 * If status is NFS4_OK,
 * new CURRENT_FH: argument to PUTFH
 */
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class PUTPUBFH4res(baseobj.BaseObj)

struct PUTPUBFH4res {
 /*
 * If status is NFS4_OK,
 * new CURRENT_FH: public fh
 */
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class PUTROOTFH4res(baseobj.BaseObj)

struct PUTROOTFH4res {
 /*
 * If status is NFS4_OK,
 * new CURRENT_FH: root fh
 */
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class READ4args(baseobj.BaseObj)

struct READ4args {
 /* CURRENT_FH: file */
 stateid4 stateid;
 offset4 offset;
 count4 count;
};
Methods defined here:
---------------------
__init__(self, unpack)

class READ4res(baseobj.BaseObj)

union switch READ4res (nfsstat4 status) {
 case const.NFS4_OK:
 READ4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class READ4resok(baseobj.BaseObj)

struct READ4resok {
 bool eof;
 opaque data<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class READDIR4args(baseobj.BaseObj)

struct READDIR4args {
 /* CURRENT_FH: directory */
 nfs_cookie4 cookie;
 verifier4 verifier;
 count4 dircount;
 count4 maxcount;
 bitmap4 request;
};
Methods defined here:
---------------------
__init__(self, unpack)

class READDIR4res(baseobj.BaseObj)

union switch READDIR4res (nfsstat4 status) {
 case const.NFS4_OK:
 READDIR4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class READDIR4resok(baseobj.BaseObj)

struct READDIR4resok {
 verifier4 verifier;
 dirlist4 reply;
};
Methods defined here:
---------------------
__init__(self, unpack)

class READLINK4res(baseobj.BaseObj)

union switch READLINK4res (nfsstat4 status) {
 case const.NFS4_OK:
 READLINK4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class READLINK4resok(baseobj.BaseObj)

struct READLINK4resok {
 linktext4 link;
};
Methods defined here:
---------------------
__init__(self, unpack)

class READ_PLUS4args(baseobj.BaseObj)

struct READ_PLUS4args {
 /* CURRENT_FH: file */
 stateid4 stateid;
 offset4 offset;
 count4 count;
};
Methods defined here:
---------------------
__init__(self, unpack)

class READ_PLUS4res(baseobj.BaseObj)

union switch READ_PLUS4res (nfsstat4 status) {
 case const.NFS4_OK:
 read_plus_res4 resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class RECLAIM_COMPLETE4args(baseobj.BaseObj)

union switch RECLAIM_COMPLETE4args (bool one_fs) {
 case const.TRUE:
 /*
 * If one_fs TRUE,
 * CURRENT_FH: object in filesystem reclaim is complete for.
 */
 void;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class RECLAIM_COMPLETE4res(baseobj.BaseObj)

struct RECLAIM_COMPLETE4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class RELEASE_LOCKOWNER4args(baseobj.BaseObj)

struct RELEASE_LOCKOWNER4args {
 lock_owner4 owner;
};
Methods defined here:
---------------------
__init__(self, unpack)

class RELEASE_LOCKOWNER4res(baseobj.BaseObj)

struct RELEASE_LOCKOWNER4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class REMOVE4args(baseobj.BaseObj)

struct REMOVE4args {
 /* CURRENT_FH: directory */
 component4 name;
};
Methods defined here:
---------------------
__init__(self, unpack)

class REMOVE4res(baseobj.BaseObj)

union switch REMOVE4res (nfsstat4 status) {
 case const.NFS4_OK:
 REMOVE4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class REMOVE4resok(baseobj.BaseObj)

struct REMOVE4resok {
 change_info4 cinfo;
};
Methods defined here:
---------------------
__init__(self, unpack)

class RENAME4args(baseobj.BaseObj)

struct RENAME4args {
 /* SAVED_FH: source directory */
 component4 name;
 /* CURRENT_FH: target directory */
 component4 newname;
};
Methods defined here:
---------------------
__init__(self, unpack)

class RENAME4res(baseobj.BaseObj)

union switch RENAME4res (nfsstat4 status) {
 case const.NFS4_OK:
 RENAME4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class RENAME4resok(baseobj.BaseObj)

struct RENAME4resok {
 change_info4 source;
 change_info4 target;
};
Methods defined here:
---------------------
__init__(self, unpack)

class RENEW4args(baseobj.BaseObj)

struct RENEW4args {
 clientid4 clientid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class RENEW4res(baseobj.BaseObj)

struct RENEW4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class RESTOREFH4res(baseobj.BaseObj)

struct RESTOREFH4res {
 /*
 * If status is NFS4_OK,
 * new CURRENT_FH: value of saved fh
 */
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SAVEFH4res(baseobj.BaseObj)

struct SAVEFH4res {
 /*
 * If status is NFS4_OK,
 * new SAVED_FH: value of current fh
 */
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SECINFO4args(baseobj.BaseObj)

struct SECINFO4args {
 /* CURRENT_FH: directory */
 component4 name;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SECINFO4res(baseobj.BaseObj)

union switch SECINFO4res (nfsstat4 status) {
 case const.NFS4_OK:
 /* CURRENTFH: consumed */
 SECINFO4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SECINFO_NO_NAME4args(baseobj.BaseObj)

struct SECINFO_NO_NAME4args {
 /* CURRENT_FH: object or child directory */
 secinfo_style4 style;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SECINFO_NO_NAME4res(baseobj.BaseObj)

SECINFO_NO_NAME4res = class SECINFO4res(baseobj.BaseObj)

class SEEK4args(baseobj.BaseObj)

struct SEEK4args {
 /* CURRENT_FH: file */
 stateid4 stateid;
 offset4 offset;
 data_content4 what;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SEEK4res(baseobj.BaseObj)

union switch SEEK4res (nfsstat4 status) {
 case const.NFS4_OK:
 seek_res4 resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SEQUENCE4args(baseobj.BaseObj)

struct SEQUENCE4args {
 sessionid4 sessionid;
 sequenceid4 sequenceid;
 slotid4 slotid;
 slotid4 highest_slotid;
 bool cachethis;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SEQUENCE4res(baseobj.BaseObj)

union switch SEQUENCE4res (nfsstat4 status) {
 case const.NFS4_OK:
 SEQUENCE4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SEQUENCE4resok(baseobj.BaseObj)

struct SEQUENCE4resok {
 sessionid4 sessionid;
 sequenceid4 sequenceid;
 slotid4 slotid;
 slotid4 highest_slotid;
 slotid4 target_highest_slotid;
 uint32_t status_flags;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SETATTR4args(baseobj.BaseObj)

struct SETATTR4args {
 /* CURRENT_FH: target object */
 stateid4 stateid;
 fattr4 attributes;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SETATTR4res(baseobj.BaseObj)

struct SETATTR4res {
 nfsstat4 status;
 bitmap4 attrset;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SETCLIENTID4args(baseobj.BaseObj)

struct SETCLIENTID4args {
 nfs_client_id4 client;
 cb_client4 callback;
 uint32_t callback_ident;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SETCLIENTID4res(baseobj.BaseObj)

union switch SETCLIENTID4res (nfsstat4 status) {
 case const.NFS4_OK:
 SETCLIENTID4resok resok;
 case const.NFS4ERR_CLID_INUSE:
 clientaddr4 client;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SETCLIENTID4resok(baseobj.BaseObj)

struct SETCLIENTID4resok {
 clientid4 clientid;
 verifier4 verifier;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SETCLIENTID_CONFIRM4args(baseobj.BaseObj)

struct SETCLIENTID_CONFIRM4args {
 clientid4 clientid;
 verifier4 verifier;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SETCLIENTID_CONFIRM4res(baseobj.BaseObj)

struct SETCLIENTID_CONFIRM4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SET_SSV4args(baseobj.BaseObj)

struct SET_SSV4args {
 opaque ssv<>;
 opaque digest<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SET_SSV4res(baseobj.BaseObj)

union switch SET_SSV4res (nfsstat4 status) {
 case const.NFS4_OK:
 SET_SSV4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class SET_SSV4resok(baseobj.BaseObj)

struct SET_SSV4resok {
 opaque digest<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class TEST_STATEID4args(baseobj.BaseObj)

struct TEST_STATEID4args {
 stateid4 stateids<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class TEST_STATEID4res(baseobj.BaseObj)

union switch TEST_STATEID4res (nfsstat4 status) {
 case const.NFS4_OK:
 TEST_STATEID4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class TEST_STATEID4resok(baseobj.BaseObj)

struct TEST_STATEID4resok {
 nfsstat4 status_codes<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class VERIFY4args(baseobj.BaseObj)

struct VERIFY4args {
 /* CURRENT_FH: object */
 fattr4 attributes;
};
Methods defined here:
---------------------
__init__(self, unpack)

class VERIFY4res(baseobj.BaseObj)

struct VERIFY4res {
 nfsstat4 status;
};
Methods defined here:
---------------------
__init__(self, unpack)

class WANT_DELEGATION4args(baseobj.BaseObj)

struct WANT_DELEGATION4args {
 uint32_t want;
 deleg_claim4 claim;
};
Methods defined here:
---------------------
__init__(self, unpack)

class WANT_DELEGATION4res(baseobj.BaseObj)

union switch WANT_DELEGATION4res (nfsstat4 status) {
 case const.NFS4_OK:
 open_delegation4 resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class WRITE4args(baseobj.BaseObj)

struct WRITE4args {
 /* CURRENT_FH: file */
 stateid4 stateid;
 offset4 offset;
 stable_how4 stable;
 opaque data<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class WRITE4res(baseobj.BaseObj)

union switch WRITE4res (nfsstat4 status) {
 case const.NFS4_OK:
 WRITE4resok resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class WRITE4resok(baseobj.BaseObj)

struct WRITE4resok {
 count4 count;
 stable_how4 committed;
 verifier4 verifier;
};
Methods defined here:
---------------------
__init__(self, unpack)

class WRITE_SAME4args(baseobj.BaseObj)

struct WRITE_SAME4args {
 /* CURRENT_FH: file */
 stateid4 stateid;
 stable_how4 stable;
 app_data_block4 adb;
};
Methods defined here:
---------------------
__init__(self, unpack)

class WRITE_SAME4res(baseobj.BaseObj)

union switch WRITE_SAME4res (nfsstat4 status) {
 case const.NFS4_OK:
 write_response4 resok;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class app_data_block4(baseobj.BaseObj)

struct app_data_block4 {
 offset4 offset;
 length4 block_size;
 length4 block_count;
 length4 reloff_blocknum;
 count4 block_num;
 length4 reloff_pattern;
 opaque pattern<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class attr_notice4(baseobj.BaseObj)

attr_notice4 = class nfstime4(baseobj.BaseObj)

class authsys_parms(baseobj.BaseObj)

struct authsys_parms {
 unsigned int stamp;
 string machinename<255>;
 unsigned int uid;
 unsigned int gid;
 unsigned int gids<16>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class callback_sec_parms4(baseobj.BaseObj)

union switch callback_sec_parms4 (nfs_secflavor4 flavor) {
 case const.AUTH_NONE:
 void;
 case const.AUTH_SYS:
 authsys_parms sys_cred; /* RFC 1831 */
 case const.RPCSEC_GSS:
 gss_cb_handles4 gss_handles;
};
Methods defined here:
---------------------
__init__(self, unpack)

class cb_client4(baseobj.BaseObj)

struct cb_client4 {
 uint32_t cb_program;
 netaddr4 cb_location;
};
Methods defined here:
---------------------
__init__(self, unpack)

class change_attr_type4(packet.utils.Enum)

enum change_attr_type4

class change_info4(baseobj.BaseObj)

struct change_info4 {
 bool atomic;
 changeid4 before;
 changeid4 after;
};
Methods defined here:
---------------------
__init__(self, unpack)

class change_policy4(baseobj.BaseObj)

struct change_policy4 {
 uint64_t major;
 uint64_t minor;
};
Methods defined here:
---------------------
__init__(self, unpack)

class channel_attrs4(baseobj.BaseObj)

struct channel_attrs4 {
 count4 headerpadsize;
 count4 maxrequestsize;
 count4 maxresponsesize;
 count4 maxresponsesize_cached;
 count4 maxoperations;
 count4 maxrequests;
 uint32_t rdma_ird<1>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class channel_dir_from_client4(packet.utils.Enum)

enum channel_dir_from_client4

class channel_dir_from_server4(packet.utils.Enum)

enum channel_dir_from_server4

class client_owner4(baseobj.BaseObj)

struct client_owner4 {
 verifier4 verifier;
 opaque ownerid<NFS4_OPAQUE_LIMIT>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class clientaddr4(baseobj.BaseObj)

struct clientaddr4 {
 /* See struct rpcb in RFC 1833 */
 string netid<>; /* network id */
 string addr<>; /* universal address */
};
Methods defined here:
---------------------
__init__(self, unpack)

class copy_confirm_auth_priv(baseobj.BaseObj)

struct copy_confirm_auth_priv {
 /* equal to GSS_GetMIC() of cfap_shared_secret */
 opaque secret<>;
 /* the NFSv4 user name that the user principal maps to */
 utf8str_mixed username;
};
Methods defined here:
---------------------
__init__(self, unpack)

class copy_from_auth_priv(baseobj.BaseObj)

struct copy_from_auth_priv {
 secret4 secret;
 netloc4 destination;
 /* the NFSv4 user name that the user principal maps to */
 utf8str_mixed username;
};
Methods defined here:
---------------------
__init__(self, unpack)

class copy_requirements4(baseobj.BaseObj)

struct copy_requirements4 {
 bool consecutive;
 bool synchronous;
};
Methods defined here:
---------------------
__init__(self, unpack)

class copy_to_auth_priv(baseobj.BaseObj)

struct copy_to_auth_priv {
 /* equal to cfap_shared_secret */
 secret4 secret;
 netloc4 source<>;
 /* the NFSv4 user name that the user principal maps to */
 utf8str_mixed username;
};
Methods defined here:
---------------------
__init__(self, unpack)

class createhow4(baseobj.BaseObj)

union switch createhow4 (createmode4 mode) {
 case const.UNCHECKED4:
 case const.GUARDED4:
 fattr4 attributes;
 case const.EXCLUSIVE4:
 verifier4 verifier;
 case const.EXCLUSIVE4_1:
 creatverfattr createboth;
};
Methods defined here:
---------------------
__init__(self, unpack)

class createmode4(packet.utils.Enum)

enum createmode4

class createtype4(baseobj.BaseObj)

union switch createtype4 (nfs_ftype4 type) {
 case const.NF4LNK:
 linktext4 linkdata;
 case const.NF4BLK:
 case const.NF4CHR:
 specdata4 devdata;
 case const.NF4SOCK:
 case const.NF4FIFO:
 case const.NF4DIR:
 void;
 default:
 void; /* server should return NFS4ERR_BADTYPE */
};
Methods defined here:
---------------------
__init__(self, unpack)

class creatverfattr(baseobj.BaseObj)

struct creatverfattr {
 verifier4 verifier;
 fattr4 attrs;
};
Methods defined here:
---------------------
__init__(self, unpack)

class data4(baseobj.BaseObj)

struct data4 {
 offset4 offset;
 opaque data<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class data_content4(packet.utils.Enum)

enum data_content4

class data_info4(baseobj.BaseObj)

struct data_info4 {
 offset4 offset;
 length4 count;
};
Methods defined here:
---------------------
__init__(self, unpack)

class deleg_claim4(baseobj.BaseObj)

union switch deleg_claim4 (open_claim_type4 claim) {
 /*
 * No special rights to object. Ordinary delegation
 * request of the specified object. Object identified
 * by filehandle.
 */
 case const.CLAIM_FH:
 void;
 /*
 * Right to file based on a delegation granted
 * to a previous boot instance of the client.
 * File is specified by filehandle.
 */
 case const.CLAIM_DELEG_PREV_FH:
 /* CURRENT_FH: object being delegated */
 void;
 /*
 * Right to the file established by an open previous
 * to server reboot. File identified by filehandle.
 * Used during server reclaim grace period.
 */
 case const.CLAIM_PREVIOUS:
 /* CURRENT_FH: object being reclaimed */
 open_delegation_type4 deleg_type;
};
Methods defined here:
---------------------
__init__(self, unpack)

class device_addr4(baseobj.BaseObj)

union switch device_addr4 (layouttype4 type) {
 case const.LAYOUT4_NFSV4_1_FILES:
 nfsv4_1_file_layout_ds_addr4 body;
 case const.LAYOUT4_FLEX_FILES:
 ff_device_addr4 body;
 default:
 /* All other types are not supported yet */
 opaque body<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class device_error4(baseobj.BaseObj)

struct device_error4 {
 deviceid4 deviceid;
 nfsstat4 status;
 nfs_opnum4 opnum;
};
Methods defined here:
---------------------
__init__(self, unpack)

class dirlist4(baseobj.BaseObj)

struct dirlist4 {
 entry4 *entries;
 bool eof;
};
Methods defined here:
---------------------
__init__(self, unpack)

class entry4(baseobj.BaseObj)

struct entry4 {
 nfs_cookie4 cookie;
 component4 name;
 fattr4 attrs;
 entry4 *nextentry;
};
Methods defined here:
---------------------
__init__(self, unpack)

class exist_lock_owner4(baseobj.BaseObj)

struct exist_lock_owner4 {
 stateid4 stateid;
 seqid4 seqid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class fattr4_archive(packet.utils.Enum)

fattr4_archive = class nfs_bool(packet.utils.Enum)

class fattr4_cansettime(packet.utils.Enum)

fattr4_cansettime = class nfs_bool(packet.utils.Enum)

class fattr4_case_insensitive(packet.utils.Enum)

fattr4_case_insensitive = class nfs_bool(packet.utils.Enum)

class fattr4_case_preserving(packet.utils.Enum)

fattr4_case_preserving = class nfs_bool(packet.utils.Enum)

class fattr4_change_attr_type(packet.utils.Enum)

fattr4_change_attr_type = class change_attr_type4(packet.utils.Enum)

class fattr4_change_policy(baseobj.BaseObj)

fattr4_change_policy = class change_policy4(baseobj.BaseObj)

class fattr4_chown_restricted(packet.utils.Enum)

fattr4_chown_restricted = class nfs_bool(packet.utils.Enum)

class fattr4_dacl(baseobj.BaseObj)

fattr4_dacl = class nfsacl41(baseobj.BaseObj)

class fattr4_dir_notif_delay(baseobj.BaseObj)

fattr4_dir_notif_delay = class nfstime4(baseobj.BaseObj)

class fattr4_dirent_notif_delay(baseobj.BaseObj)

fattr4_dirent_notif_delay = class nfstime4(baseobj.BaseObj)

class fattr4_fs_locations(baseobj.BaseObj)

fattr4_fs_locations = class fs_locations4(baseobj.BaseObj)

class fattr4_fs_locations_info(baseobj.BaseObj)

fattr4_fs_locations_info = class fs_locations_info4(baseobj.BaseObj)

class fattr4_fs_status(baseobj.BaseObj)

fattr4_fs_status = class fs4_status(baseobj.BaseObj)

class fattr4_fsid(baseobj.BaseObj)

fattr4_fsid = class fsid4(baseobj.BaseObj)

class fattr4_hidden(packet.utils.Enum)

fattr4_hidden = class nfs_bool(packet.utils.Enum)

class fattr4_homogeneous(packet.utils.Enum)

fattr4_homogeneous = class nfs_bool(packet.utils.Enum)

class fattr4_layout_hint(baseobj.BaseObj)

fattr4_layout_hint = class layouthint4(baseobj.BaseObj)

class fattr4_link_support(packet.utils.Enum)

fattr4_link_support = class nfs_bool(packet.utils.Enum)

class fattr4_mdsthreshold(baseobj.BaseObj)

fattr4_mdsthreshold = class mdsthreshold4(baseobj.BaseObj)

class fattr4_mode_set_masked(baseobj.BaseObj)

fattr4_mode_set_masked = class mode_masked4(baseobj.BaseObj)

class fattr4_named_attr(packet.utils.Enum)

fattr4_named_attr = class nfs_bool(packet.utils.Enum)

class fattr4_no_trunc(packet.utils.Enum)

fattr4_no_trunc = class nfs_bool(packet.utils.Enum)

class fattr4_rawdev(baseobj.BaseObj)

fattr4_rawdev = class specdata4(baseobj.BaseObj)

class fattr4_rdattr_error(packet.utils.Enum)

fattr4_rdattr_error = class nfsstat4(packet.utils.Enum)

class fattr4_retentevt_get(baseobj.BaseObj)

fattr4_retentevt_get = class retention_get4(baseobj.BaseObj)

class fattr4_retentevt_set(baseobj.BaseObj)

fattr4_retentevt_set = class retention_set4(baseobj.BaseObj)

class fattr4_retention_get(baseobj.BaseObj)

fattr4_retention_get = class retention_get4(baseobj.BaseObj)

class fattr4_retention_set(baseobj.BaseObj)

fattr4_retention_set = class retention_set4(baseobj.BaseObj)

class fattr4_sacl(baseobj.BaseObj)

fattr4_sacl = class nfsacl41(baseobj.BaseObj)

class fattr4_sec_label(baseobj.BaseObj)

fattr4_sec_label = class sec_label4(baseobj.BaseObj)

class fattr4_symlink_support(packet.utils.Enum)

fattr4_symlink_support = class nfs_bool(packet.utils.Enum)

class fattr4_system(packet.utils.Enum)

fattr4_system = class nfs_bool(packet.utils.Enum)

class fattr4_time_access(baseobj.BaseObj)

fattr4_time_access = class nfstime4(baseobj.BaseObj)

class fattr4_time_access_set(baseobj.BaseObj)

fattr4_time_access_set = class settime4(baseobj.BaseObj)

class fattr4_time_backup(baseobj.BaseObj)

fattr4_time_backup = class nfstime4(baseobj.BaseObj)

class fattr4_time_create(baseobj.BaseObj)

fattr4_time_create = class nfstime4(baseobj.BaseObj)

class fattr4_time_delta(baseobj.BaseObj)

fattr4_time_delta = class nfstime4(baseobj.BaseObj)

class fattr4_time_metadata(baseobj.BaseObj)

fattr4_time_metadata = class nfstime4(baseobj.BaseObj)

class fattr4_time_modify(baseobj.BaseObj)

fattr4_time_modify = class nfstime4(baseobj.BaseObj)

class fattr4_time_modify_set(baseobj.BaseObj)

fattr4_time_modify_set = class settime4(baseobj.BaseObj)

class fattr4_type(packet.utils.Enum)

fattr4_type = class nfs_ftype4(packet.utils.Enum)

class fattr4_unique_handles(packet.utils.Enum)

fattr4_unique_handles = class nfs_bool(packet.utils.Enum)

class ff_cb_recall_any_mask(packet.utils.Enum)

enum ff_cb_recall_any_mask

class ff_data_server4(baseobj.BaseObj)

struct ff_data_server4 {
 deviceid4 deviceid;
 uint32_t efficiency;
 stateid4 stateid;
 nfs_fh4 fh_list<>;
 fattr4_owner user;
 fattr4_owner_group group;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ff_device_addr4(baseobj.BaseObj)

struct ff_device_addr4 {
 uint32_t size; /* opaque size from device_addr4 */
 multipath_list4 netaddrs;
 ff_device_versions4 versions<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ff_device_versions4(baseobj.BaseObj)

struct ff_device_versions4 {
 uint32_t version;
 uint32_t minorversion;
 uint32_t rsize;
 uint32_t wsize;
 bool tightly_coupled;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ff_io_latency4(baseobj.BaseObj)

struct ff_io_latency4 {
 uint64_t ops_requested;
 uint64_t bytes_requested;
 uint64_t ops_completed;
 uint64_t bytes_completed;
 uint64_t bytes_not_delivered;
 nfstime4 total_busy_time;
 nfstime4 aggregate_completion_time;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ff_ioerr4(baseobj.BaseObj)

struct ff_ioerr4 {
 offset4 offset;
 length4 length;
 stateid4 stateid;
 device_error4 errors<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ff_iostats4(baseobj.BaseObj)

struct ff_iostats4 {
 offset4 offset;
 length4 length;
 stateid4 stateid;
 io_info4 read;
 io_info4 write;
 deviceid4 deviceid;
 ff_layoutupdate4 layoutupdate;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ff_layout4(baseobj.BaseObj)

struct ff_layout4 {
 uint32_t size; /* opaque size from layout_content4 */
 length4 stripe_unit;
 ff_mirror4 mirrors<>;
 ff_flags4 flags;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ff_layouthint4(baseobj.BaseObj)

struct ff_layouthint4 {
 ff_mirrors_hint mirrors_hint;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ff_layoutreturn4(baseobj.BaseObj)

struct ff_layoutreturn4 {
 uint32_t size; /* opaque size from layoutreturn_file4 */
 ff_ioerr4 ioerr_report<>;
 ff_iostats4 iostats_report<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ff_layoutupdate4(baseobj.BaseObj)

struct ff_layoutupdate4 {
 netaddr4 addr;
 nfs_fh4 fh;
 ff_io_latency4 read;
 ff_io_latency4 write;
 nfstime4 duration;
 bool local;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ff_mirror4(baseobj.BaseObj)

struct ff_mirror4 {
 ff_data_server4 data_servers<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ff_mirrors_hint(baseobj.BaseObj)

union switch ff_mirrors_hint (bool ffmc_valid) {
 case const.TRUE:
 uint32_t mirrors;
 case const.FALSE:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class filelayout_hint_care4(packet.utils.Enum)

enum filelayout_hint_care4

class fs4_status(baseobj.BaseObj)

struct fs4_status {
 bool absent;
 fs4_status_type type;
 utf8str_cs source;
 utf8str_cs current;
 int32_t age;
 nfstime4 version;
};
Methods defined here:
---------------------
__init__(self, unpack)

class fs4_status_type(packet.utils.Enum)

enum fs4_status_type

class fs_location4(baseobj.BaseObj)

struct fs_location4 {
 utf8str_cis server<>;
 pathname4 root;
};
Methods defined here:
---------------------
__init__(self, unpack)

class fs_locations4(baseobj.BaseObj)

struct fs_locations4 {
 pathname4 root;
 fs_location4 locations<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class fs_locations_info4(baseobj.BaseObj)

struct fs_locations_info4 {
 uint32_t flags;
 int32_t valid_for;
 pathname4 root;
 fs_locations_item4 items<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class fs_locations_item4(baseobj.BaseObj)

struct fs_locations_item4 {
 fs_locations_server4 entries<>;
 pathname4 root;
};
Methods defined here:
---------------------
__init__(self, unpack)

class fs_locations_server4(baseobj.BaseObj)

struct fs_locations_server4 {
 int32_t currency;
 opaque info<>;
 utf8str_cis server;
};
Methods defined here:
---------------------
__init__(self, unpack)

class fsid4(baseobj.BaseObj)

struct fsid4 {
 uint64_t major;
 uint64_t minor;
};
Methods defined here:
---------------------
__init__(self, unpack)

class gddrnf4_status(packet.utils.Enum)

enum gddrnf4_status

class gss_cb_handles4(baseobj.BaseObj)

struct gss_cb_handles4 {
 rpc_gss_svc_t service; /* RFC 2203 */
 gsshandle4_t server_handle;
 gsshandle4_t client_handle;
};
Methods defined here:
---------------------
__init__(self, unpack)

class io_info4(baseobj.BaseObj)

struct io_info4 {
 uint64_t count;
 uint64_t bytes;
};
Methods defined here:
---------------------
__init__(self, unpack)

class labelformat_spec4(baseobj.BaseObj)

struct labelformat_spec4 {
 policy4 lfs;
 policy4 pi;
};
Methods defined here:
---------------------
__init__(self, unpack)

class layout4(baseobj.BaseObj)

struct layout4 {
 offset4 offset;
 length4 length;
 layoutiomode4 iomode;
 layout_content4 content;
};
Methods defined here:
---------------------
__init__(self, unpack)

class layout_content4(baseobj.BaseObj)

union switch layout_content4 (layouttype4 type) {
 case const.LAYOUT4_NFSV4_1_FILES:
 nfsv4_1_file_layout4 body;
 case const.LAYOUT4_FLEX_FILES:
 ff_layout4 body;
 default:
 /* All other types are not supported yet */
 opaque body<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class layouthint4(baseobj.BaseObj)

union switch layouthint4 (layouttype4 type) {
 case const.LAYOUT4_NFSV4_1_FILES:
 nfsv4_1_file_layouthint4 body;
 case const.LAYOUT4_FLEX_FILES:
 ff_layouthint4 body;
 default:
 /* All other types are not supported yet */
 opaque body<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class layoutiomode4(packet.utils.Enum)

enum layoutiomode4

class layoutrecall4(baseobj.BaseObj)

union switch layoutrecall4 (layoutrecall_type4 recalltype) {
 case const.LAYOUTRECALL4_FILE:
 layoutrecall_file4 layout;
 case const.LAYOUTRECALL4_FSID:
 fsid4 fsid;
 case const.LAYOUTRECALL4_ALL:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class layoutrecall_file4(baseobj.BaseObj)

struct layoutrecall_file4 {
 nfs_fh4 fh;
 offset4 offset;
 length4 length;
 stateid4 stateid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class layoutrecall_type4(packet.utils.Enum)

enum layoutrecall_type4

class layoutreturn4(baseobj.BaseObj)

union switch layoutreturn4 (layoutreturn_type4 returntype) {
 case const.LAYOUTRETURN4_FILE:
 layoutreturn_file4 layout;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class layoutreturn_file4(baseobj.BaseObj)

struct layoutreturn_file4 {
 offset4 offset;
 length4 length;
 stateid4 stateid;
 /* layouttype4 specific data */
 layoutreturn_file_body4 data;
};
Methods defined here:
---------------------
__init__(self, unpack)

class layoutreturn_file_body4(baseobj.BaseObj)

union switch layoutreturn_file_body4 (layouttype4 nfs4_layouttype) {
 case const.LAYOUT4_FLEX_FILES:
 ff_layoutreturn4 body;
 default:
 /* All other types are not supported yet or not used */
 opaque body<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class layoutreturn_stateid(baseobj.BaseObj)

union switch layoutreturn_stateid (bool present) {
 case const.TRUE:
 stateid4 stateid;
 case const.FALSE:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class layoutreturn_type4(packet.utils.Enum)

enum layoutreturn_type4

class layouttype4(packet.utils.Enum)

enum layouttype4

class layoutupdate4(baseobj.BaseObj)

struct layoutupdate4 {
 layouttype4 type;
 opaque body<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class limit_by4(packet.utils.Enum)

enum limit_by4

class lock_owner4(baseobj.BaseObj)

lock_owner4 = class state_owner4(baseobj.BaseObj)

class locker4(baseobj.BaseObj)

union switch locker4 (bool new_lock_owner) {
 case const.TRUE:
 open_to_lock_owner4 open_owner;
 case const.FALSE:
 exist_lock_owner4 lock_owner;
};
Methods defined here:
---------------------
__init__(self, unpack)

class mdsthreshold4(baseobj.BaseObj)

struct mdsthreshold4 {
 threshold_item4 hints<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class mode_masked4(baseobj.BaseObj)

struct mode_masked4 {
 mode4 values; /* Values of bits to set or reset in mode. */
 mode4 mask; /* Mask of bits to set or reset in mode. */
};
Methods defined here:
---------------------
__init__(self, unpack)

class netaddr4(baseobj.BaseObj)

netaddr4 = class clientaddr4(baseobj.BaseObj)

class netloc4(baseobj.BaseObj)

union switch netloc4 (netloc_type4 type) {
 case const.NL4_NAME:
 utf8str_cis name;
 case const.NL4_URL:
 utf8str_cis url;
 case const.NL4_NETADDR:
 netaddr4 addr;
};
Methods defined here:
---------------------
__init__(self, unpack)

class netloc_type4(packet.utils.Enum)

enum netloc_type4

class newoffset4(baseobj.BaseObj)

union switch newoffset4 (bool newoffset) {
 case const.TRUE:
 offset4 offset;
 case const.FALSE:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class newsize4(baseobj.BaseObj)

union switch newsize4 (bool sizechanged) {
 case const.TRUE:
 length4 size;
 case const.FALSE:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class newtime4(baseobj.BaseObj)

union switch newtime4 (bool timechanged) {
 case const.TRUE:
 nfstime4 time;
 case const.FALSE:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class nfs_argop4(baseobj.BaseObj)

union switch nfs_argop4 (nfs_opnum4 argop) {
 case const.OP_ACCESS:
 ACCESS4args opaccess;
 case const.OP_CLOSE:
 CLOSE4args opclose;
 case const.OP_COMMIT:
 COMMIT4args opcommit;
 case const.OP_CREATE:
 CREATE4args opcreate;
 case const.OP_DELEGPURGE:
 DELEGPURGE4args opdelegpurge;
 case const.OP_DELEGRETURN:
 DELEGRETURN4args opdelegreturn;
 case const.OP_GETATTR:
 GETATTR4args opgetattr;
 case const.OP_GETFH:
 void;
 case const.OP_LINK:
 LINK4args oplink;
 case const.OP_LOCK:
 LOCK4args oplock;
 case const.OP_LOCKT:
 LOCKT4args oplockt;
 case const.OP_LOCKU:
 LOCKU4args oplocku;
 case const.OP_LOOKUP:
 LOOKUP4args oplookup;
 case const.OP_LOOKUPP:
 void;
 case const.OP_NVERIFY:
 NVERIFY4args opnverify;
 case const.OP_OPEN:
 OPEN4args opopen;
 case const.OP_OPENATTR:
 OPENATTR4args opopenattr;
 case const.OP_OPEN_CONFIRM:
 /* Not used in NFSv4.1 */
 OPEN_CONFIRM4args opopen_confirm;
 case const.OP_OPEN_DOWNGRADE:
 OPEN_DOWNGRADE4args opopen_downgrade;
 case const.OP_PUTFH:
 PUTFH4args opputfh;
 case const.OP_PUTPUBFH:
 void;
 case const.OP_PUTROOTFH:
 void;
 case const.OP_READ:
 READ4args opread;
 case const.OP_READDIR:
 READDIR4args opreaddir;
 case const.OP_READLINK:
 void;
 case const.OP_REMOVE:
 REMOVE4args opremove;
 case const.OP_RENAME:
 RENAME4args oprename;
 case const.OP_RENEW:
 /* Not used in NFSv4.1 */
 RENEW4args oprenew;
 case const.OP_RESTOREFH:
 void;
 case const.OP_SAVEFH:
 void;
 case const.OP_SECINFO:
 SECINFO4args opsecinfo;
 case const.OP_SETATTR:
 SETATTR4args opsetattr;
 case const.OP_SETCLIENTID:
 /* Not used in NFSv4.1 */
 SETCLIENTID4args opsetclientid;
 case const.OP_SETCLIENTID_CONFIRM:
 /* Not used in NFSv4.1 */
 SETCLIENTID_CONFIRM4args opsetclientid_confirm;
 case const.OP_VERIFY:
 VERIFY4args opverify;
 case const.OP_WRITE:
 WRITE4args opwrite;
 case const.OP_RELEASE_LOCKOWNER:
 /* Not used in NFSv4.1 */
 RELEASE_LOCKOWNER4args oprelease_lockowner;
 /*
 * New to NFSv4.1
 */
 case const.OP_BACKCHANNEL_CTL:
 BACKCHANNEL_CTL4args opbackchannel_ctl;
 case const.OP_BIND_CONN_TO_SESSION:
 BIND_CONN_TO_SESSION4args opbind_conn_to_session;
 case const.OP_EXCHANGE_ID:
 EXCHANGE_ID4args opexchange_id;
 case const.OP_CREATE_SESSION:
 CREATE_SESSION4args opcreate_session;
 case const.OP_DESTROY_SESSION:
 DESTROY_SESSION4args opdestroy_session;
 case const.OP_FREE_STATEID:
 FREE_STATEID4args opfree_stateid;
 case const.OP_GET_DIR_DELEGATION:
 GET_DIR_DELEGATION4args opget_dir_delegation;
 case const.OP_GETDEVICEINFO:
 GETDEVICEINFO4args opgetdeviceinfo;
 case const.OP_GETDEVICELIST:
 /* Not used in NFSv4.2 */
 GETDEVICELIST4args opgetdevicelist;
 case const.OP_LAYOUTCOMMIT:
 LAYOUTCOMMIT4args oplayoutcommit;
 case const.OP_LAYOUTGET:
 LAYOUTGET4args oplayoutget;
 case const.OP_LAYOUTRETURN:
 LAYOUTRETURN4args oplayoutreturn;
 case const.OP_SECINFO_NO_NAME:
 SECINFO_NO_NAME4args opsecinfo_no_name;
 case const.OP_SEQUENCE:
 SEQUENCE4args opsequence;
 case const.OP_SET_SSV:
 SET_SSV4args opset_ssv;
 case const.OP_TEST_STATEID:
 TEST_STATEID4args optest_stateid;
 case const.OP_WANT_DELEGATION:
 WANT_DELEGATION4args opwant_delegation;
 case const.OP_DESTROY_CLIENTID:
 DESTROY_CLIENTID4args opdestroy_clientid;
 case const.OP_RECLAIM_COMPLETE:
 RECLAIM_COMPLETE4args opreclaim_complete;
 /*
 * New to NFSv4.2
 */
 case const.OP_ALLOCATE:
 ALLOCATE4args opallocate;
 case const.OP_COPY:
 COPY4args opcopy;
 case const.OP_COPY_NOTIFY:
 COPY_NOTIFY4args opcopy_notify;
 case const.OP_DEALLOCATE:
 DEALLOCATE4args opdeallocate;
 case const.OP_IO_ADVISE:
 IO_ADVISE4args opio_advise;
 case const.OP_LAYOUTERROR:
 LAYOUTERROR4args oplayouterror;
 case const.OP_LAYOUTSTATS:
 LAYOUTSTATS4args oplayoutstats;
 case const.OP_OFFLOAD_CANCEL:
 OFFLOAD_CANCEL4args opoffload_cancel;
 case const.OP_OFFLOAD_STATUS:
 OFFLOAD_STATUS4args opoffload_status;
 case const.OP_READ_PLUS:
 READ_PLUS4args opread_plus;
 case const.OP_SEEK:
 SEEK4args opseek;
 case const.OP_WRITE_SAME:
 WRITE_SAME4args opwrite_same;
 case const.OP_CLONE:
 CLONE4args opclone;
 case const.OP_ILLEGAL:
 /* Illegal operation */
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class nfs_bool(packet.utils.Enum)

enum nfs_bool

class nfs_cb_argop4(baseobj.BaseObj)

union switch nfs_cb_argop4 (nfs_cb_opnum4 argop) {
 case const.OP_CB_GETATTR:
 CB_GETATTR4args opcbgetattr;
 case const.OP_CB_RECALL:
 CB_RECALL4args opcbrecall;
 /*
 * New to NFSv4.1
 */
 case const.OP_CB_LAYOUTRECALL:
 CB_LAYOUTRECALL4args opcblayoutrecall;
 case const.OP_CB_NOTIFY:
 CB_NOTIFY4args opcbnotify;
 case const.OP_CB_PUSH_DELEG:
 CB_PUSH_DELEG4args opcbpush_deleg;
 case const.OP_CB_RECALL_ANY:
 CB_RECALL_ANY4args opcbrecall_any;
 case const.OP_CB_RECALLABLE_OBJ_AVAIL:
 CB_RECALLABLE_OBJ_AVAIL4args opcbrecallable_obj_avail;
 case const.OP_CB_RECALL_SLOT:
 CB_RECALL_SLOT4args opcbrecall_slot;
 case const.OP_CB_SEQUENCE:
 CB_SEQUENCE4args opcbsequence;
 case const.OP_CB_WANTS_CANCELLED:
 CB_WANTS_CANCELLED4args opcbwants_cancelled;
 case const.OP_CB_NOTIFY_LOCK:
 CB_NOTIFY_LOCK4args opcbnotify_lock;
 case const.OP_CB_NOTIFY_DEVICEID:
 CB_NOTIFY_DEVICEID4args opcbnotify_deviceid;
 /*
 * New to NFSv4.2
 */
 case const.OP_CB_OFFLOAD:
 CB_OFFLOAD4args opcboffload;
 case const.OP_CB_ILLEGAL:
 /* Illegal callback operation */
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class nfs_cb_opnum4(packet.utils.Enum)

enum nfs_cb_opnum4

class nfs_cb_resop4(baseobj.BaseObj)

union switch nfs_cb_resop4 (nfs_cb_opnum4 resop) {
 case const.OP_CB_GETATTR:
 CB_GETATTR4res opcbgetattr;
 case const.OP_CB_RECALL:
 CB_RECALL4res opcbrecall;
 /*
 * New to NFSv4.1
 */
 case const.OP_CB_LAYOUTRECALL:
 CB_LAYOUTRECALL4res opcblayoutrecall;
 case const.OP_CB_NOTIFY:
 CB_NOTIFY4res opcbnotify;
 case const.OP_CB_PUSH_DELEG:
 CB_PUSH_DELEG4res opcbpush_deleg;
 case const.OP_CB_RECALL_ANY:
 CB_RECALL_ANY4res opcbrecall_any;
 case const.OP_CB_RECALLABLE_OBJ_AVAIL:
 CB_RECALLABLE_OBJ_AVAIL4res opcbrecallable_obj_avail;
 case const.OP_CB_RECALL_SLOT:
 CB_RECALL_SLOT4res opcbrecall_slot;
 case const.OP_CB_SEQUENCE:
 CB_SEQUENCE4res opcbsequence;
 case const.OP_CB_WANTS_CANCELLED:
 CB_WANTS_CANCELLED4res opcbwants_cancelled;
 case const.OP_CB_NOTIFY_LOCK:
 CB_NOTIFY_LOCK4res opcbnotify_lock;
 case const.OP_CB_NOTIFY_DEVICEID:
 CB_NOTIFY_DEVICEID4res opcbnotify_deviceid;
 /*
 * New to NFSv4.2
 */
 case const.OP_CB_OFFLOAD:
 CB_OFFLOAD4res opcboffload;
 case const.OP_CB_ILLEGAL:
 /* Illegal callback operation */
 CB_ILLEGAL4res opcbillegal;
};
Methods defined here:
---------------------
__init__(self, unpack)

class nfs_client_id4(baseobj.BaseObj)

struct nfs_client_id4 {
 verifier4 verifier;
 opaque id<NFS4_OPAQUE_LIMIT>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class nfs_fattr4(packet.utils.Enum)

enum nfs_fattr4

class nfs_ftype4(packet.utils.Enum)

enum nfs_ftype4

class nfs_impl_id4(baseobj.BaseObj)

struct nfs_impl_id4 {
 utf8str_cis domain;
 utf8str_cs name;
 nfstime4 date;
};
Methods defined here:
---------------------
__init__(self, unpack)

class nfs_lock_type4(packet.utils.Enum)

enum nfs_lock_type4

class nfs_modified_limit4(baseobj.BaseObj)

struct nfs_modified_limit4 {
 uint32_t num_blocks;
 uint32_t bytes_per_block;
};
Methods defined here:
---------------------
__init__(self, unpack)

class nfs_opnum4(packet.utils.Enum)

enum nfs_opnum4

class nfs_resop4(baseobj.BaseObj)

union switch nfs_resop4 (nfs_opnum4 resop) {
 case const.OP_ACCESS:
 ACCESS4res opaccess;
 case const.OP_CLOSE:
 CLOSE4res opclose;
 case const.OP_COMMIT:
 COMMIT4res opcommit;
 case const.OP_CREATE:
 CREATE4res opcreate;
 case const.OP_DELEGPURGE:
 DELEGPURGE4res opdelegpurge;
 case const.OP_DELEGRETURN:
 DELEGRETURN4res opdelegreturn;
 case const.OP_GETATTR:
 GETATTR4res opgetattr;
 case const.OP_GETFH:
 GETFH4res opgetfh;
 case const.OP_LINK:
 LINK4res oplink;
 case const.OP_LOCK:
 LOCK4res oplock;
 case const.OP_LOCKT:
 LOCKT4res oplockt;
 case const.OP_LOCKU:
 LOCKU4res oplocku;
 case const.OP_LOOKUP:
 LOOKUP4res oplookup;
 case const.OP_LOOKUPP:
 LOOKUPP4res oplookupp;
 case const.OP_NVERIFY:
 NVERIFY4res opnverify;
 case const.OP_OPEN:
 OPEN4res opopen;
 case const.OP_OPENATTR:
 OPENATTR4res opopenattr;
 case const.OP_OPEN_CONFIRM:
 /* Not used in NFSv4.1 */
 OPEN_CONFIRM4res opopen_confirm;
 case const.OP_OPEN_DOWNGRADE:
 OPEN_DOWNGRADE4res opopen_downgrade;
 case const.OP_PUTFH:
 PUTFH4res opputfh;
 case const.OP_PUTPUBFH:
 PUTPUBFH4res opputpubfh;
 case const.OP_PUTROOTFH:
 PUTROOTFH4res opputrootfh;
 case const.OP_READ:
 READ4res opread;
 case const.OP_READDIR:
 READDIR4res opreaddir;
 case const.OP_READLINK:
 READLINK4res opreadlink;
 case const.OP_REMOVE:
 REMOVE4res opremove;
 case const.OP_RENAME:
 RENAME4res oprename;
 case const.OP_RENEW:
 /* Not used in NFSv4.1 */
 RENEW4res oprenew;
 case const.OP_RESTOREFH:
 RESTOREFH4res oprestorefh;
 case const.OP_SAVEFH:
 SAVEFH4res opsavefh;
 case const.OP_SECINFO:
 SECINFO4res opsecinfo;
 case const.OP_SETATTR:
 SETATTR4res opsetattr;
 case const.OP_SETCLIENTID:
 /* Not used in NFSv4.1 */
 SETCLIENTID4res opsetclientid;
 case const.OP_SETCLIENTID_CONFIRM:
 /* Not used in NFSv4.1 */
 SETCLIENTID_CONFIRM4res opsetclientid_confirm;
 case const.OP_VERIFY:
 VERIFY4res opverify;
 case const.OP_WRITE:
 WRITE4res opwrite;
 case const.OP_RELEASE_LOCKOWNER:
 /* Not used in NFSv4.1 */
 RELEASE_LOCKOWNER4res oprelease_lockowner;
 /*
 * New to NFSv4.1
 */
 case const.OP_BACKCHANNEL_CTL:
 BACKCHANNEL_CTL4res opbackchannel_ctl;
 case const.OP_BIND_CONN_TO_SESSION:
 BIND_CONN_TO_SESSION4res opbind_conn_to_session;
 case const.OP_EXCHANGE_ID:
 EXCHANGE_ID4res opexchange_id;
 case const.OP_CREATE_SESSION:
 CREATE_SESSION4res opcreate_session;
 case const.OP_DESTROY_SESSION:
 DESTROY_SESSION4res opdestroy_session;
 case const.OP_FREE_STATEID:
 FREE_STATEID4res opfree_stateid;
 case const.OP_GET_DIR_DELEGATION:
 GET_DIR_DELEGATION4res opget_dir_delegation;
 case const.OP_GETDEVICEINFO:
 GETDEVICEINFO4res opgetdeviceinfo;
 case const.OP_GETDEVICELIST:
 /* Not used in NFSv4.2 */
 GETDEVICELIST4res opgetdevicelist;
 case const.OP_LAYOUTCOMMIT:
 LAYOUTCOMMIT4res oplayoutcommit;
 case const.OP_LAYOUTGET:
 LAYOUTGET4res oplayoutget;
 case const.OP_LAYOUTRETURN:
 LAYOUTRETURN4res oplayoutreturn;
 case const.OP_SECINFO_NO_NAME:
 SECINFO_NO_NAME4res opsecinfo_no_name;
 case const.OP_SEQUENCE:
 SEQUENCE4res opsequence;
 case const.OP_SET_SSV:
 SET_SSV4res opset_ssv;
 case const.OP_TEST_STATEID:
 TEST_STATEID4res optest_stateid;
 case const.OP_WANT_DELEGATION:
 WANT_DELEGATION4res opwant_delegation;
 case const.OP_DESTROY_CLIENTID:
 DESTROY_CLIENTID4res opdestroy_clientid;
 case const.OP_RECLAIM_COMPLETE:
 RECLAIM_COMPLETE4res opreclaim_complete;
 /*
 * New to NFSv4.2
 */
 case const.OP_ALLOCATE:
 ALLOCATE4res opallocate;
 case const.OP_COPY:
 COPY4res opcopy;
 case const.OP_COPY_NOTIFY:
 COPY_NOTIFY4res opcopy_notify;
 case const.OP_DEALLOCATE:
 DEALLOCATE4res opdeallocate;
 case const.OP_IO_ADVISE:
 IO_ADVISE4res opio_advise;
 case const.OP_LAYOUTERROR:
 LAYOUTERROR4res oplayouterror;
 case const.OP_LAYOUTSTATS:
 LAYOUTSTATS4res oplayoutstats;
 case const.OP_OFFLOAD_CANCEL:
 OFFLOAD_CANCEL4res opoffload_cancel;
 case const.OP_OFFLOAD_STATUS:
 OFFLOAD_STATUS4res opoffload_status;
 case const.OP_READ_PLUS:
 READ_PLUS4res opread_plus;
 case const.OP_SEEK:
 SEEK4res opseek;
 case const.OP_WRITE_SAME:
 WRITE_SAME4res opwrite_same;
 case const.OP_CLONE:
 CLONE4res opclone;
 case const.OP_ILLEGAL:
 /* Illegal operation */
 ILLEGAL4res opillegal;
};
Methods defined here:
---------------------
__init__(self, unpack)

class nfs_secflavor4(packet.utils.Enum)

enum nfs_secflavor4

class nfs_space_limit4(baseobj.BaseObj)

union switch nfs_space_limit4 (limit_by4 limitby) {
 /* limit specified as file size */
 case const.NFS_LIMIT_SIZE:
 uint64_t filesize;
 /* limit specified by number of blocks */
 case const.NFS_LIMIT_BLOCKS:
 nfs_modified_limit4 mod_blocks;
};
Methods defined here:
---------------------
__init__(self, unpack)

class nfsace4(baseobj.BaseObj)

struct nfsace4 {
 acetype4 type;
 aceflag4 flag;
 acemask4 mask;
 utf8str_mixed who;
};
Methods defined here:
---------------------
__init__(self, unpack)

class nfsacl41(baseobj.BaseObj)

struct nfsacl41 {
 aclflag4 flag;
 nfsace4 aces<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class nfsstat4(packet.utils.Enum)

enum nfsstat4

class nfstime4(baseobj.BaseObj)

struct nfstime4 {
 int64_t seconds;
 uint32_t nseconds;
};
Methods defined here:
---------------------
__init__(self, unpack)

class nfsv4_1_file_layout4(baseobj.BaseObj)

struct nfsv4_1_file_layout4 {
 uint32_t size; /* opaque size from layout_content4 */
 deviceid4 deviceid;
 nfl_util4 nfl_util;
 uint32_t first_stripe_index;
 offset4 pattern_offset;
 nfs_fh4 fh_list<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class nfsv4_1_file_layout_ds_addr4(baseobj.BaseObj)

struct nfsv4_1_file_layout_ds_addr4 {
 uint32_t size; /* opaque size from device_addr4 */
 uint32_t stripe_indices<>;
 multipath_list4 multipath_ds_list<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class nfsv4_1_file_layouthint4(baseobj.BaseObj)

struct nfsv4_1_file_layouthint4 {
 uint32_t size; /* opaque size from layouthint4 */
 uint32_t care;
 nfl_util4 nfl_util;
 count4 stripe_count;
};
Methods defined here:
---------------------
__init__(self, unpack)

class notify4(baseobj.BaseObj)

struct notify4 {
 /* composed from notify_type4 or notify_deviceid_type4 */
 bitmap4 mask;
 notifylist4 values;
};
Methods defined here:
---------------------
__init__(self, unpack)

class notify_add4(baseobj.BaseObj)

struct notify_add4 {
 /*
 * Information on object
 * possibly renamed over.
 */
 notify_remove4 old_entry<1>;
 notify_entry4 new_entry;
 /* what READDIR would have returned for this entry */
 nfs_cookie4 new_cookie<1>;
 prev_entry4 prev_entry<1>;
 bool last_entry;
};
Methods defined here:
---------------------
__init__(self, unpack)

class notify_attr4(baseobj.BaseObj)

struct notify_attr4 {
 notify_entry4 entry;
};
Methods defined here:
---------------------
__init__(self, unpack)

class notify_deviceid_change4(baseobj.BaseObj)

struct notify_deviceid_change4 {
 layouttype4 type;
 deviceid4 deviceid;
 bool immediate;
};
Methods defined here:
---------------------
__init__(self, unpack)

class notify_deviceid_delete4(baseobj.BaseObj)

struct notify_deviceid_delete4 {
 layouttype4 type;
 deviceid4 deviceid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class notify_deviceid_type4(packet.utils.Enum)

enum notify_deviceid_type4

class notify_entry4(baseobj.BaseObj)

struct notify_entry4 {
 component4 name;
 fattr4 attrs;
};
Methods defined here:
---------------------
__init__(self, unpack)

class notify_remove4(baseobj.BaseObj)

struct notify_remove4 {
 notify_entry4 entry;
 nfs_cookie4 cookie;
};
Methods defined here:
---------------------
__init__(self, unpack)

class notify_rename4(baseobj.BaseObj)

struct notify_rename4 {
 notify_remove4 old_entry;
 notify_add4 new_entry;
};
Methods defined here:
---------------------
__init__(self, unpack)

class notify_type4(packet.utils.Enum)

enum notify_type4

class notify_verifier4(baseobj.BaseObj)

struct notify_verifier4 {
 verifier4 old_verifier;
 verifier4 new_verifier;
};
Methods defined here:
---------------------
__init__(self, unpack)

class offload_info4(baseobj.BaseObj)

union switch offload_info4 (nfsstat4 status) {
 case const.NFS4_OK:
 write_response4 resok;
 default:
 length4 count;
};
Methods defined here:
---------------------
__init__(self, unpack)

class open_claim4(baseobj.BaseObj)

union switch open_claim4 (open_claim_type4 claim) {
 /*
 * No special rights to file.
 * Ordinary OPEN of the specified file.
 */
 case const.CLAIM_NULL:
 /* CURRENT_FH: directory */
 component4 name;
 /*
 * Right to the file established by an
 * open previous to server reboot. File
 * identified by filehandle obtained at
 * that time rather than by name.
 */
 case const.CLAIM_PREVIOUS:
 /* CURRENT_FH: file being reclaimed */
 open_delegation_type4 deleg_type;
 /*
 * Right to file based on a delegation
 * granted by the server. File is
 * specified by name.
 */
 case const.CLAIM_DELEGATE_CUR:
 /* CURRENT_FH: directory */
 open_claim_delegate_cur4 deleg_info;
 /*
 * Right to file based on a delegation
 * granted to a previous boot instance
 * of the client. File is specified by name.
 */
 case const.CLAIM_DELEGATE_PREV:
 /* CURRENT_FH: directory */
 component4 name;
 /*
 * Like CLAIM_NULL. No special rights
 * to file. Ordinary OPEN of the
 * specified file by current filehandle.
 */
 case const.CLAIM_FH: /* New to NFSv4.1 */
 /* CURRENT_FH: regular file to open */
 void;
 /*
 * Like CLAIM_DELEGATE_PREV. Right to file based on a
 * delegation granted to a previous boot
 * instance of the client. File is identified by
 * by filehandle.
 */
 case const.CLAIM_DELEG_PREV_FH: /* New to NFSv4.1 */
 /* CURRENT_FH: file being opened */
 void;
 /*
 * Like CLAIM_DELEGATE_CUR. Right to file based on
 * a delegation granted by the server.
 * File is identified by filehandle.
 */
 case const.CLAIM_DELEG_CUR_FH: /* New to NFSv4.1 */
 /* CURRENT_FH: file being opened */
 stateid4 stateid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class open_claim_delegate_cur4(baseobj.BaseObj)

struct open_claim_delegate_cur4 {
 stateid4 stateid;
 component4 name;
};
Methods defined here:
---------------------
__init__(self, unpack)

class open_claim_type4(packet.utils.Enum)

enum open_claim_type4

class open_delegation4(baseobj.BaseObj)

union switch open_delegation4 (open_delegation_type4 deleg_type) {
 case const.OPEN_DELEGATE_NONE:
 void;
 case const.OPEN_DELEGATE_READ:
 open_read_delegation4 read;
 case const.OPEN_DELEGATE_WRITE:
 open_write_delegation4 write;
 case const.OPEN_DELEGATE_NONE_EXT: /* New to NFSv4.1 */
 open_none_delegation4 whynone;
};
Methods defined here:
---------------------
__init__(self, unpack)

class open_delegation_type4(packet.utils.Enum)

enum open_delegation_type4

class open_none_delegation4(baseobj.BaseObj)

union switch open_none_delegation4 (why_no_delegation4 why) {
 case const.WND4_CONTENTION:
 /* Server will push delegation */
 bool push;
 case const.WND4_RESOURCE:
 /* Server will signal availability */
 bool signal;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class open_owner4(baseobj.BaseObj)

open_owner4 = class state_owner4(baseobj.BaseObj)

class open_read_delegation4(baseobj.BaseObj)

struct open_read_delegation4 {
 stateid4 stateid; /* Stateid for delegation */
 bool recall; /* Pre-recalled flag for delegations obtained by reclaim (CLAIM_PREVIOUS) */
 nfsace4 permissions; /* Defines users who don't need an ACCESS call to open for read */
};
Methods defined here:
---------------------
__init__(self, unpack)

class open_to_lock_owner4(baseobj.BaseObj)

struct open_to_lock_owner4 {
 seqid4 seqid;
 stateid4 stateid;
 seqid4 lock_seqid;
 lock_owner4 lock_owner;
};
Methods defined here:
---------------------
__init__(self, unpack)

class open_write_delegation4(baseobj.BaseObj)

struct open_write_delegation4 {
 stateid4 stateid; /* Stateid for delegation */
 bool recall; /* Pre-recalled flag for delegations obtained by reclaim (CLAIM_PREVIOUS) */
 nfs_space_limit4 space_limit; /* Defines condition that the client must check to determine whether the file needs to be flushed to the server on close. */
 nfsace4 permissions; /* Defines users who don't need an ACCESS call as part of a delegated open. */
};
Methods defined here:
---------------------
__init__(self, unpack)

class openflag4(baseobj.BaseObj)

union switch openflag4 (opentype4 opentype) {
 case const.OPEN4_CREATE:
 createhow4 how;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class opentype4(packet.utils.Enum)

enum opentype4

class prev_entry4(baseobj.BaseObj)

struct prev_entry4 {
 notify_entry4 entry;
 /* what READDIR returned for this entry */
 nfs_cookie4 cookie;
};
Methods defined here:
---------------------
__init__(self, unpack)

class read_plus_content(baseobj.BaseObj)

union switch read_plus_content (data_content4 content) {
 case const.NFS4_CONTENT_DATA:
 data4 data;
 case const.NFS4_CONTENT_HOLE:
 data_info4 hole;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class read_plus_res4(baseobj.BaseObj)

struct read_plus_res4 {
 bool eof;
 read_plus_content contents<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class referring_call4(baseobj.BaseObj)

struct referring_call4 {
 sequenceid4 sequenceid;
 slotid4 slotid;
};
Methods defined here:
---------------------
__init__(self, unpack)

class referring_call_list4(baseobj.BaseObj)

struct referring_call_list4 {
 sessionid4 sessionid;
 referring_call4 referring_calls<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class retention_get4(baseobj.BaseObj)

struct retention_get4 {
 uint64_t duration;
 nfstime4 begin_time<1>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class retention_set4(baseobj.BaseObj)

struct retention_set4 {
 bool enable;
 uint64_t duration<1>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class rpc_gss_svc_t(packet.utils.Enum)

enum rpc_gss_svc_t

class rpcsec_gss_info(baseobj.BaseObj)

struct rpcsec_gss_info {
 sec_oid4 oid;
 qop4 qop;
 rpc_gss_svc_t service;
};
Methods defined here:
---------------------
__init__(self, unpack)

class sec_label4(baseobj.BaseObj)

struct sec_label4 {
 labelformat_spec4 lfs;
 opaque data<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class secinfo4(baseobj.BaseObj)

union switch secinfo4 (nfs_secflavor4 flavor) {
 case const.RPCSEC_GSS:
 rpcsec_gss_info info;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class secinfo_style4(packet.utils.Enum)

enum secinfo_style4

class seek_res4(baseobj.BaseObj)

struct seek_res4 {
 bool eof;
 offset4 offset;
};
Methods defined here:
---------------------
__init__(self, unpack)

class server_owner4(baseobj.BaseObj)

struct server_owner4 {
 uint64_t minor_id;
 opaque major_id<NFS4_OPAQUE_LIMIT>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class settime4(baseobj.BaseObj)

union switch settime4 (time_how4 set_it) {
 case const.SET_TO_CLIENT_TIME4:
 nfstime4 time;
 default:
 void;
};
Methods defined here:
---------------------
__init__(self, unpack)

class specdata4(baseobj.BaseObj)

struct specdata4 {
 uint32_t specdata1; /* major device number */
 uint32_t specdata2; /* minor device number */
};
Methods defined here:
---------------------
__init__(self, unpack)

class ssa_digest_input4(baseobj.BaseObj)

struct ssa_digest_input4 {
 SEQUENCE4args seqargs;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ssr_digest_input4(baseobj.BaseObj)

struct ssr_digest_input4 {
 SEQUENCE4res seqres;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ssv_mic_plain_tkn4(baseobj.BaseObj)

struct ssv_mic_plain_tkn4 {
 uint32_t ssv_seq;
 opaque orig_plain<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ssv_mic_tkn4(baseobj.BaseObj)

struct ssv_mic_tkn4 {
 uint32_t ssv_seq;
 opaque hmac<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ssv_prot_info4(baseobj.BaseObj)

struct ssv_prot_info4 {
 state_protect_ops4 ops;
 uint32_t hash_alg;
 uint32_t encr_alg;
 uint32_t ssv_len;
 uint32_t window;
 gsshandle4_t handles<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ssv_seal_cipher_tkn4(baseobj.BaseObj)

struct ssv_seal_cipher_tkn4 {
 uint32_t ssv_seq;
 opaque iv<>;
 opaque encr_data<>;
 opaque hmac<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ssv_seal_plain_tkn4(baseobj.BaseObj)

struct ssv_seal_plain_tkn4 {
 opaque confounder<>;
 uint32_t ssv_seq;
 opaque orig_plain<>;
 opaque pad<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ssv_sp_parms4(baseobj.BaseObj)

struct ssv_sp_parms4 {
 state_protect_ops4 ops;
 sec_oid4 hash_algs<>;
 sec_oid4 encr_algs<>;
 uint32_t window;
 uint32_t num_gss_handles;
};
Methods defined here:
---------------------
__init__(self, unpack)

class ssv_subkey4(packet.utils.Enum)

enum ssv_subkey4

class stable_how4(packet.utils.Enum)

enum stable_how4

class state_owner4(baseobj.BaseObj)

struct state_owner4 {
 clientid4 clientid;
 opaque owner<NFS4_OPAQUE_LIMIT>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class state_protect4_a(baseobj.BaseObj)

union switch state_protect4_a (state_protect_how4 how) {
 case const.SP4_NONE:
 void;
 case const.SP4_MACH_CRED:
 state_protect_ops4 mach_ops;
 case const.SP4_SSV:
 ssv_sp_parms4 ssv_parms;
};
Methods defined here:
---------------------
__init__(self, unpack)

class state_protect4_r(baseobj.BaseObj)

union switch state_protect4_r (state_protect_how4 how) {
 case const.SP4_NONE:
 void;
 case const.SP4_MACH_CRED:
 state_protect_ops4 mach_ops;
 case const.SP4_SSV:
 ssv_prot_info4 ssv_info;
};
Methods defined here:
---------------------
__init__(self, unpack)

class state_protect_how4(packet.utils.Enum)

enum state_protect_how4

class state_protect_ops4(baseobj.BaseObj)

struct state_protect_ops4 {
 bitmap4 enforce;
 bitmap4 allow;
};
Methods defined here:
---------------------
__init__(self, unpack)

class stateid4(baseobj.BaseObj)

struct stateid4 {
 uint32_t seqid;
 opaque other[NFS4_OTHER_SIZE];
};
Methods defined here:
---------------------
__init__(self, unpack)

class threshold_item4(baseobj.BaseObj)

struct threshold_item4 {
 layouttype4 type;
 bitmap4 mask;
 opaque values<>;
};
Methods defined here:
---------------------
__init__(self, unpack)

class time_how4(packet.utils.Enum)

enum time_how4

class why_no_delegation4(packet.utils.Enum)

enum why_no_delegation4

class write_response4(baseobj.BaseObj)

struct write_response4 {
 stateid4 callback_id<1>;
 length4 count;
 stable_how4 committed;
 verifier4 verifier;
};
Methods defined here:
---------------------
__init__(self, unpack)

Functions

SECINFO4resok(unpack)

aceflag4(unpack)

acemask4(unpack)

acetype4(unpack)

aclflag4(unpack)

bitmap4(unpack)

changeid4(unpack)

clientid4(unpack)

deviceid4(unpack)

fattr4(unpack)

struct fattr4 {
 bitmap4   mask;
 attrlist4 values; };

fattr4_acl(unpack)

fattr4_change(unpack)

fattr4_filehandle(unpack)

fattr4_fs_layout_types(unpack)

fattr4_layout_types(unpack)

fattr4_suppattr_exclcreat(unpack)

fattr4_supported_attrs(unpack)

gsshandle4_t(unpack)

multipath_list4(unpack)

nfl_util4(unpack)

nfs_fh4(unpack)

notifylist4(unpack)

 Objects of type notify_<>4 and
 notify_device_<>4 are encoded in this.

pathname4(unpack)

sec_oid4(unpack)

sessionid4(unpack)

verifier4(unpack)

See Also

baseobj(3), packet.nfs.nfsbase(3), packet.unpack(3), packet.utils(3)

Bugs

No known bugs.

Author

Jorge Mora (mora [at] netapp.com)