nfs4/nfs4.x

/* This is based on RFC3530 */

/*
 * NFS v4 Definitions
 */


/*
 *  Copyright (C) The Internet Society (1998,1999,2000,2001,2002).
 *  All Rights Reserved.
 */

/*
 *      nfs4_prot.x
 *
 */

/*
 * Sizes
 */
const NFS4_FHSIZE               = 128;
const NFS4_VERIFIER_SIZE        = 8;
const NFS4_OPAQUE_LIMIT         = 1024;
const NFS4_SESSIONID_SIZE       = 16;
/*
 * File types
 */
enum nfs_ftype4 {
     NF4REG          = 1,    /* Regular File */
     NF4DIR          = 2,    /* Directory */
     NF4BLK          = 3,    /* Special File - block device */
     NF4CHR          = 4,    /* Special File - character device */
     NF4LNK          = 5,    /* Symbolic Link */
     NF4SOCK         = 6,    /* Special File - socket */
     NF4FIFO         = 7,    /* Special File - fifo */
     NF4ATTRDIR      = 8,    /* Attribute Directory */
     NF4NAMEDATTR    = 9     /* Named Attribute */
};

/*
 * Error status
 */
enum nfsstat4 {
     NFS4_OK                 = 0,    /* everything is okay      */
     NFS4ERR_PERM            = 1,    /* caller not privileged   */
     NFS4ERR_NOENT           = 2,    /* no such file/directory  */
     NFS4ERR_IO              = 5,    /* hard I/O error          */
     NFS4ERR_NXIO            = 6,    /* no such device          */
     NFS4ERR_ACCESS          = 13,   /* access denied           */
     NFS4ERR_EXIST           = 17,   /* file already exists     */
     NFS4ERR_XDEV            = 18,   /* different filesystems   */
     /* Unused/reserved        19 */
     NFS4ERR_NOTDIR          = 20,   /* should be a directory   */
     NFS4ERR_ISDIR           = 21,   /* should not be directory */
     NFS4ERR_INVAL           = 22,   /* invalid argument        */
     NFS4ERR_FBIG            = 27,   /* file exceeds server max */
     NFS4ERR_NOSPC           = 28,   /* no space on filesystem  */
     NFS4ERR_ROFS            = 30,   /* read-only filesystem    */
     NFS4ERR_MLINK           = 31,   /* too many hard links     */
     NFS4ERR_NAMETOOLONG     = 63,   /* name exceeds server max */
     NFS4ERR_NOTEMPTY        = 66,   /* directory not empty     */
     NFS4ERR_DQUOT           = 69,   /* hard quota limit reached*/
     NFS4ERR_STALE           = 70,   /* file no longer exists   */
     NFS4ERR_BADHANDLE       = 10001,/* Illegal filehandle      */
     NFS4ERR_BAD_COOKIE      = 10003,/* READDIR cookie is stale */
     NFS4ERR_NOTSUPP         = 10004,/* operation not supported */
     NFS4ERR_TOOSMALL        = 10005,/* response limit exceeded */
     NFS4ERR_SERVERFAULT     = 10006,/* undefined server error  */
     NFS4ERR_BADTYPE         = 10007,/* type invalid for CREATE */
     NFS4ERR_DELAY           = 10008,/* file "busy" - retry     */
     NFS4ERR_SAME            = 10009,/* nverify says attrs same */
     NFS4ERR_DENIED          = 10010,/* lock unavailable        */
     NFS4ERR_EXPIRED         = 10011,/* lock lease expired      */
     NFS4ERR_LOCKED          = 10012,/* I/O failed due to lock  */
     NFS4ERR_GRACE           = 10013,/* in grace period         */
     NFS4ERR_FHEXPIRED       = 10014,/* filehandle expired      */
     NFS4ERR_SHARE_DENIED    = 10015,/* share reserve denied    */
     NFS4ERR_WRONGSEC        = 10016,/* wrong security flavor   */
     NFS4ERR_CLID_INUSE      = 10017,/* clientid in use         */
     NFS4ERR_RESOURCE        = 10018,/* resource exhaustion     */
     NFS4ERR_MOVED           = 10019,/* filesystem relocated    */
     NFS4ERR_NOFILEHANDLE    = 10020,/* current FH is not set   */
     NFS4ERR_MINOR_VERS_MISMATCH = 10021,/* minor vers not supp */
     NFS4ERR_STALE_CLIENTID  = 10022,/* server has rebooted     */
     NFS4ERR_STALE_STATEID   = 10023,/* server has rebooted     */
     NFS4ERR_OLD_STATEID     = 10024,/* state is out of sync    */
     NFS4ERR_BAD_STATEID     = 10025,/* incorrect stateid       */
     NFS4ERR_BAD_SEQID       = 10026,/* request is out of seq.  */
     NFS4ERR_NOT_SAME        = 10027,/* verify - attrs not same */
     NFS4ERR_LOCK_RANGE      = 10028,/* lock range not supported*/
     NFS4ERR_SYMLINK         = 10029,/* should be file/directory*/
     NFS4ERR_RESTOREFH       = 10030,/* no saved filehandle     */
     NFS4ERR_LEASE_MOVED     = 10031,/* some filesystem moved   */
     NFS4ERR_ATTRNOTSUPP     = 10032,/* recommended attr not sup*/
     NFS4ERR_NO_GRACE        = 10033,/* reclaim outside of grace*/
     NFS4ERR_RECLAIM_BAD     = 10034,/* reclaim error at server */
     NFS4ERR_RECLAIM_CONFLICT = 10035,/* conflict on reclaim    */
     NFS4ERR_BADZDR          = 10036,/* ZDR decode failed       */
     NFS4ERR_LOCKS_HELD      = 10037,/* file locks held at CLOSE*/
     NFS4ERR_OPENMODE        = 10038,/* conflict in OPEN and I/O*/
     NFS4ERR_BADOWNER        = 10039,/* owner translation bad   */
     NFS4ERR_BADCHAR         = 10040,/* utf-8 char not supported*/
     NFS4ERR_BADNAME         = 10041,/* name not supported      */
     NFS4ERR_BAD_RANGE       = 10042,/* lock range not supported*/
     NFS4ERR_LOCK_NOTSUPP    = 10043,/* no atomic up/downgrade  */
     NFS4ERR_OP_ILLEGAL      = 10044,/* undefined operation     */
     NFS4ERR_DEADLOCK        = 10045,/* file locking deadlock   */
     NFS4ERR_FILE_OPEN       = 10046,/* open file blocks op.    */
     NFS4ERR_ADMIN_REVOKED   = 10047,/* lockowner state revoked */
     NFS4ERR_CB_PATH_DOWN    = 10048,/* callback path down      */
     NFS4ERR_BADIOMODE       = 10049,
     NFS4ERR_BADLAYOUT       = 10050,
     NFS4ERR_BAD_SESSION_DIGEST = 10051,
     NFS4ERR_BADSESSION      = 10052,
     NFS4ERR_BADSLOT         = 10053,
     NFS4ERR_COMPLETE_ALREADY = 10054,
     NFS4ERR_CONN_NOT_BOUND_TO_SESSION = 10055,
     NFS4ERR_DELEG_ALREADY_WANTED = 10056,
     NFS4ERR_BACK_CHAN_BUSY  = 10057,
     NFS4ERR_LAYOUTTRYLATER  = 10058,
     NFS4ERR_LAYOUTUNAVAILABLE = 10059,
     NFS4ERR_NOMATCHING_LAYOUT = 10060,
     NFS4ERR_RECALLCONFLICT  = 10061
};

/*
 * Basic data types
 */
typedef uint32_t        bitmap4<>;
typedef uint64_t        offset4;
typedef uint32_t        count4;
typedef uint64_t        length4;
typedef uint64_t        clientid4;
typedef uint32_t	sequenceid4;
typedef uint32_t        seqid4;
typedef uint32_t        slotid4;
typedef opaque          utf8string<>;
typedef utf8string      utf8str_cis;
typedef utf8string      utf8str_cs;
typedef utf8string      utf8str_mixed;
typedef utf8str_cs      component4;
typedef component4      pathname4<>;
typedef uint64_t        nfs_lockid4;
typedef uint64_t        nfs_cookie4;
typedef utf8str_cs      linktext4;
typedef opaque          sec_oid4<>;
typedef uint32_t        qop4;
typedef uint32_t        mode4;
typedef uint64_t        changeid4;
typedef opaque          verifier4[NFS4_VERIFIER_SIZE];
typedef opaque          sessionid4[NFS4_SESSIONID_SIZE];
/*
 * Authsys_parms
 */
struct authsys_parms {
     unsigned int stamp;
     string machinename<255>;
     unsigned int uid;
     unsigned int gid;
     unsigned int gids<16>;
};

const NFS4_DEVICEID4_SIZE = 16;

typedef opaque  deviceid4[NFS4_DEVICEID4_SIZE];

enum layouttype4 {
       LAYOUT4_NFSV4_1_FILES   = 0x1,
       LAYOUT4_OSD2_OBJECTS    = 0x2,
       LAYOUT4_BLOCK_VOLUME    = 0x3
};

struct layoutupdate4 {
       layouttype4             lou_type;
       opaque                  lou_body<>;
};


struct device_addr4 {
       layouttype4             da_layout_type;
       opaque                  da_addr_body<>;
};

/*
 * Timeval
 */
struct nfstime4 {
     int64_t         seconds;
     uint32_t        nseconds;
};

enum time_how4 {
     SET_TO_SERVER_TIME4 = 0,
     SET_TO_CLIENT_TIME4 = 1
};

enum layoutiomode4 {
       LAYOUTIOMODE4_READ      = 1,
       LAYOUTIOMODE4_RW        = 2,
       LAYOUTIOMODE4_ANY       = 3
};

struct layout_content4 {
       layouttype4 loc_type;
       opaque      loc_body<>;
};

struct layout4 {
       offset4                 lo_offset;
       length4                 lo_length;
       layoutiomode4           lo_iomode;
       layout_content4         lo_content;
};

union settime4 switch (time_how4 set_it) {
   case SET_TO_CLIENT_TIME4:
        nfstime4 time;
   default:
        void;
};

/*
 * File access handle
 */
typedef opaque  nfs_fh4<NFS4_FHSIZE>;

/*
 * File attribute definitions
 */

/*
 * FSID structure for major/minor
 */
struct fsid4 {
     uint64_t        major;
     uint64_t        minor;
};

/*
 * Filesystem locations attribute for relocation/migration
 */
struct fs_location4 {
     utf8str_cis     server<>;
     pathname4       rootpath;
};

struct fs_locations4 {
     pathname4       fs_root;
     fs_location4    locations<>;
};

/*
 * Various Access Control Entry definitions
 */

/*
 * Mask that indicates which Access Control Entries are supported.
 * Values for the fattr4_aclsupport attribute.
 */
const ACL4_SUPPORT_ALLOW_ACL    = 0x00000001;
const ACL4_SUPPORT_DENY_ACL     = 0x00000002;
const ACL4_SUPPORT_AUDIT_ACL    = 0x00000004;
const ACL4_SUPPORT_ALARM_ACL    = 0x00000008;


typedef uint32_t        acetype4;
/*
 * acetype4 values, others can be added as needed.
 */
const ACE4_ACCESS_ALLOWED_ACE_TYPE      = 0x00000000;
const ACE4_ACCESS_DENIED_ACE_TYPE       = 0x00000001;
const ACE4_SYSTEM_AUDIT_ACE_TYPE        = 0x00000002;
const ACE4_SYSTEM_ALARM_ACE_TYPE        = 0x00000003;


/*
 * ACE flag
 */
typedef uint32_t aceflag4;

/*
 * ACE flag values
 */
const ACE4_FILE_INHERIT_ACE             = 0x00000001;
const ACE4_DIRECTORY_INHERIT_ACE        = 0x00000002;
const ACE4_NO_PROPAGATE_INHERIT_ACE     = 0x00000004;
const ACE4_INHERIT_ONLY_ACE             = 0x00000008;
const ACE4_SUCCESSFUL_ACCESS_ACE_FLAG   = 0x00000010;
const ACE4_FAILED_ACCESS_ACE_FLAG       = 0x00000020;
const ACE4_IDENTIFIER_GROUP             = 0x00000040;


/*
 * ACE mask
 */
typedef uint32_t        acemask4;

/*
 * ACE mask values
 */
const ACE4_READ_DATA            = 0x00000001;
const ACE4_LIST_DIRECTORY       = 0x00000001;
const ACE4_WRITE_DATA           = 0x00000002;
const ACE4_ADD_FILE             = 0x00000002;
const ACE4_APPEND_DATA          = 0x00000004;
const ACE4_ADD_SUBDIRECTORY     = 0x00000004;
const ACE4_READ_NAMED_ATTRS     = 0x00000008;
const ACE4_WRITE_NAMED_ATTRS    = 0x00000010;
const ACE4_EXECUTE              = 0x00000020;
const ACE4_DELETE_CHILD         = 0x00000040;
const ACE4_READ_ATTRIBUTES      = 0x00000080;
const ACE4_WRITE_ATTRIBUTES     = 0x00000100;
const ACE4_DELETE               = 0x00010000;
const ACE4_READ_ACL             = 0x00020000;
const ACE4_WRITE_ACL            = 0x00040000;
const ACE4_WRITE_OWNER          = 0x00080000;
const ACE4_SYNCHRONIZE          = 0x00100000;

/*
 * ACE4_GENERIC_READ -- defined as combination of
 *      ACE4_READ_ACL |
 *      ACE4_READ_DATA |
 *      ACE4_READ_ATTRIBUTES |
 *      ACE4_SYNCHRONIZE
 */
const ACE4_GENERIC_READ = 0x00120081;

/*
 * ACE4_GENERIC_WRITE -- defined as combination of
 *      ACE4_READ_ACL |
 *      ACE4_WRITE_DATA |
 *      ACE4_WRITE_ATTRIBUTES |
 *      ACE4_WRITE_ACL |
 *      ACE4_APPEND_DATA |
 *      ACE4_SYNCHRONIZE
 */
const ACE4_GENERIC_WRITE = 0x00160106;

/*
 * ACE4_GENERIC_EXECUTE -- defined as combination of
 *      ACE4_READ_ACL
 *      ACE4_READ_ATTRIBUTES
 *      ACE4_EXECUTE
 *      ACE4_SYNCHRONIZE
 */
const ACE4_GENERIC_EXECUTE = 0x001200A0;


/*
 * Access Control Entry definition
 */
struct nfsace4 {
     acetype4        type;
     aceflag4        flag;
     acemask4        access_mask;
     utf8str_mixed   who;
};

/*
 * Field definitions for the fattr4_mode attribute
 */
const MODE4_SUID = 0x800;  /* set user id on execution */
const MODE4_SGID = 0x400;  /* set group id on execution */
const MODE4_SVTX = 0x200;  /* save text even after use */
const MODE4_RUSR = 0x100;  /* read permission: owner */
const MODE4_WUSR = 0x080;  /* write permission: owner */
const MODE4_XUSR = 0x040;  /* execute permission: owner */
const MODE4_RGRP = 0x020;  /* read permission: group */
const MODE4_WGRP = 0x010;  /* write permission: group */
const MODE4_XGRP = 0x008;  /* execute permission: group */
const MODE4_ROTH = 0x004;  /* read permission: other */
const MODE4_WOTH = 0x002;  /* write permission: other */
const MODE4_XOTH = 0x001;  /* execute permission: other */

/*
 * Special data/attribute associated with
 * file types NF4BLK and NF4CHR.
 */
struct specdata4 {
     uint32_t        specdata1;      /* major device number */
     uint32_t        specdata2;      /* minor device number */
};

/*
 * Values for fattr4_fh_expire_type
 */
const   FH4_PERSISTENT          = 0x00000000;
const   FH4_NOEXPIRE_WITH_OPEN  = 0x00000001;
const   FH4_VOLATILE_ANY        = 0x00000002;
const   FH4_VOL_MIGRATION       = 0x00000004;
const   FH4_VOL_RENAME          = 0x00000008;


typedef bitmap4         fattr4_supported_attrs;
typedef nfs_ftype4      fattr4_type;
typedef uint32_t        fattr4_fh_expire_type;
typedef changeid4       fattr4_change;
typedef uint64_t        fattr4_size;
typedef bool            fattr4_link_support;
typedef bool            fattr4_symlink_support;
typedef bool            fattr4_named_attr;
typedef fsid4           fattr4_fsid;
typedef bool            fattr4_unique_handles;
typedef uint32_t        fattr4_lease_time;
typedef nfsstat4        fattr4_rdattr_error;
typedef nfsace4         fattr4_acl<>;
typedef uint32_t        fattr4_aclsupport;
typedef bool            fattr4_archive;
typedef bool            fattr4_cansettime;
typedef bool            fattr4_case_insensitive;
typedef bool            fattr4_case_preserving;
typedef bool            fattr4_chown_restricted;
typedef uint64_t        fattr4_fileid;
typedef uint64_t        fattr4_files_avail;
typedef nfs_fh4         fattr4_filehandle;
typedef uint64_t        fattr4_files_free;
typedef uint64_t        fattr4_files_total;
typedef fs_locations4   fattr4_fs_locations;
typedef bool            fattr4_hidden;
typedef bool            fattr4_homogeneous;
typedef uint64_t        fattr4_maxfilesize;
typedef uint32_t        fattr4_maxlink;
typedef uint32_t        fattr4_maxname;
typedef uint64_t        fattr4_maxread;
typedef uint64_t        fattr4_maxwrite;
typedef utf8str_cs      fattr4_mimetype;
typedef mode4           fattr4_mode;
typedef uint64_t        fattr4_mounted_on_fileid;
typedef bool            fattr4_no_trunc;
typedef uint32_t        fattr4_numlinks;
typedef utf8str_mixed   fattr4_owner;
typedef utf8str_mixed   fattr4_owner_group;
typedef uint64_t        fattr4_quota_avail_hard;
typedef uint64_t        fattr4_quota_avail_soft;
typedef uint64_t        fattr4_quota_used;
typedef specdata4       fattr4_rawdev;
typedef uint64_t        fattr4_space_avail;
typedef uint64_t        fattr4_space_free;
typedef uint64_t        fattr4_space_total;
typedef uint64_t        fattr4_space_used;
typedef bool            fattr4_system;
typedef nfstime4        fattr4_time_access;
typedef settime4        fattr4_time_access_set;
typedef nfstime4        fattr4_time_backup;
typedef nfstime4        fattr4_time_create;
typedef nfstime4        fattr4_time_delta;
typedef nfstime4        fattr4_time_metadata;
typedef nfstime4        fattr4_time_modify;
typedef settime4        fattr4_time_modify_set;


/*
 * Mandatory Attributes
 */
const FATTR4_SUPPORTED_ATTRS    = 0;
const FATTR4_TYPE               = 1;
const FATTR4_FH_EXPIRE_TYPE     = 2;
const FATTR4_CHANGE             = 3;
const FATTR4_SIZE               = 4;
const FATTR4_LINK_SUPPORT       = 5;
const FATTR4_SYMLINK_SUPPORT    = 6;
const FATTR4_NAMED_ATTR         = 7;
const FATTR4_FSID               = 8;
const FATTR4_UNIQUE_HANDLES     = 9;
const FATTR4_LEASE_TIME         = 10;
const FATTR4_RDATTR_ERROR       = 11;
const FATTR4_FILEHANDLE         = 19;

/*
 * Recommended Attributes
 */
const FATTR4_ACL                = 12;
const FATTR4_ACLSUPPORT         = 13;
const FATTR4_ARCHIVE            = 14;
const FATTR4_CANSETTIME         = 15;
const FATTR4_CASE_INSENSITIVE   = 16;
const FATTR4_CASE_PRESERVING    = 17;
const FATTR4_CHOWN_RESTRICTED   = 18;
const FATTR4_FILEID             = 20;
const FATTR4_FILES_AVAIL        = 21;
const FATTR4_FILES_FREE         = 22;
const FATTR4_FILES_TOTAL        = 23;
const FATTR4_FS_LOCATIONS       = 24;
const FATTR4_HIDDEN             = 25;
const FATTR4_HOMOGENEOUS        = 26;
const FATTR4_MAXFILESIZE        = 27;
const FATTR4_MAXLINK            = 28;
const FATTR4_MAXNAME            = 29;
const FATTR4_MAXREAD            = 30;
const FATTR4_MAXWRITE           = 31;
const FATTR4_MIMETYPE           = 32;
const FATTR4_MODE               = 33;
const FATTR4_NO_TRUNC           = 34;
const FATTR4_NUMLINKS           = 35;
const FATTR4_OWNER              = 36;
const FATTR4_OWNER_GROUP        = 37;
const FATTR4_QUOTA_AVAIL_HARD   = 38;
const FATTR4_QUOTA_AVAIL_SOFT   = 39;
const FATTR4_QUOTA_USED         = 40;
const FATTR4_RAWDEV             = 41;
const FATTR4_SPACE_AVAIL        = 42;
const FATTR4_SPACE_FREE         = 43;
const FATTR4_SPACE_TOTAL        = 44;
const FATTR4_SPACE_USED         = 45;
const FATTR4_SYSTEM             = 46;
const FATTR4_TIME_ACCESS        = 47;
const FATTR4_TIME_ACCESS_SET    = 48;
const FATTR4_TIME_BACKUP        = 49;
const FATTR4_TIME_CREATE        = 50;
const FATTR4_TIME_DELTA         = 51;
const FATTR4_TIME_METADATA      = 52;
const FATTR4_TIME_MODIFY        = 53;
const FATTR4_TIME_MODIFY_SET    = 54;
const FATTR4_MOUNTED_ON_FILEID  = 55;

typedef opaque  attrlist4<>;

/*
 * File attribute container
 */
struct fattr4 {
     bitmap4         attrmask;
     attrlist4       attr_vals;
};

/*
 * Change info for the client
 */
struct change_info4 {
     bool            atomic;
     changeid4       before;
     changeid4       after;
};

struct clientaddr4 {
        /* see struct rpcb in RFC 1833 */
        string r_netid<>;               /* network id */
        string r_addr<>;                /* universal address */
};

/*
 * Callback program info as provided by the client
 */
struct cb_client4 {
        uint32_t        cb_program;
        clientaddr4     cb_location;
};

/*
 * Stateid
 */
struct stateid4 {
        uint32_t        seqid;
        opaque          other[12];
};

/*
 * Client ID
 */
struct nfs_client_id4 {
        verifier4       verifier;
        opaque          id<NFS4_OPAQUE_LIMIT>;
};

struct open_owner4 {
        clientid4       clientid;
        opaque          owner<NFS4_OPAQUE_LIMIT>;
};

struct lock_owner4 {
        clientid4       clientid;
        opaque          owner<NFS4_OPAQUE_LIMIT>;
};

enum nfs_lock_type4 {
        READ_LT         = 1,
        WRITE_LT        = 2,
        READW_LT        = 3,    /* blocking read */
        WRITEW_LT       = 4     /* blocking write */
};

/*
 * Client owner
 */
struct client_owner4 {
        verifier4       co_verifier;
        opaque          co_ownerid<NFS4_OPAQUE_LIMIT>;
};

/*
 * Server owner
 */
struct server_owner4 {
        uint64_t       so_minor_id;
        opaque         so_major_id<NFS4_OPAQUE_LIMIT>;
};

/*
 * NFS implementation details
 */
struct nfs_impl_id4 {
        utf8str_cis   nii_domain;
        utf8str_cs    nii_name;
        nfstime4      nii_date;
};

/*
 * ACCESS: Check access permission
 */
const ACCESS4_READ      = 0x00000001;
const ACCESS4_LOOKUP    = 0x00000002;
const ACCESS4_MODIFY    = 0x00000004;
const ACCESS4_EXTEND    = 0x00000008;
const ACCESS4_DELETE    = 0x00000010;
const ACCESS4_EXECUTE   = 0x00000020;

struct ACCESS4args {
        /* CURRENT_FH: object */
        uint32_t        access;
};

struct ACCESS4resok {
        uint32_t        supported;
        uint32_t        access;
};

union ACCESS4res switch (nfsstat4 status) {
 case NFS4_OK:
         ACCESS4resok   resok4;
 default:
         void;
};

/*
 * CLOSE: Close a file and release share reservations
 */
struct CLOSE4args {
        /* CURRENT_FH: object */
        seqid4          seqid;
        stateid4        open_stateid;
};

union CLOSE4res switch (nfsstat4 status) {
 case NFS4_OK:
         stateid4       open_stateid;
 default:
         void;
};

/*
 * COMMIT: Commit cached data on server to stable storage
 */
struct COMMIT4args {
        /* CURRENT_FH: file */
        offset4         offset;
        count4          count;
};

struct COMMIT4resok {
        verifier4       writeverf;
};


union COMMIT4res switch (nfsstat4 status) {
 case NFS4_OK:
         COMMIT4resok   resok4;
 default:
         void;
};

/*
 * CREATE: Create a non-regular file
 */
union createtype4 switch (nfs_ftype4 type) {
 case NF4LNK:
         linktext4      linkdata;
 case NF4BLK:
 case NF4CHR:
         specdata4      devdata;
 case NF4SOCK:
 case NF4FIFO:
 case NF4DIR:
         void;
 default:
         void;          /* server should return NFS4ERR_BADTYPE */
};

struct CREATE4args {
        /* CURRENT_FH: directory for creation */
        createtype4     objtype;
        component4      objname;
        fattr4          createattrs;
};

struct CREATE4resok {
        change_info4    cinfo;
        bitmap4         attrset;        /* attributes set */
};

union CREATE4res switch (nfsstat4 status) {
 case NFS4_OK:
         CREATE4resok resok4;
 default:
         void;
};

/*
 * DELEGPURGE: Purge Delegations Awaiting Recovery
 */
struct DELEGPURGE4args {
        clientid4       clientid;
};

struct DELEGPURGE4res {
        nfsstat4        status;
};

/*
 * DELEGRETURN: Return a delegation
 */
struct DELEGRETURN4args {
        /* CURRENT_FH: delegated file */
        stateid4        deleg_stateid;
};

struct DELEGRETURN4res {
        nfsstat4        status;
};

/*
 * GETATTR: Get file attributes
 */
struct GETATTR4args {
        /* CURRENT_FH: directory or file */
        bitmap4         attr_request;
};

struct GETATTR4resok {
        fattr4          obj_attributes;
};

union GETATTR4res switch (nfsstat4 status) {
 case NFS4_OK:
         GETATTR4resok  resok4;
 default:
         void;
};

/*
 * GETFH: Get current filehandle
 */
struct GETFH4resok {
        nfs_fh4         object;
};

union GETFH4res switch (nfsstat4 status) {
 case NFS4_OK:
        GETFH4resok     resok4;
 default:
        void;
};

/*
 * LINK: Create link to an object
 */
struct LINK4args {
        /* SAVED_FH: source object */
        /* CURRENT_FH: target directory */
        component4      newname;
};

struct LINK4resok {
        change_info4    cinfo;
};

union LINK4res switch (nfsstat4 status) {
 case NFS4_OK:
         LINK4resok resok4;
 default:
         void;
};

/*
 * For LOCK, transition from open_owner to new lock_owner
 */
struct open_to_lock_owner4 {
        seqid4          open_seqid;
        stateid4        open_stateid;
        seqid4          lock_seqid;
        lock_owner4     lock_owner;
};

/*
 * For LOCK, existing lock_owner continues to request file locks
 */
struct exist_lock_owner4 {
        stateid4        lock_stateid;
        seqid4          lock_seqid;
};

union locker4 switch (bool new_lock_owner) {
 case TRUE:
        open_to_lock_owner4     open_owner;
 case FALSE:
        exist_lock_owner4       lock_owner;
};

/*
 * LOCK/LOCKT/LOCKU: Record lock management
 */
struct LOCK4args {
        /* CURRENT_FH: file */
        nfs_lock_type4  locktype;
        bool            reclaim;
        offset4         offset;
        length4         length;
        locker4         locker;
};

struct LOCK4denied {
        offset4         offset;
        length4         length;
        nfs_lock_type4  locktype;
        lock_owner4     owner;
};

struct LOCK4resok {
        stateid4        lock_stateid;
};

union LOCK4res switch (nfsstat4 status) {
 case NFS4_OK:
         LOCK4resok     resok4;
 case NFS4ERR_DENIED:
         LOCK4denied    denied;
 default:
         void;
};

struct LOCKT4args {
        /* CURRENT_FH: file */
        nfs_lock_type4  locktype;
        offset4         offset;
        length4         length;
        lock_owner4     owner;
};

union LOCKT4res switch (nfsstat4 status) {
 case NFS4ERR_DENIED:
         LOCK4denied    denied;
 case NFS4_OK:
         void;
 default:
         void;
};

struct LOCKU4args {
        /* CURRENT_FH: file */
        nfs_lock_type4  locktype;
        seqid4          seqid;
        stateid4        lock_stateid;
        offset4         offset;
        length4         length;
};

union LOCKU4res switch (nfsstat4 status) {
 case   NFS4_OK:
         stateid4       lock_stateid;
 default:
         void;
};

/*
 * LOOKUP: Lookup filename
 */
struct LOOKUP4args {
        /* CURRENT_FH: directory */
        component4      objname;
};

struct LOOKUP4res {
        /* CURRENT_FH: object */
        nfsstat4        status;
};

/*
 * LOOKUPP: Lookup parent directory
 */
struct LOOKUPP4res {
        /* CURRENT_FH: directory */
        nfsstat4        status;
};

/*
 * NVERIFY: Verify attributes different
 */
struct NVERIFY4args {
        /* CURRENT_FH: object */
        fattr4          obj_attributes;
};

struct NVERIFY4res {
        nfsstat4        status;
};

/*
 * Various definitions for OPEN
 */
enum createmode4 {
        UNCHECKED4      = 0,
        GUARDED4        = 1,
        EXCLUSIVE4      = 2
};

union createhow4 switch (createmode4 mode) {
 case UNCHECKED4:
 case GUARDED4:
         fattr4         createattrs;
 case EXCLUSIVE4:
         verifier4      createverf;
};

enum opentype4 {
        OPEN4_NOCREATE  = 0,
        OPEN4_CREATE    = 1
};

union openflag4 switch (opentype4 opentype) {
 case OPEN4_CREATE:
         createhow4     how;
 default:
         void;
};

/* Next definitions used for OPEN delegation */
enum limit_by4 {
        NFS_LIMIT_SIZE          = 1,
        NFS_LIMIT_BLOCKS        = 2
        /* others as needed */
};

struct nfs_modified_limit4 {
        uint32_t        num_blocks;
        uint32_t        bytes_per_block;
};

union nfs_space_limit4 switch (limit_by4 limitby) {
 /* limit specified as file size */
 case NFS_LIMIT_SIZE:
         uint64_t               filesize;
 /* limit specified by number of blocks */
 case NFS_LIMIT_BLOCKS:
         nfs_modified_limit4    mod_blocks;
} ;

/*
 * Share Access and Deny constants for open argument
 */
const OPEN4_SHARE_ACCESS_READ   = 0x00000001;
const OPEN4_SHARE_ACCESS_WRITE  = 0x00000002;
const OPEN4_SHARE_ACCESS_BOTH   = 0x00000003;

const OPEN4_SHARE_DENY_NONE     = 0x00000000;
const OPEN4_SHARE_DENY_READ     = 0x00000001;
const OPEN4_SHARE_DENY_WRITE    = 0x00000002;
const OPEN4_SHARE_DENY_BOTH     = 0x00000003;

enum open_delegation_type4 {
        OPEN_DELEGATE_NONE      = 0,
        OPEN_DELEGATE_READ      = 1,
        OPEN_DELEGATE_WRITE     = 2
};

enum open_claim_type4 {
        CLAIM_NULL              = 0,
        CLAIM_PREVIOUS          = 1,
        CLAIM_DELEGATE_CUR      = 2,
        CLAIM_DELEGATE_PREV     = 3,
        CLAIM_FH                = 4, /* new to v4.1 */
        CLAIM_DELEG_CUR_FH      = 5, /* new to v4.1 */
        CLAIM_DELEG_PREV_FH     = 6 /* new to v4.1 */
};

struct open_claim_delegate_cur4 {
        stateid4        delegate_stateid;
        component4      file;
};

union open_claim4 switch (open_claim_type4 claim) {
 /*
  * No special rights to file. Ordinary OPEN of the specified file.
  */
 case CLAIM_NULL:
        /* CURRENT_FH: directory */
        component4      file;

 /*
  * 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 CLAIM_PREVIOUS:
        /* CURRENT_FH: file being reclaimed */
        open_delegation_type4   delegate_type;

 /*
  * Right to file based on a delegation granted by the server.
  * File is specified by name.
  */
 case CLAIM_DELEGATE_CUR:
        /* CURRENT_FH: directory */
        open_claim_delegate_cur4        delegate_cur_info;

 /* Right to file based on a delegation granted to a previous boot
  * instance of the client.  File is specified by name.
  */
 case CLAIM_DELEGATE_PREV:
        /* CURRENT_FH: directory */
        component4      file_delegate_prev;

 /*
  * Like CLAIM_NULL.  No special rights
  * to file.  Ordinary OPEN of the
  * specified file by current filehandle.
  */
 case CLAIM_FH: /* new to v4.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 CLAIM_DELEG_PREV_FH: /* new to v4.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 CLAIM_DELEG_CUR_FH: /* new to v4.1 */
        /* CURRENT_FH: file being opened */
        stateid4       oc_delegate_stateid;
};

/*
 * OPEN: Open a file, potentially receiving an open delegation
 */
struct OPEN4args {
        seqid4          seqid;
        uint32_t        share_access;
        uint32_t        share_deny;
        open_owner4     owner;
        openflag4       openhow;
        open_claim4     claim;
};

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 */
};

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. */
};

union open_delegation4
switch (open_delegation_type4 delegation_type) {
        case OPEN_DELEGATE_NONE:
                void;
        case OPEN_DELEGATE_READ:
                open_read_delegation4 read;
        case OPEN_DELEGATE_WRITE:
                open_write_delegation4 write;
};
/*
 * Result flags
 */
/* Client must confirm open */
const OPEN4_RESULT_CONFIRM      = 0x00000002;
/* Type of file locking behavior at the server */
const OPEN4_RESULT_LOCKTYPE_POSIX = 0x00000004;

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 */
};

union OPEN4res switch (nfsstat4 status) {
 case NFS4_OK:
        /* CURRENT_FH: opened file */
        OPEN4resok      resok4;
 default:
        void;
};

/*
 * OPENATTR: open named attributes directory
 */
struct OPENATTR4args {
        /* CURRENT_FH: object */
        bool    createdir;
};

struct OPENATTR4res {
        /* CURRENT_FH: named attr directory */
        nfsstat4        status;
};

/*
 * OPEN_CONFIRM: confirm the open
 */
struct OPEN_CONFIRM4args {
        /* CURRENT_FH: opened file */
        stateid4        open_stateid;
        seqid4          seqid;
};

struct OPEN_CONFIRM4resok {
        stateid4        open_stateid;
};

union OPEN_CONFIRM4res switch (nfsstat4 status) {
    case NFS4_OK:
            OPEN_CONFIRM4resok     resok4;
 default:
         void;
};

/*
 * OPEN_DOWNGRADE: downgrade the access/deny for a file
 */
struct OPEN_DOWNGRADE4args {
        /* CURRENT_FH: opened file */
        stateid4        open_stateid;
        seqid4          seqid;
        uint32_t        share_access;
        uint32_t        share_deny;
};

struct OPEN_DOWNGRADE4resok {
        stateid4        open_stateid;
};

union OPEN_DOWNGRADE4res switch(nfsstat4 status) {
 case NFS4_OK:
        OPEN_DOWNGRADE4resok    resok4;
 default:
         void;
};

/*
 * PUTFH: Set current filehandle
 */
struct PUTFH4args {
        nfs_fh4         object;
};

struct PUTFH4res {
        /* CURRENT_FH: */
        nfsstat4        status;
};

/*
 * PUTPUBFH: Set public filehandle
 */
struct PUTPUBFH4res {
        /* CURRENT_FH: public fh */
        nfsstat4        status;
};

/*
 * PUTROOTFH: Set root filehandle
 */
struct PUTROOTFH4res {

        /* CURRENT_FH: root fh */
        nfsstat4        status;
};

/*
 * READ: Read from file
 */
struct READ4args {
        /* CURRENT_FH: file */
        stateid4        stateid;
        offset4         offset;
        count4          count;
};

struct READ4resok {
        bool            eof;
        opaque          data<>;
};

union READ4res switch (nfsstat4 status) {
 case NFS4_OK:
         READ4resok     resok4;
 default:
         void;
};

/*
 * READDIR: Read directory
 */
struct READDIR4args {
        /* CURRENT_FH: directory */
        nfs_cookie4     cookie;
        verifier4       cookieverf;
        count4          dircount;
        count4          maxcount;
        bitmap4         attr_request;
};

struct entry4 {
        nfs_cookie4     cookie;
        component4      name;
        fattr4          attrs;
        entry4          *nextentry;
};

struct dirlist4 {
        entry4          *entries;
        bool            eof;
};

struct READDIR4resok {
        verifier4       cookieverf;
        dirlist4        reply;
};


union READDIR4res switch (nfsstat4 status) {
 case NFS4_OK:
         READDIR4resok  resok4;
 default:
         void;
};


/*
 * READLINK: Read symbolic link
 */
struct READLINK4resok {
        linktext4       link;
};

union READLINK4res switch (nfsstat4 status) {
 case NFS4_OK:
         READLINK4resok resok4;
 default:
         void;
};

/*
 * REMOVE: Remove filesystem object
 */
struct REMOVE4args {
        /* CURRENT_FH: directory */
        component4      target;
};

struct REMOVE4resok {
        change_info4    cinfo;
};

union REMOVE4res switch (nfsstat4 status) {
 case NFS4_OK:
         REMOVE4resok   resok4;
 default:
         void;
};

/*
 * RENAME: Rename directory entry
 */
struct RENAME4args {
        /* SAVED_FH: source directory */
        component4      oldname;
        /* CURRENT_FH: target directory */

        component4      newname;
};

struct RENAME4resok {
        change_info4    source_cinfo;
        change_info4    target_cinfo;
};

union RENAME4res switch (nfsstat4 status) {
 case NFS4_OK:
        RENAME4resok    resok4;
 default:
        void;
};

/*
 * RENEW: Renew a Lease
 */
struct RENEW4args {
        clientid4       clientid;
};

struct RENEW4res {
        nfsstat4        status;
};

/*
 * RESTOREFH: Restore saved filehandle
 */

struct RESTOREFH4res {
        /* CURRENT_FH: value of saved fh */
        nfsstat4        status;
};

/*
 * SAVEFH: Save current filehandle
 */
struct SAVEFH4res {
        /* SAVED_FH: value of current fh */
        nfsstat4        status;
};

/*
 * SECINFO: Obtain Available Security Mechanisms
 */
struct SECINFO4args {
        component4      name;
};

enum rpc_gss_svc_t {
        RPC_GSS_SVC_NONE        = 1,
        RPC_GSS_SVC_INTEGRITY   = 2,
        RPC_GSS_SVC_PRIVACY     = 3
};

struct rpcsec_gss_info {
        sec_oid4        oid;
        qop4            qop;
        rpc_gss_svc_t   service;
};

const RPCSEC_GSS = 6;

union secinfo4 switch (uint32_t flavor) {
 case RPCSEC_GSS:
         rpcsec_gss_info        flavor_info;
 default:
         void;
};

typedef secinfo4 SECINFO4resok<>;

union SECINFO4res switch (nfsstat4 status) {
 case NFS4_OK:
         SECINFO4resok resok4;
 default:
         void;
};

/*
 * SETATTR: Set attributes
 */
struct SETATTR4args {
        /* CURRENT_FH: target object */
        stateid4        stateid;
        fattr4          obj_attributes;
};

struct SETATTR4res {
        nfsstat4        status;
        bitmap4         attrsset;
};

/*
 * SETCLIENTID
 */
struct SETCLIENTID4args {
        nfs_client_id4  client;
        cb_client4      callback;
        uint32_t        callback_ident;

};

struct SETCLIENTID4resok {
        clientid4       clientid;
        verifier4       setclientid_confirm;
};

union SETCLIENTID4res switch (nfsstat4 status) {
 case NFS4_OK:
         SETCLIENTID4resok      resok4;
 case NFS4ERR_CLID_INUSE:
         clientaddr4    client_using;
 default:
         void;
};

struct SETCLIENTID_CONFIRM4args {
        clientid4       clientid;
        verifier4       setclientid_confirm;
};

struct SETCLIENTID_CONFIRM4res {
        nfsstat4        status;
};

/*
 * VERIFY: Verify attributes same
 */
struct VERIFY4args {
        /* CURRENT_FH: object */
        fattr4          obj_attributes;
};

struct VERIFY4res {
        nfsstat4        status;
};

/*
 * WRITE: Write to file
 */
enum stable_how4 {
        UNSTABLE4       = 0,
        DATA_SYNC4      = 1,
        FILE_SYNC4      = 2
};

struct WRITE4args {
        /* CURRENT_FH: file */
        stateid4        stateid;
        offset4         offset;
        stable_how4     stable;
        opaque          data<>;
};

struct WRITE4resok {
        count4          count;
        stable_how4     committed;
        verifier4       writeverf;
};

union WRITE4res switch (nfsstat4 status) {
 case NFS4_OK:
         WRITE4resok    resok4;
 default:
         void;
};

/*
 * RELEASE_LOCKOWNER: Notify server to release lockowner
 */
struct RELEASE_LOCKOWNER4args {
        lock_owner4     lock_owner;
};

struct RELEASE_LOCKOWNER4res {
        nfsstat4        status;
};

/*
 * BACKCHANNEL_CTL
 */
typedef opaque gsshandle4_t<>;

/*
struct gss_cb_handles4 {
       rpc_gss_svc_t           gcbp_service; RFC 2203
       gsshandle4_t            gcbp_handle_from_server;
       gsshandle4_t            gcbp_handle_from_client;
};
*/

union callback_sec_parms4 switch (uint32_t cb_secflavor) {
case AUTH_NONE:
       void;
case AUTH_SYS:
       authsys_parms   cbsp_sys_cred; /* RFC 1831 */
/*
 * case RPCSEC_GSS:
 *     gss_cb_handles4 cbsp_gss_handles;
 */
};

/*
struct BACKCHANNEL_CTL4args {
       uint32_t                bca_cb_program;
       callback_sec_parms4     bca_sec_parms<>;
};
*/

/*
 * BIND_CONN_TO_SESSION
 */
enum channel_dir_from_client4 {
        CDFC4_FORE             = 0x1,
        CDFC4_BACK             = 0x2,
        CDFC4_FORE_OR_BOTH     = 0x3,
        CDFC4_BACK_OR_BOTH     = 0x7
};

struct BIND_CONN_TO_SESSION4args {
        sessionid4     bctsa_sessid;
        channel_dir_from_client4 bctsa_dir;
        bool           bctsa_use_conn_in_rdma_mode;
};

enum channel_dir_from_server4 {
        CDFS4_FORE     = 0x1,
        CDFS4_BACK     = 0x2,
        CDFS4_BOTH     = 0x3
};

struct BIND_CONN_TO_SESSION4resok {
        sessionid4     bctsr_sessid;
        channel_dir_from_server4 bctsr_dir;
        bool           bctsr_use_conn_in_rdma_mode;
};

union BIND_CONN_TO_SESSION4res switch (nfsstat4 bctsr_status) {
case NFS4_OK:
        BIND_CONN_TO_SESSION4resok bctsr_resok4;
default:
        void;
};

/*
 * EXCHANGE_ID
 */
const EXCHGID4_FLAG_SUPP_MOVED_REFER    = 0x00000001;
const EXCHGID4_FLAG_SUPP_MOVED_MIGR     = 0x00000002;

const EXCHGID4_FLAG_BIND_PRINC_STATEID  = 0x00000100;

const EXCHGID4_FLAG_USE_NON_PNFS        = 0x00010000;
const EXCHGID4_FLAG_USE_PNFS_MDS        = 0x00020000;
const EXCHGID4_FLAG_USE_PNFS_DS         = 0x00040000;

const EXCHGID4_FLAG_MASK_PNFS           = 0x00070000;

const EXCHGID4_FLAG_UPD_CONFIRMED_REC_A = 0x40000000;
const EXCHGID4_FLAG_CONFIRMED_R         = 0x80000000;

struct state_protect_ops4 {
        bitmap4 spo_must_enforce;
        bitmap4 spo_must_allow;
};

struct ssv_sp_parms4 {
        state_protect_ops4      ssp_ops;
        sec_oid4                ssp_hash_algs<>;
        sec_oid4                ssp_encr_algs<>;
        uint32_t                ssp_window;
        uint32_t                ssp_num_gss_handles;
};

enum state_protect_how4 {
        SP4_NONE = 0,
        SP4_MACH_CRED = 1,
        SP4_SSV = 2
};

union state_protect4_a switch(state_protect_how4 spa_how) {
case SP4_NONE:
        void;
case SP4_MACH_CRED:
        state_protect_ops4      spa_mach_ops;
case SP4_SSV:
        ssv_sp_parms4           spa_ssv_parms;
};

struct EXCHANGE_ID4args {
        client_owner4           eia_clientowner;
        uint32_t                eia_flags;
        state_protect4_a        eia_state_protect;
        nfs_impl_id4            eia_client_impl_id<1>;
};

struct ssv_prot_info4 {
        state_protect_ops4     spi_ops;
        uint32_t               spi_hash_alg;
        uint32_t               spi_encr_alg;
        uint32_t               spi_ssv_len;
        uint32_t               spi_window;
        gsshandle4_t           spi_handles<>;
};

union state_protect4_r switch(state_protect_how4 spr_how) {
case SP4_NONE:
        void;
case SP4_MACH_CRED:
        state_protect_ops4     spr_mach_ops;
case SP4_SSV:
        ssv_prot_info4         spr_ssv_info;
};

struct EXCHANGE_ID4resok {
        clientid4        eir_clientid;
        sequenceid4      eir_sequenceid;
        uint32_t         eir_flags;
        state_protect4_r eir_state_protect;
        server_owner4    eir_server_owner;
        opaque           eir_server_scope<NFS4_OPAQUE_LIMIT>;
        nfs_impl_id4     eir_server_impl_id<1>;
};

union EXCHANGE_ID4res switch (nfsstat4 eir_status) {
case NFS4_OK:
        EXCHANGE_ID4resok      eir_resok4;
default:
        void;
};

/*
 * CREATE_SESSION
 */
struct channel_attrs4 {
       count4                  ca_headerpadsize;
       count4                  ca_maxrequestsize;
       count4                  ca_maxresponsesize;
       count4                  ca_maxresponsesize_cached;
       count4                  ca_maxoperations;
       count4                  ca_maxrequests;
       uint32_t                ca_rdma_ird<1>;
};

const CREATE_SESSION4_FLAG_PERSIST              = 0x00000001;
const CREATE_SESSION4_FLAG_CONN_BACK_CHAN       = 0x00000002;
const CREATE_SESSION4_FLAG_CONN_RDMA            = 0x00000004;

struct CREATE_SESSION4args {
       clientid4               csa_clientid;
       sequenceid4             csa_sequence;
       uint32_t                csa_flags;
       channel_attrs4          csa_fore_chan_attrs;
       channel_attrs4          csa_back_chan_attrs;
       uint32_t                csa_cb_program;
       callback_sec_parms4     csa_sec_parms<>;
};

struct CREATE_SESSION4resok {
       sessionid4              csr_sessionid;
       sequenceid4             csr_sequence;
       uint32_t                csr_flags;
       channel_attrs4          csr_fore_chan_attrs;
       channel_attrs4          csr_back_chan_attrs;
};

union CREATE_SESSION4res switch (nfsstat4 csr_status) {
case NFS4_OK:
       CREATE_SESSION4resok    csr_resok4;
default:
       void;
};

/*
 * DESTROY_SESSION
 */
struct DESTROY_SESSION4args {
       sessionid4      dsa_sessionid;
};

struct DESTROY_SESSION4res {
       nfsstat4        dsr_status;
};

/*
 * FREE_STATEID
 */
struct FREE_STATEID4args {
       stateid4        fsa_stateid;
};

struct FREE_STATEID4res {
       nfsstat4        fsr_status;
};

/*
 * GET_DIR_DELEGATION
 */
typedef nfstime4 attr_notice4;

struct GET_DIR_DELEGATION4args {
       bool            gdda_signal_deleg_avail;
       bitmap4         gdda_notification_types;
       attr_notice4    gdda_child_attr_delay;
       attr_notice4    gdda_dir_attr_delay;
       bitmap4         gdda_child_attributes;
       bitmap4         gdda_dir_attributes;
};

struct GET_DIR_DELEGATION4resok {
       verifier4       gddr_cookieverf;
       stateid4        gddr_stateid;
       bitmap4         gddr_notification;
       bitmap4         gddr_child_attributes;
       bitmap4         gddr_dir_attributes;
};

enum gddrnf4_status {
       GDD4_OK         = 0,
       GDD4_UNAVAIL    = 1
};

union GET_DIR_DELEGATION4res_non_fatal switch (gddrnf4_status gddrnf_status) {
 case GDD4_OK:
     GET_DIR_DELEGATION4resok      gddrnf_resok4;
 case GDD4_UNAVAIL:
     bool                          gddrnf_will_signal_deleg_avail;
};

union GET_DIR_DELEGATION4res switch (nfsstat4 gddr_status) {
 case NFS4_OK:
     GET_DIR_DELEGATION4res_non_fatal      gddr_res_non_fatal4;
 default:
     void;
};

/*
 * GETDEVICEINFO
 */
struct GETDEVICEINFO4args {
       deviceid4       gdia_device_id;
       layouttype4     gdia_layout_type;
       count4          gdia_maxcount;
       bitmap4         gdia_notify_types;
};

struct GETDEVICEINFO4resok {
       device_addr4    gdir_device_addr;
       bitmap4         gdir_notification;
};

union GETDEVICEINFO4res switch (nfsstat4 gdir_status) {
case NFS4_OK:
       GETDEVICEINFO4resok     gdir_resok4;
case NFS4ERR_TOOSMALL:
       count4                  gdir_mincount;
default:
       void;
};

/*
 * GETDEVICELIST
 */
struct GETDEVICELIST4args {
        layouttype4     gdla_layout_type;
        count4          gdla_maxdevices;
        nfs_cookie4     gdla_cookie;
        verifier4       gdla_cookieverf;
};

struct GETDEVICELIST4resok {
       nfs_cookie4             gdlr_cookie;
       verifier4               gdlr_cookieverf;
       deviceid4               gdlr_deviceid_list<>;
       bool                    gdlr_eof;
};

union GETDEVICELIST4res switch (nfsstat4 gdlr_status) {
case NFS4_OK:
       GETDEVICELIST4resok     gdlr_resok4;
default:
       void;
};

/*
 * LAYOUTCOMMIT
 */
union newtime4 switch (bool nt_timechanged) {
case TRUE:
       nfstime4           nt_time;
case FALSE:
       void;
};

union newoffset4 switch (bool no_newoffset) {
case TRUE:
       offset4           no_offset;
case FALSE:
       void;
};

struct LAYOUTCOMMIT4args {
       offset4                 loca_offset;
       length4                 loca_length;
       bool                    loca_reclaim;
       stateid4                loca_stateid;
       newoffset4              loca_last_write_offset;
       newtime4                loca_time_modify;
       layoutupdate4           loca_layoutupdate;
};

union newsize4 switch (bool ns_sizechanged) {
case TRUE:
       length4         ns_size;
case FALSE:
       void;
};

struct LAYOUTCOMMIT4resok {
       newsize4                locr_newsize;
};

union LAYOUTCOMMIT4res switch (nfsstat4 locr_status) {
case NFS4_OK:
       LAYOUTCOMMIT4resok      locr_resok4;
default:
       void;
};

/*
 * LAYOUTGET
 */
struct LAYOUTGET4args {
       bool                    loga_signal_layout_avail;
       layouttype4             loga_layout_type;
       layoutiomode4           loga_iomode;
       offset4                 loga_offset;
       length4                 loga_length;
       length4                 loga_minlength;
       stateid4                loga_stateid;
       count4                  loga_maxcount;
};

struct LAYOUTGET4resok {
       bool               logr_return_on_close;
       stateid4           logr_stateid;
       layout4            logr_layout<>;
};

union LAYOUTGET4res switch (nfsstat4 logr_status) {
case NFS4_OK:
       LAYOUTGET4resok     logr_resok4;
case NFS4ERR_LAYOUTTRYLATER:
       bool                logr_will_signal_layout_avail;
default:
       void;
};

/*
 * LAYOUTRETURN
 */
const LAYOUT4_RET_REC_FILE      = 1;
const LAYOUT4_RET_REC_FSID      = 2;
const LAYOUT4_RET_REC_ALL       = 3;

enum layoutreturn_type4 {
       LAYOUTRETURN4_FILE = LAYOUT4_RET_REC_FILE,
       LAYOUTRETURN4_FSID = LAYOUT4_RET_REC_FSID,
       LAYOUTRETURN4_ALL  = LAYOUT4_RET_REC_ALL
};

struct layoutreturn_file4 {
       offset4         lrf_offset;
       length4         lrf_length;
       stateid4        lrf_stateid;
       opaque          lrf_body<>;
};

union layoutreturn4 switch(layoutreturn_type4 lr_returntype) {
       case LAYOUTRETURN4_FILE:
               layoutreturn_file4      lr_layout;
       default:
               void;
};

struct LAYOUTRETURN4args {
       bool                    lora_reclaim;
       layouttype4             lora_layout_type;
       layoutiomode4           lora_iomode;
       layoutreturn4           lora_layoutreturn;
};

union layoutreturn_stateid switch (bool lrs_present) {
case TRUE:
       stateid4                lrs_stateid;
case FALSE:
       void;
};

union LAYOUTRETURN4res switch (nfsstat4 lorr_status) {
case NFS4_OK:
       layoutreturn_stateid    lorr_stateid;
default:
       void;
};

/*
 * SECINFO_NO_NAME
 */
enum secinfo_style4 {
       SECINFO_STYLE4_CURRENT_FH       = 0,
       SECINFO_STYLE4_PARENT           = 1
};

typedef secinfo_style4 SECINFO_NO_NAME4args;

typedef SECINFO4res SECINFO_NO_NAME4res;

/*
 * SEQUENCE
 */
struct SEQUENCE4args {
       sessionid4     sa_sessionid;
       sequenceid4    sa_sequenceid;
       slotid4        sa_slotid;
       slotid4        sa_highest_slotid;
       bool           sa_cachethis;
};

const SEQ4_STATUS_CB_PATH_DOWN                  = 0x00000001;
const SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING      = 0x00000002;
const SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED       = 0x00000004;
const SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED     = 0x00000008;
const SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED    = 0x00000010;
const SEQ4_STATUS_ADMIN_STATE_REVOKED           = 0x00000020;
const SEQ4_STATUS_RECALLABLE_STATE_REVOKED      = 0x00000040;
const SEQ4_STATUS_LEASE_MOVED                   = 0x00000080;
const SEQ4_STATUS_RESTART_RECLAIM_NEEDED        = 0x00000100;
const SEQ4_STATUS_CB_PATH_DOWN_SESSION          = 0x00000200;
const SEQ4_STATUS_BACKCHANNEL_FAULT             = 0x00000400;
const SEQ4_STATUS_DEVID_CHANGED                 = 0x00000800;
const SEQ4_STATUS_DEVID_DELETED                 = 0x00001000;

struct SEQUENCE4resok {
       sessionid4      sr_sessionid;
       sequenceid4     sr_sequenceid;
       slotid4         sr_slotid;
       slotid4         sr_highest_slotid;
       slotid4         sr_target_highest_slotid;
       uint32_t        sr_status_flags;
};

union SEQUENCE4res switch (nfsstat4 sr_status) {
case NFS4_OK:
       SEQUENCE4resok  sr_resok4;
default:
       void;
};

/*
 * SET_SSV
 */
struct ssa_digest_input4 {
       SEQUENCE4args sdi_seqargs;
};

struct SET_SSV4args {
       opaque          ssa_ssv<>;
       opaque          ssa_digest<>;
};

struct ssr_digest_input4 {
       SEQUENCE4res sdi_seqres;
};

struct SET_SSV4resok {
       opaque          ssr_digest<>;
};

union SET_SSV4res switch (nfsstat4 ssr_status) {
case NFS4_OK:
       SET_SSV4resok   ssr_resok4;
default:
       void;
};

/*
 * TEST_STATEID
 */
struct TEST_STATEID4args {
       stateid4        ts_stateids<>;
};

struct TEST_STATEID4resok {
       nfsstat4        tsr_status_codes<>;
};

union TEST_STATEID4res switch (nfsstat4 tsr_status) {
   case NFS4_OK:
       TEST_STATEID4resok tsr_resok4;
   default:
       void;
};

/*
 * WANT_DELEGATION
 */
union deleg_claim4 switch (open_claim_type4 dc_claim) {
case CLAIM_FH:
       void;
case CLAIM_DELEG_PREV_FH:
       void;
case CLAIM_PREVIOUS:
       open_delegation_type4   dc_delegate_type;
};

struct WANT_DELEGATION4args {
       uint32_t        wda_want;
       deleg_claim4    wda_claim;
};

union WANT_DELEGATION4res switch (nfsstat4 wdr_status) {
case NFS4_OK:
       open_delegation4 wdr_resok4;
default:
       void;
};

/*
 * DESTROY_CLIENTID
 */
struct DESTROY_CLIENTID4args {
       clientid4       dca_clientid;
};

struct DESTROY_CLIENTID4res {
       nfsstat4        dcr_status;
};

/*
 * RECLAIM_COMPLETE
 */
struct RECLAIM_COMPLETE4args {
       bool            rca_one_fs;
};

struct RECLAIM_COMPLETE4res {
       nfsstat4        rcr_status;
};

/*
 * ILLEGAL: Response for illegal operation numbers
 */
struct ILLEGAL4res {
        nfsstat4        status;
};

/*
 * Operation arrays
 */

enum nfs_opnum4 {
        OP_ACCESS               = 3,
        OP_CLOSE                = 4,
        OP_COMMIT               = 5,
        OP_CREATE               = 6,
        OP_DELEGPURGE           = 7,
        OP_DELEGRETURN          = 8,
        OP_GETATTR              = 9,
        OP_GETFH                = 10,
        OP_LINK                 = 11,
        OP_LOCK                 = 12,
        OP_LOCKT                = 13,
        OP_LOCKU                = 14,
        OP_LOOKUP               = 15,
        OP_LOOKUPP              = 16,
        OP_NVERIFY              = 17,
        OP_OPEN                 = 18,
        OP_OPENATTR             = 19,
        OP_OPEN_CONFIRM         = 20,
        OP_OPEN_DOWNGRADE       = 21,
        OP_PUTFH                = 22,
        OP_PUTPUBFH             = 23,
        OP_PUTROOTFH            = 24,
        OP_READ                 = 25,
        OP_READDIR              = 26,
        OP_READLINK             = 27,
        OP_REMOVE               = 28,
        OP_RENAME               = 29,
        OP_RENEW                = 30,
        OP_RESTOREFH            = 31,
        OP_SAVEFH               = 32,
        OP_SECINFO              = 33,
        OP_SETATTR              = 34,
        OP_SETCLIENTID          = 35,
        OP_SETCLIENTID_CONFIRM  = 36,
        OP_VERIFY               = 37,
        OP_WRITE                = 38,
        OP_RELEASE_LOCKOWNER    = 39,
        OP_BIND_CONN_TO_SESSION = 41,
        OP_EXCHANGE_ID          = 42,
        OP_CREATE_SESSION       = 43,
        OP_DESTROY_SESSION      = 44,
        OP_FREE_STATEID         = 45,
        OP_GET_DIR_DELEGATION   = 46,
        OP_GETDEVICEINFO        = 47,
        OP_GETDEVICELIST        = 48,
        OP_LAYOUTCOMMIT         = 49,
        OP_LAYOUTGET            = 50,
        OP_LAYOUTRETURN         = 51,
        OP_SECINFO_NO_NAME      = 52,
        OP_SEQUENCE             = 53,
        OP_SET_SSV              = 54,
        OP_TEST_STATEID         = 55,
        OP_WANT_DELEGATION      = 56,
        OP_DESTROY_CLIENTID     = 57,
        OP_RECLAIM_COMPLETE     = 58,
        OP_ILLEGAL              = 10044
};

union nfs_argop4 switch (nfs_opnum4 argop) {
 case OP_ACCESS:        ACCESS4args opaccess;
 case OP_CLOSE:         CLOSE4args opclose;
 case OP_COMMIT:        COMMIT4args opcommit;
 case OP_CREATE:        CREATE4args opcreate;
 case OP_DELEGPURGE:    DELEGPURGE4args opdelegpurge;
 case OP_DELEGRETURN:   DELEGRETURN4args opdelegreturn;
 case OP_GETATTR:       GETATTR4args opgetattr;
 case OP_GETFH:         void;
 case OP_LINK:          LINK4args oplink;
 case OP_LOCK:          LOCK4args oplock;
 case OP_LOCKT:         LOCKT4args oplockt;
 case OP_LOCKU:         LOCKU4args oplocku;
 case OP_LOOKUP:        LOOKUP4args oplookup;
 case OP_LOOKUPP:       void;
 case OP_NVERIFY:       NVERIFY4args opnverify;
 case OP_OPEN:          OPEN4args opopen;
 case OP_OPENATTR:      OPENATTR4args opopenattr;
 case OP_OPEN_CONFIRM:  OPEN_CONFIRM4args opopen_confirm;
 case OP_OPEN_DOWNGRADE:        OPEN_DOWNGRADE4args opopen_downgrade;
 case OP_PUTFH:         PUTFH4args opputfh;
 case OP_PUTPUBFH:      void;
 case OP_PUTROOTFH:     void;
 case OP_READ:          READ4args opread;
 case OP_READDIR:       READDIR4args opreaddir;
 case OP_READLINK:      void;
 case OP_REMOVE:        REMOVE4args opremove;
 case OP_RENAME:        RENAME4args oprename;
 case OP_RENEW:         RENEW4args oprenew;
 case OP_RESTOREFH:     void;
 case OP_SAVEFH:        void;
 case OP_SECINFO:       SECINFO4args opsecinfo;
 case OP_SETATTR:       SETATTR4args opsetattr;
 case OP_SETCLIENTID:   SETCLIENTID4args opsetclientid;
 case OP_SETCLIENTID_CONFIRM:   SETCLIENTID_CONFIRM4args
                                        opsetclientid_confirm;
 case OP_VERIFY:        VERIFY4args opverify;
 case OP_WRITE:         WRITE4args opwrite;
 case OP_RELEASE_LOCKOWNER:     RELEASE_LOCKOWNER4args
                                    oprelease_lockowner;
 case OP_BIND_CONN_TO_SESSION:  BIND_CONN_TO_SESSION4args opbindconntosession;
 case OP_EXCHANGE_ID:           EXCHANGE_ID4args opexchangeid;
 case OP_CREATE_SESSION:        CREATE_SESSION4args opcreatesession;
 case OP_DESTROY_SESSION:       DESTROY_SESSION4args opdestroysession;
 case OP_FREE_STATEID:          FREE_STATEID4args opfreestateid;
 case OP_GET_DIR_DELEGATION:    GET_DIR_DELEGATION4args opgetdirdelegation;
 case OP_GETDEVICEINFO:         GETDEVICEINFO4args opgetdeviceinfo;
 case OP_GETDEVICELIST:         GETDEVICELIST4args opgetdevicelist;
 case OP_LAYOUTCOMMIT:          LAYOUTCOMMIT4args oplayoutcommit;
 case OP_LAYOUTGET:             LAYOUTGET4args oplayoutget;
 case OP_LAYOUTRETURN:          LAYOUTRETURN4args oplayoutreturn;
 case OP_SECINFO_NO_NAME:       SECINFO_NO_NAME4args opsecinfononame;
 case OP_SEQUENCE:              SEQUENCE4args opsequence;
 case OP_SET_SSV:               SET_SSV4args opsetssv;
 case OP_TEST_STATEID:          TEST_STATEID4args opteststateid;
 case OP_WANT_DELEGATION:       WANT_DELEGATION4args opwantdelegation;
 case OP_DESTROY_CLIENTID:      DESTROY_CLIENTID4args opdestroyclientid;
 case OP_RECLAIM_COMPLETE:      RECLAIM_COMPLETE4args opreclaimcomplete;
 case OP_ILLEGAL:       void;
};

union nfs_resop4 switch (nfs_opnum4 resop){
 case OP_ACCESS:        ACCESS4res opaccess;
 case OP_CLOSE:         CLOSE4res opclose;
 case OP_COMMIT:        COMMIT4res opcommit;
 case OP_CREATE:        CREATE4res opcreate;
 case OP_DELEGPURGE:    DELEGPURGE4res opdelegpurge;
 case OP_DELEGRETURN:   DELEGRETURN4res opdelegreturn;
 case OP_GETATTR:       GETATTR4res opgetattr;
 case OP_GETFH:         GETFH4res opgetfh;
 case OP_LINK:          LINK4res oplink;
 case OP_LOCK:          LOCK4res oplock;
 case OP_LOCKT:         LOCKT4res oplockt;
 case OP_LOCKU:         LOCKU4res oplocku;
 case OP_LOOKUP:        LOOKUP4res oplookup;
 case OP_LOOKUPP:       LOOKUPP4res oplookupp;
 case OP_NVERIFY:       NVERIFY4res opnverify;
 case OP_OPEN:          OPEN4res opopen;
 case OP_OPENATTR:      OPENATTR4res opopenattr;
 case OP_OPEN_CONFIRM:  OPEN_CONFIRM4res opopen_confirm;
 case OP_OPEN_DOWNGRADE:        OPEN_DOWNGRADE4res opopen_downgrade;
 case OP_PUTFH:         PUTFH4res opputfh;
 case OP_PUTPUBFH:      PUTPUBFH4res opputpubfh;
 case OP_PUTROOTFH:     PUTROOTFH4res opputrootfh;
 case OP_READ:          READ4res opread;
 case OP_READDIR:       READDIR4res opreaddir;
 case OP_READLINK:      READLINK4res opreadlink;
 case OP_REMOVE:        REMOVE4res opremove;
 case OP_RENAME:        RENAME4res oprename;
 case OP_RENEW:         RENEW4res oprenew;
 case OP_RESTOREFH:     RESTOREFH4res oprestorefh;
 case OP_SAVEFH:        SAVEFH4res opsavefh;
 case OP_SECINFO:       SECINFO4res opsecinfo;
 case OP_SETATTR:       SETATTR4res opsetattr;
 case OP_SETCLIENTID:   SETCLIENTID4res opsetclientid;
 case OP_SETCLIENTID_CONFIRM:   SETCLIENTID_CONFIRM4res
                                        opsetclientid_confirm;
 case OP_VERIFY:        VERIFY4res opverify;
 case OP_WRITE:         WRITE4res opwrite;
 case OP_RELEASE_LOCKOWNER:     RELEASE_LOCKOWNER4res
                                    oprelease_lockowner;
 case OP_BIND_CONN_TO_SESSION:  BIND_CONN_TO_SESSION4res opbindconntosession;
 case OP_EXCHANGE_ID:           EXCHANGE_ID4res opexchangeid;
 case OP_CREATE_SESSION:        CREATE_SESSION4res opcreatesession;
 case OP_DESTROY_SESSION:       DESTROY_SESSION4res opdestroysession;
 case OP_FREE_STATEID:          FREE_STATEID4res opfreestateid;
 case OP_GET_DIR_DELEGATION:    GET_DIR_DELEGATION4res opgetdirdelegation;
 case OP_GETDEVICEINFO:         GETDEVICEINFO4res opgetdeviceinfo;
 case OP_GETDEVICELIST:         GETDEVICELIST4res opgetdevicelist;
 case OP_LAYOUTCOMMIT:          LAYOUTCOMMIT4res oplayoutcommit;
 case OP_LAYOUTGET:             LAYOUTGET4res oplayoutget;
 case OP_LAYOUTRETURN:          LAYOUTRETURN4res oplayoutreturn;
 case OP_SECINFO_NO_NAME:       SECINFO_NO_NAME4res opsecinfononame;
 case OP_SEQUENCE:              SEQUENCE4res opsequence;
 case OP_SET_SSV:               SET_SSV4res opsetssv;
 case OP_TEST_STATEID:          TEST_STATEID4res opteststateid;
 case OP_WANT_DELEGATION:       WANT_DELEGATION4res opwantdelegation;
 case OP_DESTROY_CLIENTID:      DESTROY_CLIENTID4res opdestroyclientid;
 case OP_RECLAIM_COMPLETE:      RECLAIM_COMPLETE4res opreclaimcomplete;
 case OP_ILLEGAL:       ILLEGAL4res opillegal;
};

struct COMPOUND4args {
        utf8str_cs      tag;
        uint32_t        minorversion;
        nfs_argop4      argarray<>;
};

struct COMPOUND4res {
        nfsstat4 status;
        utf8str_cs      tag;
        nfs_resop4      resarray<>;
};

/*
 * Remote file service routines
 */
program NFS4_PROGRAM {
        version NFS_V4 {
                void
                        NFSPROC4_NULL(void) = 0;

                COMPOUND4res
                        NFSPROC4_COMPOUND(COMPOUND4args) = 1;

        } = 4;
} = 100003;


/*
 * NFS4 Callback Procedure Definitions and Program
 */

/*
 * CB_GETATTR: Get Current Attributes
 */
struct CB_GETATTR4args {
        nfs_fh4 fh;
        bitmap4 attr_request;
};

struct CB_GETATTR4resok {
        fattr4  obj_attributes;
};

union CB_GETATTR4res switch (nfsstat4 status) {
 case NFS4_OK:
         CB_GETATTR4resok       resok4;
 default:
         void;
};

/*
 * CB_RECALL: Recall an Open Delegation
 */
struct CB_RECALL4args {
        stateid4        stateid;
        bool            truncate;
        nfs_fh4         fh;
};

struct CB_RECALL4res {
        nfsstat4        status;
};

/*
 * CB_ILLEGAL: Response for illegal operation numbers
 */
struct CB_ILLEGAL4res {
        nfsstat4        status;
};

/*
 * Various definitions for CB_COMPOUND
 */
enum nfs_cb_opnum4 {
        OP_CB_GETATTR           = 3,
        OP_CB_RECALL            = 4,
        OP_CB_ILLEGAL           = 10044
};

union nfs_cb_argop4 switch (unsigned argop) {
 case OP_CB_GETATTR:    CB_GETATTR4args opcbgetattr;
 case OP_CB_RECALL:     CB_RECALL4args  opcbrecall;
 case OP_CB_ILLEGAL:    void;
};

union nfs_cb_resop4 switch (unsigned resop){
 case OP_CB_GETATTR:    CB_GETATTR4res  opcbgetattr;
 case OP_CB_RECALL:     CB_RECALL4res   opcbrecall;
 case OP_CB_ILLEGAL:    CB_ILLEGAL4res  opcbillegal;
};

struct CB_COMPOUND4args {
        utf8str_cs      tag;
        uint32_t        minorversion;
        uint32_t        callback_ident;
        nfs_cb_argop4   argarray<>;
};

struct CB_COMPOUND4res {
        nfsstat4 status;
        utf8str_cs      tag;
        nfs_cb_resop4   resarray<>;
};


/*
 * Program number is in the transient range since the client
 * will assign the exact transient program number and provide
 * that to the server via the SETCLIENTID operation.
 */
program NFS4_CALLBACK {
        version NFS_CB {
                void
                        CB_NULL(void) = 0;
                CB_COMPOUND4res
                        CB_COMPOUND(CB_COMPOUND4args) = 1;
        } = 1;
} = 0x40000000;

/*
 * GSS definitions
 */
/* RPCSEC_GSS control procedures */
enum rpc_gss_proc_t {
        RPCSEC_GSS_DATA = 0,
        RPCSEC_GSS_INIT = 1,
        RPCSEC_GSS_CONTINUE_INIT = 2,
        RPCSEC_GSS_DESTROY = 3
};

struct rpc_gss_cred_vers_1_t {
    rpc_gss_proc_t gss_proc;  /* control procedure */
    unsigned int seq_num;   /* sequence number */
    rpc_gss_svc_t service; /* service used */
    opaque handle<>;       /* context handle */
};

const RPCSEC_GSS_VERS_1 = 1;

union rpc_gss_cred_t switch (unsigned int vers) { /* version of RPCSEC_GSS */
    case RPCSEC_GSS_VERS_1:
        rpc_gss_cred_vers_1_t rpc_gss_cred_vers_1_t;
};

struct rpc_gss_init_arg {
    opaque gss_token<>;
};

struct rpc_gss_init_res {
        opaque handle<>;
        unsigned int gss_major;
        unsigned int gss_minor;
        unsigned int seq_window;
        opaque gss_token<>;
};

struct rpc_gss_integ_data {
    opaque databody_integ<>;
    opaque checksum<>;
};