--- name: "packet.nfs.nfs4" section: "3" platform: "linux" package: "nfstest" version: "3.2-3" release: "Debian 13 (Trixie)" platforms: ["linux"] url: "https://new.carta.tech/packet.nfs.nfs4" --- # packet.nfs.nfs4(3) NFSv4 decoding module ## NAME packet.nfs.nfs4 - NFSv4 decoding module ## CLASSES ### class ACCESS4args(baseobj.BaseObj) ``` struct ACCESS4args { /* CURRENT_FH: object */ access4 access; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class ACCESS4res(baseobj.BaseObj) ``` union switch ACCESS4res (nfsstat4 status) { case const.NFS4_OK: ACCESS4resok resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class ACCESS4resok(baseobj.BaseObj) ``` struct ACCESS4resok { access4 supported; access4 access; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class ALLOCATE4args(baseobj.BaseObj) ``` struct ALLOCATE4args { /* CURRENT_FH: file */ stateid4 stateid; offset4 offset; length4 length; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class ALLOCATE4res(baseobj.BaseObj) ``` struct ALLOCATE4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class BACKCHANNEL\_CTL4args(baseobj.BaseObj) ``` struct BACKCHANNEL_CTL4args { uint32_t cb_program; callback_sec_parms4 sec_parms<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class BACKCHANNEL\_CTL4res(baseobj.BaseObj) ``` struct BACKCHANNEL_CTL4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_GETATTR4args(baseobj.BaseObj) ``` struct CB_GETATTR4args { nfs_fh4 fh; bitmap4 request; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_GETATTR4resok(baseobj.BaseObj) ``` struct CB_GETATTR4resok { fattr4 attributes; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_ILLEGAL4res(baseobj.BaseObj) ``` struct CB_ILLEGAL4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_LAYOUTRECALL4args(baseobj.BaseObj) ``` struct CB_LAYOUTRECALL4args { layouttype4 type; layoutiomode4 iomode; bool changed; layoutrecall4 recall; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_LAYOUTRECALL4res(baseobj.BaseObj) ``` struct CB_LAYOUTRECALL4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_NOTIFY4args(baseobj.BaseObj) ``` struct CB_NOTIFY4args { stateid4 stateid; nfs_fh4 fh; notify4 changes<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_NOTIFY4res(baseobj.BaseObj) ``` struct CB_NOTIFY4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_NOTIFY\_DEVICEID4args(baseobj.BaseObj) ``` struct CB_NOTIFY_DEVICEID4args { notify4 changes<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_NOTIFY\_DEVICEID4res(baseobj.BaseObj) ``` struct CB_NOTIFY_DEVICEID4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_NOTIFY\_LOCK4args(baseobj.BaseObj) ``` struct CB_NOTIFY_LOCK4args { nfs_fh4 fh; lock_owner4 lock_owner; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_NOTIFY\_LOCK4res(baseobj.BaseObj) ``` struct CB_NOTIFY_LOCK4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_OFFLOAD4args(baseobj.BaseObj) ``` struct CB_OFFLOAD4args { nfs_fh4 fh; stateid4 stateid; offload_info4 info; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_OFFLOAD4res(baseobj.BaseObj) ``` struct CB_OFFLOAD4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_PUSH\_DELEG4args(baseobj.BaseObj) ``` struct CB_PUSH_DELEG4args { nfs_fh4 fh; open_delegation4 delegation; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_PUSH\_DELEG4res(baseobj.BaseObj) ``` struct CB_PUSH_DELEG4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_RECALL4args(baseobj.BaseObj) ``` struct CB_RECALL4args { stateid4 stateid; bool truncate; nfs_fh4 fh; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_RECALL4res(baseobj.BaseObj) ``` struct CB_RECALL4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_RECALL\_ANY4args(baseobj.BaseObj) ``` struct CB_RECALL_ANY4args { uint32_t objects_to_keep; bitmap4 mask; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_RECALL\_ANY4res(baseobj.BaseObj) ``` struct CB_RECALL_ANY4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_RECALL\_SLOT4args(baseobj.BaseObj) ``` struct CB_RECALL_SLOT4args { slotid4 target_highest_slotid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_RECALL\_SLOT4res(baseobj.BaseObj) ``` struct CB_RECALL_SLOT4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_WANTS\_CANCELLED4args(baseobj.BaseObj) ``` struct CB_WANTS_CANCELLED4args { bool contended; bool resourced; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CB\_WANTS\_CANCELLED4res(baseobj.BaseObj) ``` struct CB_WANTS_CANCELLED4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CLONE4res(baseobj.BaseObj) ``` struct CLONE4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CLOSE4args(baseobj.BaseObj) ``` struct CLOSE4args { /* CURRENT_FH: object */ seqid4 seqid; stateid4 stateid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CLOSE4res(baseobj.BaseObj) ``` union switch CLOSE4res (nfsstat4 status) { case const.NFS4_OK: stateid4 stateid; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class COMMIT4args(baseobj.BaseObj) ``` struct COMMIT4args { /* CURRENT_FH: file */ offset4 offset; count4 count; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class COMMIT4res(baseobj.BaseObj) ``` union switch COMMIT4res (nfsstat4 status) { case const.NFS4_OK: COMMIT4resok resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class COMMIT4resok(baseobj.BaseObj) ``` struct COMMIT4resok { verifier4 verifier; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class COMPOUND4args(packet.nfs.nfsbase.NFSbase) ``` struct COMPOUND4args { utf8str_cs tag; uint32_t minorversion; nfs_argop4 array<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class COMPOUND4res(packet.nfs.nfsbase.NFSbase) ``` struct COMPOUND4res { nfsstat4 status; utf8str_cs tag; nfs_resop4 array<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack, minorversion)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class COPY4resok(baseobj.BaseObj) ``` struct COPY4resok { write_response4 response; copy_requirements4 requirements; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class COPY\_NOTIFY4args(baseobj.BaseObj) ``` struct COPY_NOTIFY4args { /* CURRENT_FH: source file */ stateid4 stateid; netloc4 dst_server; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class COPY\_NOTIFY4resok(baseobj.BaseObj) ``` struct COPY_NOTIFY4resok { nfstime4 lease_time; stateid4 stateid; netloc4 src_servers<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CREATE4args(baseobj.BaseObj) ``` struct CREATE4args { /* CURRENT_FH: directory for creation */ createtype4 type; component4 name; fattr4 attributes; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class CREATE4resok(baseobj.BaseObj) ``` struct CREATE4resok { change_info4 cinfo; bitmap4 attrset; /* attributes set */ }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class DEALLOCATE4args(baseobj.BaseObj) ``` struct DEALLOCATE4args { /* CURRENT_FH: file */ stateid4 stateid; offset4 offset; length4 length; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class DEALLOCATE4res(baseobj.BaseObj) ``` struct DEALLOCATE4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class DELEGPURGE4args(baseobj.BaseObj) ``` struct DELEGPURGE4args { clientid4 clientid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class DELEGPURGE4res(baseobj.BaseObj) ``` struct DELEGPURGE4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class DELEGRETURN4args(baseobj.BaseObj) ``` struct DELEGRETURN4args { /* CURRENT_FH: delegated object */ stateid4 stateid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class DELEGRETURN4res(baseobj.BaseObj) ``` struct DELEGRETURN4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class DESTROY\_CLIENTID4args(baseobj.BaseObj) ``` struct DESTROY_CLIENTID4args { clientid4 clientid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class DESTROY\_CLIENTID4res(baseobj.BaseObj) ``` struct DESTROY_CLIENTID4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class DESTROY\_SESSION4args(baseobj.BaseObj) ``` struct DESTROY_SESSION4args { sessionid4 sessionid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class DESTROY\_SESSION4res(baseobj.BaseObj) ``` struct DESTROY_SESSION4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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; nfs_impl_id4 server_impl_id<1>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class FREE\_STATEID4args(baseobj.BaseObj) ``` struct FREE_STATEID4args { stateid4 stateid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class FREE\_STATEID4res(baseobj.BaseObj) ``` struct FREE_STATEID4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class GETATTR4args(baseobj.BaseObj) ``` struct GETATTR4args { /* CURRENT_FH: object */ bitmap4 request; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class GETATTR4res(baseobj.BaseObj) ``` union switch GETATTR4res (nfsstat4 status) { case const.NFS4_OK: GETATTR4resok resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class GETATTR4resok(baseobj.BaseObj) ``` struct GETATTR4resok { fattr4 attributes; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class GETDEVICEINFO4args(baseobj.BaseObj) ``` struct GETDEVICEINFO4args { deviceid4 deviceid; layouttype4 type; count4 maxcount; bitmap4 notify_mask; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class GETDEVICEINFO4resok(baseobj.BaseObj) ``` struct GETDEVICEINFO4resok { device_addr4 device_addr; bitmap4 notify_mask; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class GETDEVICELIST4res(baseobj.BaseObj) ``` union switch GETDEVICELIST4res (nfsstat4 status) { case const.NFS4_OK: GETDEVICELIST4resok resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class GETDEVICELIST4resok(baseobj.BaseObj) ``` struct GETDEVICELIST4resok { nfs_cookie4 cookie; verifier4 verifier; deviceid4 deviceid_list<>; bool eof; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class GETFH4res(baseobj.BaseObj) ``` union switch GETFH4res (nfsstat4 status) { case const.NFS4_OK: GETFH4resok resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class GETFH4resok(baseobj.BaseObj) ``` struct GETFH4resok { nfs_fh4 fh; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class GETXATTR4args(baseobj.BaseObj) ``` struct GETXATTR4args { /* CURRENT_FH: file */ xattrkey4 name; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class GETXATTR4res(baseobj.BaseObj) ``` union switch GETXATTR4res (nfsstat4 status) { case const.NFS4_OK: xattrvalue4 value; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class ILLEGAL4res(baseobj.BaseObj) ``` struct ILLEGAL4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class IO\_ADVISE4args(baseobj.BaseObj) ``` struct IO_ADVISE4args { /* CURRENT_FH: file */ stateid4 stateid; offset4 offset; length4 count; bitmap4 mask; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class IO\_ADVISE4resok(baseobj.BaseObj) ``` struct IO_ADVISE4resok { bitmap4 mask; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LAYOUTCOMMIT4res(baseobj.BaseObj) ``` union switch LAYOUTCOMMIT4res (nfsstat4 status) { case const.NFS4_OK: LAYOUTCOMMIT4resok resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LAYOUTCOMMIT4resok(baseobj.BaseObj) ``` struct LAYOUTCOMMIT4resok { newsize4 newsize; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LAYOUTERROR4args(baseobj.BaseObj) ``` struct LAYOUTERROR4args { /* CURRENT_FH: file */ offset4 offset; length4 length; stateid4 stateid; device_error4 errors<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LAYOUTERROR4res(baseobj.BaseObj) ``` struct LAYOUTERROR4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LAYOUTGET4resok(baseobj.BaseObj) ``` struct LAYOUTGET4resok { bool return_on_close; stateid4 stateid; layout4 layout<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LAYOUTRETURN4args(baseobj.BaseObj) ``` struct LAYOUTRETURN4args { /* CURRENT_FH: file */ bool reclaim; layouttype4 type; layoutiomode4 iomode; layoutreturn4 layoutreturn; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LAYOUTRETURN4res(baseobj.BaseObj) ``` union switch LAYOUTRETURN4res (nfsstat4 status) { case const.NFS4_OK: layoutreturn_stateid stateid; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LAYOUTSTATS4res(baseobj.BaseObj) ``` struct LAYOUTSTATS4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LINK4args(baseobj.BaseObj) ``` struct LINK4args { /* * SAVED_FH: source object * CURRENT_FH: target directory */ component4 name; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LINK4res(baseobj.BaseObj) ``` union switch LINK4res (nfsstat4 status) { case const.NFS4_OK: LINK4resok resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LINK4resok(baseobj.BaseObj) ``` struct LINK4resok { change_info4 cinfo; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LISTXATTRS4args(baseobj.BaseObj) ``` struct LISTXATTRS4args { /* CURRENT_FH: file */ nfs_cookie4 cookie; count4 maxcount; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LISTXATTRS4res(baseobj.BaseObj) ``` union switch LISTXATTRS4res (nfsstat4 status) { case const.NFS4_OK: LISTXATTRS4resok value; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LISTXATTRS4resok(baseobj.BaseObj) ``` struct LISTXATTRS4resok { nfs_cookie4 cookie; xattrkey4 names<>; bool eof; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LOCK4denied(baseobj.BaseObj) ``` struct LOCK4denied { offset4 offset; length4 length; nfs_lock_type4 locktype; lock_owner4 owner; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LOCK4resok(baseobj.BaseObj) ``` struct LOCK4resok { stateid4 stateid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LOCKU4res(baseobj.BaseObj) ``` union switch LOCKU4res (nfsstat4 status) { case const.NFS4_OK: stateid4 stateid; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LOOKUP4args(baseobj.BaseObj) ``` struct LOOKUP4args { /* CURRENT_FH: directory */ component4 name; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LOOKUP4res(baseobj.BaseObj) ``` struct LOOKUP4res { /* New CURRENT_FH: object */ nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class LOOKUPP4res(baseobj.BaseObj) ``` struct LOOKUPP4res { /* new CURRENT_FH: parent directory */ nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class NVERIFY4args(baseobj.BaseObj) ``` struct NVERIFY4args { /* CURRENT_FH: object */ fattr4 attributes; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class NVERIFY4res(baseobj.BaseObj) ``` struct NVERIFY4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class OFFLOAD\_CANCEL4args(baseobj.BaseObj) ``` struct OFFLOAD_CANCEL4args { /* CURRENT_FH: file to cancel */ stateid4 stateid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class OFFLOAD\_CANCEL4res(baseobj.BaseObj) ``` struct OFFLOAD_CANCEL4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class OFFLOAD\_STATUS4args(baseobj.BaseObj) ``` struct OFFLOAD_STATUS4args { /* CURRENT_FH: destination file */ stateid4 stateid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class OFFLOAD\_STATUS4resok(baseobj.BaseObj) ``` struct OFFLOAD_STATUS4resok { length4 count; nfsstat4 complete<1>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class OPENATTR4args(baseobj.BaseObj) ``` struct OPENATTR4args { /* CURRENT_FH: object */ bool createdir; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class OPEN\_CONFIRM4args(baseobj.BaseObj) ``` struct OPEN_CONFIRM4args { /* CURRENT_FH: opened file */ stateid4 stateid; seqid4 seqid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class OPEN\_CONFIRM4resok(baseobj.BaseObj) ``` struct OPEN_CONFIRM4resok { stateid4 stateid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class OPEN\_DOWNGRADE4resok(baseobj.BaseObj) ``` struct OPEN_DOWNGRADE4resok { stateid4 stateid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class PUTFH4args(baseobj.BaseObj) ``` struct PUTFH4args { nfs_fh4 fh; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class PUTPUBFH4res(baseobj.BaseObj) ``` struct PUTPUBFH4res { /* * If status is NFS4_OK, * new CURRENT_FH: public fh */ nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class PUTROOTFH4res(baseobj.BaseObj) ``` struct PUTROOTFH4res { /* * If status is NFS4_OK, * new CURRENT_FH: root fh */ nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class READ4args(baseobj.BaseObj) ``` struct READ4args { /* CURRENT_FH: file */ stateid4 stateid; offset4 offset; count4 count; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class READ4res(baseobj.BaseObj) ``` union switch READ4res (nfsstat4 status) { case const.NFS4_OK: READ4resok resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class READ4resok(packet.utils.RDMAbase) ``` struct READ4resok { bool eof; opaque data<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class READDIR4res(baseobj.BaseObj) ``` union switch READDIR4res (nfsstat4 status) { case const.NFS4_OK: READDIR4resok resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class READDIR4resok(baseobj.BaseObj) ``` struct READDIR4resok { verifier4 verifier; dirlist4 reply; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class READLINK4res(baseobj.BaseObj) ``` union switch READLINK4res (nfsstat4 status) { case const.NFS4_OK: READLINK4resok resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class READLINK4resok(packet.utils.RDMAbase) ``` struct READLINK4resok { linktext4 link; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class READ\_PLUS4args(baseobj.BaseObj) ``` struct READ_PLUS4args { /* CURRENT_FH: file */ stateid4 stateid; offset4 offset; count4 count; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class RECLAIM\_COMPLETE4res(baseobj.BaseObj) ``` struct RECLAIM_COMPLETE4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class RELEASE\_LOCKOWNER4args(baseobj.BaseObj) ``` struct RELEASE_LOCKOWNER4args { lock_owner4 owner; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class RELEASE\_LOCKOWNER4res(baseobj.BaseObj) ``` struct RELEASE_LOCKOWNER4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class REMOVE4args(baseobj.BaseObj) ``` struct REMOVE4args { /* CURRENT_FH: directory */ component4 name; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class REMOVE4res(baseobj.BaseObj) ``` union switch REMOVE4res (nfsstat4 status) { case const.NFS4_OK: REMOVE4resok resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class REMOVE4resok(baseobj.BaseObj) ``` struct REMOVE4resok { change_info4 cinfo; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class REMOVEXATTR4args(baseobj.BaseObj) ``` struct REMOVEXATTR4args { /* CURRENT_FH: file */ xattrkey4 name; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class REMOVEXATTR4res(baseobj.BaseObj) ``` union switch REMOVEXATTR4res (nfsstat4 status) { case const.NFS4_OK: change_info4 info; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class RENAME4args(baseobj.BaseObj) ``` struct RENAME4args { /* SAVED_FH: source directory */ component4 name; /* CURRENT_FH: target directory */ component4 newname; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class RENAME4res(baseobj.BaseObj) ``` union switch RENAME4res (nfsstat4 status) { case const.NFS4_OK: RENAME4resok resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class RENAME4resok(baseobj.BaseObj) ``` struct RENAME4resok { change_info4 source; change_info4 target; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class RENEW4args(baseobj.BaseObj) ``` struct RENEW4args { clientid4 clientid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class RENEW4res(baseobj.BaseObj) ``` struct RENEW4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class SECINFO4args(baseobj.BaseObj) ``` struct SECINFO4args { /* CURRENT_FH: directory */ component4 name; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class SEEK4res(baseobj.BaseObj) ``` union switch SEEK4res (nfsstat4 status) { case const.NFS4_OK: seek_res4 resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class SEQUENCE4args(baseobj.BaseObj) ``` struct SEQUENCE4args { sessionid4 sessionid; sequenceid4 sequenceid; slotid4 slotid; slotid4 highest_slotid; bool cachethis; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class SEQUENCE4res(baseobj.BaseObj) ``` union switch SEQUENCE4res (nfsstat4 status) { case const.NFS4_OK: SEQUENCE4resok resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class SETATTR4args(baseobj.BaseObj) ``` struct SETATTR4args { /* CURRENT_FH: target object */ stateid4 stateid; fattr4 attributes; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class SETATTR4res(baseobj.BaseObj) ``` struct SETATTR4res { nfsstat4 status; bitmap4 attrset; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class SETCLIENTID4args(baseobj.BaseObj) ``` struct SETCLIENTID4args { nfs_client_id4 client; cb_client4 callback; uint32_t callback_ident; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class SETCLIENTID4resok(baseobj.BaseObj) ``` struct SETCLIENTID4resok { clientid4 clientid; verifier4 verifier; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class SETCLIENTID\_CONFIRM4args(baseobj.BaseObj) ``` struct SETCLIENTID_CONFIRM4args { clientid4 clientid; verifier4 verifier; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class SETCLIENTID\_CONFIRM4res(baseobj.BaseObj) ``` struct SETCLIENTID_CONFIRM4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class SETXATTR4args(baseobj.BaseObj) ``` struct SETXATTR4args { /* CURRENT_FH: file */ setxattr_option4 option; xattrkey4 name; xattrvalue4 value; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class SETXATTR4res(baseobj.BaseObj) ``` union switch SETXATTR4res (nfsstat4 status) { case const.NFS4_OK: change_info4 info; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class SET\_SSV4args(baseobj.BaseObj) ``` struct SET_SSV4args { opaque ssv<>; opaque digest<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class SET\_SSV4resok(baseobj.BaseObj) ``` struct SET_SSV4resok { opaque digest<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class TEST\_STATEID4args(baseobj.BaseObj) ``` struct TEST_STATEID4args { stateid4 stateids<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class TEST\_STATEID4resok(baseobj.BaseObj) ``` struct TEST_STATEID4resok { nfsstat4 status_codes<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class VERIFY4args(baseobj.BaseObj) ``` struct VERIFY4args { /* CURRENT_FH: object */ fattr4 attributes; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class VERIFY4res(baseobj.BaseObj) ``` struct VERIFY4res { nfsstat4 status; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class WANT\_DELEGATION4args(baseobj.BaseObj) ``` struct WANT_DELEGATION4args { uint32_t want; deleg_claim4 claim; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class WRITE4args(baseobj.BaseObj) ``` struct WRITE4args { /* CURRENT_FH: file */ stateid4 stateid; offset4 offset; stable_how4 stable; opaque data<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class WRITE4res(baseobj.BaseObj) ``` union switch WRITE4res (nfsstat4 status) { case const.NFS4_OK: WRITE4resok resok; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class WRITE4resok(baseobj.BaseObj) ``` struct WRITE4resok { count4 count; stable_how4 committed; verifier4 verifier; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class bitmap4\_list(baseobj.BaseObj) ``` struct bitmap4_list { bitmap4 attrs; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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 5531 */ case const.RPCSEC_GSS: gss_cb_handles4 gss_handles; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class cb\_client4(baseobj.BaseObj) ``` struct cb_client4 { uint32_t cb_program; netaddr4 cb_location; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class change\_policy4(baseobj.BaseObj) ``` struct change_policy4 { uint64_t major; uint64_t minor; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class copy\_requirements4(baseobj.BaseObj) ``` struct copy_requirements4 { bool consecutive; bool synchronous; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class creatverfattr(baseobj.BaseObj) ``` struct creatverfattr { verifier4 verifier; fattr4 attrs; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class data4(baseobj.BaseObj) ``` struct data4 { offset4 offset; opaque data<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class device\_error4(baseobj.BaseObj) ``` struct device_error4 { deviceid4 deviceid; nfsstat4 status; nfs_opnum4 opnum; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class dirlist4(baseobj.BaseObj) ``` struct dirlist4 { entry4 *entries; bool eof; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class entry4(baseobj.BaseObj) ``` struct entry4 { nfs_cookie4 cookie; component4 name; fattr4 attrs; entry4 *nextentry; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class exist\_lock\_owner4(baseobj.BaseObj) ``` struct exist_lock_owner4 { stateid4 stateid; seqid4 seqid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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\_mode\_umask(baseobj.BaseObj) ``` fattr4_mode_umask = class mode_umask4(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\_suppattr\_exclcreat(baseobj.BaseObj) ``` fattr4_suppattr_exclcreat = class bitmap4_list(baseobj.BaseObj) ``` ### class fattr4\_supported\_attrs(baseobj.BaseObj) ``` fattr4_supported_attrs = class bitmap4_list(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 fattr4\_xattr\_support(packet.utils.Enum) ``` fattr4_xattr_support = 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class ff\_ioerr4(baseobj.BaseObj) ``` struct ff_ioerr4 { offset4 offset; length4 length; stateid4 stateid; device_error4 errors<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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; uint32_t stats_hint; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class ff\_layouthint4(baseobj.BaseObj) ``` struct ff_layouthint4 { ff_mirrors_hint mirrors_hint; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class ff\_mirror4(baseobj.BaseObj) ``` struct ff_mirror4 { ff_data_server4 data_servers<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class ff\_mirrors\_hint(baseobj.BaseObj) ``` union switch ff_mirrors_hint (bool valid) { case const.TRUE: uint32_t mirrors; case const.FALSE: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class fs\_locations4(baseobj.BaseObj) ``` struct fs_locations4 { pathname4 root; fs_location4 locations<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class fs\_locations\_item4(baseobj.BaseObj) ``` struct fs_locations_item4 { fs_locations_server4 entries<>; pathname4 root; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class fs\_locations\_server4(baseobj.BaseObj) ``` struct fs_locations_server4 { int32_t currency; opaque info<>; utf8str_cis server; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class fsid4(baseobj.BaseObj) ``` struct fsid4 { uint64_t major; uint64_t minor; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class io\_info4(baseobj.BaseObj) ``` struct io_info4 { uint64_t count; uint64_t bytes; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class labelformat\_spec4(baseobj.BaseObj) ``` struct labelformat_spec4 { policy4 lfs; policy4 pi; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class layout4(baseobj.BaseObj) ``` struct layout4 { offset4 offset; length4 length; layoutiomode4 iomode; layout_content4 content; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class layoutrecall\_file4(baseobj.BaseObj) ``` struct layoutrecall_file4 { nfs_fh4 fh; offset4 offset; length4 length; stateid4 stateid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class mdsthreshold4(baseobj.BaseObj) ``` struct mdsthreshold4 { threshold_item4 hints<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class mode\_umask4(baseobj.BaseObj) ``` struct mode_umask4 { mode4 mode; mode4 umask; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class newsize4(baseobj.BaseObj) ``` union switch newsize4 (bool sizechanged) { case const.TRUE: length4 size; case const.FALSE: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class newtime4(baseobj.BaseObj) ``` union switch newtime4 (bool timechanged) { case const.TRUE: nfstime4 time; case const.FALSE: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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; /* * RFC 8276 */ case const.OP_GETXATTR: GETXATTR4args opgetxattr; case const.OP_SETXATTR: SETXATTR4args opsetxattr; case const.OP_LISTXATTRS: LISTXATTRS4args oplistxattrs; case const.OP_REMOVEXATTR: REMOVEXATTR4args opremovexattr; case const.OP_ILLEGAL: /* Illegal operation */ void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class nfs\_client\_id4(baseobj.BaseObj) ``` struct nfs_client_id4 { verifier4 verifier; opaque id; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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; /* * RFC 8276 */ case const.OP_GETXATTR: GETXATTR4res opgetxattr; case const.OP_SETXATTR: SETXATTR4res opsetxattr; case const.OP_LISTXATTRS: LISTXATTRS4res oplistxattrs; case const.OP_REMOVEXATTR: REMOVEXATTR4res opremovexattr; case const.OP_ILLEGAL: /* Illegal operation */ ILLEGAL4res opillegal; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class nfsace4(baseobj.BaseObj) ``` struct nfsace4 { acetype4 type; aceflag4 flag; acemask4 mask; utf8str_mixed who; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class nfsacl41(baseobj.BaseObj) ``` struct nfsacl41 { aclflag4 flag; nfsace4 aces<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class nfsv4\_1\_file\_th\_items4(packet.utils.Enum) ``` enum nfsv4_1_file_th_items4 ``` ### class notify4(baseobj.BaseObj) ``` struct notify4 { /* composed from notify_type4 or notify_deviceid_type4 */ bitmap4 mask; notifylist4 values; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class notify\_attr4(baseobj.BaseObj) ``` struct notify_attr4 { notify_entry4 entry; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class notify\_deviceid\_change4(baseobj.BaseObj) ``` struct notify_deviceid_change4 { layouttype4 type; deviceid4 deviceid; bool immediate; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class notify\_deviceid\_delete4(baseobj.BaseObj) ``` struct notify_deviceid_delete4 { layouttype4 type; deviceid4 deviceid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class notify\_remove4(baseobj.BaseObj) ``` struct notify_remove4 { notify_entry4 entry; nfs_cookie4 cookie; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class notify\_rename4(baseobj.BaseObj) ``` struct notify_rename4 { notify_remove4 old_entry; notify_add4 new_entry; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class open\_claim\_delegate\_cur4(baseobj.BaseObj) ``` struct open_claim_delegate_cur4 { stateid4 stateid; component4 name; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class openflag4(baseobj.BaseObj) ``` union switch openflag4 (opentype4 opentype) { case const.OPEN4_CREATE: createhow4 how; default: void; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class read\_plus\_res4(baseobj.BaseObj) ``` struct read_plus_res4 { bool eof; read_plus_content contents<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class referring\_call4(baseobj.BaseObj) ``` struct referring_call4 { sequenceid4 sequenceid; slotid4 slotid; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class referring\_call\_list4(baseobj.BaseObj) ``` struct referring_call_list4 { sessionid4 sessionid; referring_call4 referring_calls<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class retention\_get4(baseobj.BaseObj) ``` struct retention_get4 { uint64_t duration; nfstime4 begin_time<1>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class retention\_set4(baseobj.BaseObj) ``` struct retention_set4 { bool enable; uint64_t duration<1>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class sec\_label4(baseobj.BaseObj) ``` struct sec_label4 { labelformat_spec4 lfs; opaque data<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class server\_owner4(baseobj.BaseObj) ``` struct server_owner4 { uint64_t minor_id; opaque major_id; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class setxattr\_option4(packet.utils.Enum) ``` enum setxattr_option4 ``` ### class specdata4(baseobj.BaseObj) ``` struct specdata4 { uint32_t specdata1; /* major device number */ uint32_t specdata2; /* minor device number */ }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class ssa\_digest\_input4(baseobj.BaseObj) ``` struct ssa_digest_input4 { SEQUENCE4args seqargs; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class ssr\_digest\_input4(baseobj.BaseObj) ``` struct ssr_digest_input4 { SEQUENCE4res seqres; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class ssv\_mic\_tkn4(baseobj.BaseObj) ``` struct ssv_mic_tkn4 { uint32_t ssv_seq; opaque hmac<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class state\_protect\_how4(packet.utils.Enum) ``` enum state_protect_how4 ``` ### class state\_protect\_ops4(baseobj.BaseObj) ``` struct state_protect_ops4 { bitmap4 enforce_mask; bitmap4 allow_mask; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class stateid4(baseobj.BaseObj) ``` struct stateid4 { uint32_t seqid; opaque other[NFS4_OTHER_SIZE]; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class th\_item4(baseobj.BaseObj) ``` struct th_item4 { bitmap4 mask; opaque values<>; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### class threshold\_item4(baseobj.BaseObj) ``` union switch threshold_item4 (layouttype4 type) { case const.LAYOUT4_NFSV4_1_FILES: nfsv4_1_file_th_item4 items; default: th_item4 items; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ### 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 stateid<1>; length4 count; stable_how4 committed; verifier4 verifier; }; ``` **Methods defined here:** --------------------- **\_\_init\_\_(self, unpack)** Constructor Initialize object's private data according to the arguments given. Arguments can be given as positional, named arguments or a combination of both. ## 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)** **gsshandle4\_t(unpack)** **multipath\_list4(unpack)** **nfl\_util4(unpack)** **nfs\_fh4(unpack)** **nfsv4\_1\_file\_th\_item4(unpack)** struct nfsv4\_1\_file\_th\_item4 {\ bitmap4 mask;\ opaque values\<\>; }; **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)](/baseobj/3.md),** **[packet.nfs.nfs4\_const(3)](/packet.nfs.nfs4_const/3.md),** **[packet.nfs.nfsbase(3)](/packet.nfs.nfsbase/3.md),** **[packet.unpack(3)](/packet.unpack/3.md),** **[packet.utils(3)](/packet.utils/3.md)** ## BUGS No known bugs. ## AUTHOR Jorge Mora (mora@netapp.com)