doc: Add RFC documents

1 files changed, 2187 insertions, 0 deletions

diff --git a/doc/rfc/rfc7531.txt b/doc/rfc/rfc7531.txt
new file mode 100644
index 0000000..ec44669
--- /dev/null
+++ b/doc/rfc/rfc7531.txt
@@ -0,0 +1,2187 @@
+
+
+
+
+
+
+Internet Engineering Task Force (IETF)                    T. Haynes, Ed.
+Request for Comments: 7531                                  Primary Data
+Category: Standards Track                                 D. Noveck, Ed.
+ISSN: 2070-1721                                                     Dell
+                                                              March 2015
+
+
+                  Network File System (NFS) Version 4
+        External Data Representation Standard (XDR) Description
+
+Abstract
+
+   The Network File System (NFS) version 4 protocol is a distributed
+   file system protocol that owes its heritage to NFS protocol version 2
+   (RFC 1094) and version 3 (RFC 1813).  Unlike earlier versions, the
+   NFS version 4 protocol supports traditional file access while
+   integrating support for file locking and the MOUNT protocol.  In
+   addition, support for strong security (and its negotiation), COMPOUND
+   operations, client caching, and internationalization has been added.
+   Of course, attention has been applied to making NFS version 4 operate
+   well in an Internet environment.
+
+   RFC 7530 formally obsoletes RFC 3530.  This document, together with
+   RFC 7530, replaces RFC 3530 as the definition of the NFS version 4
+   protocol.
+
+Status of This Memo
+
+   This is an Internet Standards Track document.
+
+   This document is a product of the Internet Engineering Task Force
+   (IETF).  It represents the consensus of the IETF community.  It has
+   received public review and has been approved for publication by the
+   Internet Engineering Steering Group (IESG).  Further information on
+   Internet Standards is available in Section 2 of RFC 5741.
+
+   Information about the current status of this document, any errata,
+   and how to provide feedback on it may be obtained at
+   http://www.rfc-editor.org/info/rfc7531.
+
+
+
+
+
+
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                    [Page 1]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+Copyright Notice
+
+   Copyright (c) 2015 IETF Trust and the persons identified as the
+   document authors.  All rights reserved.
+
+   This document is subject to BCP 78 and the IETF Trust's Legal
+   Provisions Relating to IETF Documents
+   (http://trustee.ietf.org/license-info) in effect on the date of
+   publication of this document.  Please review these documents
+   carefully, as they describe your rights and restrictions with respect
+   to this document.  Code Components extracted from this document must
+   include Simplified BSD License text as described in Section 4.e of
+   the Trust Legal Provisions and are provided without warranty as
+   described in the Simplified BSD License.
+
+   This document may contain material from IETF Documents or IETF
+   Contributions published or made publicly available before November
+   10, 2008.  The person(s) controlling the copyright in some of this
+   material may not have granted the IETF Trust the right to allow
+   modifications of such material outside the IETF Standards Process.
+   Without obtaining an adequate license from the person(s) controlling
+   the copyright in such materials, this document may not be modified
+   outside the IETF Standards Process, and derivative works of it may
+   not be created outside the IETF Standards Process, except to format
+   it for publication as an RFC or to translate it into languages other
+   than English.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                    [Page 2]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+Table of Contents
+
+   1. Introduction ...................................................3
+   2. XDR Description of NFSv4.0 .....................................3
+   3. Security Considerations .......................................39
+   4. Normative References ..........................................39
+   Acknowledgments ..................................................39
+   Authors' Addresses ...............................................39
+
+1.  Introduction
+
+   This document contains the External Data Representation (XDR)
+   [RFC4506] description of the NFSv4.0 protocol [RFC7530].
+
+2.  XDR Description of NFSv4.0
+
+   The XDR description is provided in this document in a way that makes
+   it simple for the reader to extract it into a form that is ready to
+   compile.  The reader can feed this document in the following shell
+   script to produce the machine-readable XDR description of NFSv4.0:
+
+      #!/bin/sh
+      grep "^  *///" | sed 's?^  */// ??' | sed 's?^  *///$??'
+
+   That is, if the above script is stored in a file called "extract.sh",
+   and this document is in a file called "spec.txt", then the reader
+   can do:
+
+      sh extract.sh < spec.txt > nfs4_prot.x
+
+   The effect of the script is to remove leading white space from each
+   line, plus a sentinel sequence of "///".
+
+   The XDR description, with the sentinel sequence, follows:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                    [Page 3]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// /*
+    ///  * This file was machine generated for [RFC7530].
+    ///  *
+    ///  * Last updated Tue Mar 10 11:51:21 PDT 2015.
+    ///  */
+    ///
+    /// /*
+    ///  * Copyright (c) 2015 IETF Trust and the persons identified
+    ///  * as authors of the code.  All rights reserved.
+    ///  *
+    ///  * Redistribution and use in source and binary forms, with
+    ///  * or without modification, are permitted provided that the
+    ///  * following conditions are met:
+    ///  *
+    ///  * - Redistributions of source code must retain the above
+    ///  *   copyright notice, this list of conditions and the
+    ///  *   following disclaimer.
+    ///  *
+    ///  * - Redistributions in binary form must reproduce the above
+    ///  *   copyright notice, this list of conditions and the
+    ///  *   following disclaimer in the documentation and/or other
+    ///  *   materials provided with the distribution.
+    ///  *
+    ///  * - Neither the name of Internet Society, IETF or IETF
+    ///  *   Trust, nor the names of specific contributors, may be
+    ///  *   used to endorse or promote products derived from this
+    ///  *   software without specific prior written permission.
+    ///  *
+    ///  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
+    ///  *   AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+    ///  *   WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    ///  *   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    ///  *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
+    ///  *   EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+    ///  *   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+    ///  *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+    ///  *   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    ///  *   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+    ///  *   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+    ///  *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+    ///  *   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+    ///  *   IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+    ///  *   ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+    ///  */
+    ///
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                    [Page 4]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// /*
+    ///  * This code was derived from RFC 7531.
+    ///  */
+    ///
+    /// /*
+    ///  *      nfs4_prot.x
+    ///  *
+    ///  */
+    ///
+    /// /*
+    ///  * Basic typedefs for RFC 1832 data type definitions
+    ///  */
+    /// /*
+    ///  * typedef int          int32_t;
+    ///  * typedef unsigned int uint32_t;
+    ///  * typedef hyper                int64_t;
+    ///  * typedef unsigned hyper       uint64_t;
+    ///  */
+    ///
+    /// /*
+    ///  * Sizes
+    ///  */
+    /// const NFS4_FHSIZE               = 128;
+    /// const NFS4_VERIFIER_SIZE        = 8;
+    /// const NFS4_OTHER_SIZE           = 12;
+    /// const NFS4_OPAQUE_LIMIT         = 1024;
+    ///
+    /// const NFS4_INT64_MAX            = 0x7fffffffffffffff;
+    /// const NFS4_UINT64_MAX           = 0xffffffffffffffff;
+    /// const NFS4_INT32_MAX            = 0x7fffffff;
+    /// const NFS4_UINT32_MAX           = 0xffffffff;
+    ///
+    ///
+    /// /*
+    ///  * 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 */
+
+
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                    [Page 5]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    ///         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 file systems   */
+    ///  /* 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 file system  */
+    ///  NFS4ERR_ROFS           = 30,   /* read-only file system    */
+    ///  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      */
+
+
+
+Haynes & Noveck              Standards Track                    [Page 6]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    ///  NFS4ERR_MOVED          = 10019,/* file system 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 file system 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_BADXDR         = 10036,/* XDR 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,/* lock-owner state revoked */
+    ///  NFS4ERR_CB_PATH_DOWN   = 10048 /* callback path down       */
+    /// };
+    ///
+    /// /*
+    ///  * Basic data types
+    ///  */
+    /// typedef opaque  attrlist4<>;
+    /// typedef uint32_t        bitmap4<>;
+    /// typedef uint64_t        changeid4;
+    /// typedef uint64_t        clientid4;
+    /// typedef uint32_t        count4;
+    /// typedef uint64_t        length4;
+    /// typedef uint32_t        mode4;
+    /// typedef uint64_t        nfs_cookie4;
+    /// typedef opaque  nfs_fh4<NFS4_FHSIZE>;
+    /// typedef uint32_t        nfs_lease4;
+    /// typedef uint64_t        offset4;
+    /// typedef uint32_t        qop4;
+    /// typedef opaque  sec_oid4<>;
+
+
+
+Haynes & Noveck              Standards Track                    [Page 7]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// typedef uint32_t        seqid4;
+    /// typedef opaque  utf8string<>;
+    /// typedef utf8string      utf8str_cis;
+    /// typedef utf8string      utf8str_cs;
+    /// typedef utf8string      utf8str_mixed;
+    /// typedef utf8str_cs      component4;
+    /// typedef opaque  linktext4<>;
+    /// typedef utf8string      ascii_REQUIRED4;
+    /// typedef component4      pathname4<>;
+    /// typedef uint64_t        nfs_lockid4;
+    /// typedef opaque  verifier4[NFS4_VERIFIER_SIZE];
+    ///
+    ///
+    /// /*
+    ///  * Timeval
+    ///  */
+    /// struct nfstime4 {
+    ///         int64_t         seconds;
+    ///         uint32_t        nseconds;
+    /// };
+    ///
+    /// enum time_how4 {
+    ///         SET_TO_SERVER_TIME4 = 0,
+    ///         SET_TO_CLIENT_TIME4 = 1
+    /// };
+    ///
+    /// union settime4 switch (time_how4 set_it) {
+    ///  case SET_TO_CLIENT_TIME4:
+    ///          nfstime4       time;
+    ///  default:
+    ///          void;
+    /// };
+    ///
+    ///
+    /// /*
+    ///  * File attribute definitions
+    ///  */
+    ///
+    /// /*
+    ///  * FSID structure for major/minor
+    ///  */
+    /// struct fsid4 {
+    ///         uint64_t        major;
+    ///         uint64_t        minor;
+    /// };
+    ///
+    ///
+
+
+
+
+Haynes & Noveck              Standards Track                    [Page 8]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// /*
+    ///  * File system 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;
+    ///
+
+
+
+
+
+Haynes & Noveck              Standards Track                    [Page 9]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    ///
+    /// /*
+    ///  * 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;
+    ///
+    ///
+
+
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 10]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// /*
+    ///  * ACE4_GENERIC_READ - defined as a combination of
+    ///  *      ACE4_READ_ACL |
+    ///  *      ACE4_READ_DATA |
+    ///  *      ACE4_READ_ATTRIBUTES |
+    ///  *      ACE4_SYNCHRONIZE
+    ///  */
+    ///
+    /// const ACE4_GENERIC_READ = 0x00120081;
+    ///
+    /// /*
+    ///  * ACE4_GENERIC_WRITE - defined as a 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 a 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;
+    /// };
+    ///
+
+
+
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 11]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    ///
+    /// /*
+    ///  * 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;
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 12]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// typedef bool                    fattr4_unique_handles;
+    /// typedef nfs_lease4              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 ascii_REQUIRED4         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;
+
+
+
+Haynes & Noveck              Standards Track                   [Page 13]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    ///
+    ///
+    /// /*
+    ///  * 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;
+
+
+
+Haynes & Noveck              Standards Track                   [Page 14]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// 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;
+    ///
+    /// /*
+    ///  * 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 */
+    /// };
+    ///
+
+
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 15]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    ///
+    /// /*
+    ///  * Callback program info as provided by the client
+    ///  */
+    /// struct cb_client4 {
+    ///         unsigned int    cb_program;
+    ///         clientaddr4     cb_location;
+    /// };
+    ///
+    ///
+    /// /*
+    ///  * Stateid
+    ///  */
+    /// struct stateid4 {
+    ///         uint32_t        seqid;
+    ///         opaque          other[NFS4_OTHER_SIZE];
+    /// };
+    ///
+    /// /*
+    ///  * 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 */
+    /// };
+    ///
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 16]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    ///
+    /// 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;
+    /// };
+    ///
+    /// struct CLOSE4args {
+    ///         /* CURRENT_FH: object */
+    ///         seqid4          seqid;
+    ///         stateid4        open_stateid;
+    /// };
+    ///
+    /// union CLOSE4res switch (nfsstat4 status) {
+    ///  case NFS4_OK:
+    ///          stateid4       open_stateid;
+    ///  default:
+    ///          void;
+    /// };
+    ///
+    /// struct COMMIT4args {
+    ///         /* CURRENT_FH: file */
+    ///         offset4         offset;
+    ///         count4          count;
+    /// };
+    ///
+    /// struct COMMIT4resok {
+    ///         verifier4       writeverf;
+    /// };
+    ///
+
+
+
+Haynes & Noveck              Standards Track                   [Page 17]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// union COMMIT4res switch (nfsstat4 status) {
+    ///  case NFS4_OK:
+    ///          COMMIT4resok   resok4;
+    ///  default:
+    ///          void;
+    /// };
+    ///
+    /// 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;
+    /// };
+    ///
+    /// struct DELEGPURGE4args {
+    ///         clientid4       clientid;
+    /// };
+    ///
+    /// struct DELEGPURGE4res {
+    ///         nfsstat4        status;
+    /// };
+    ///
+
+
+
+Haynes & Noveck              Standards Track                   [Page 18]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// struct DELEGRETURN4args {
+    ///         /* CURRENT_FH: delegated file */
+    ///         stateid4        deleg_stateid;
+    /// };
+    ///
+    /// struct DELEGRETURN4res {
+    ///         nfsstat4        status;
+    /// };
+    ///
+    /// 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;
+    /// };
+    ///
+    /// struct GETFH4resok {
+    ///         nfs_fh4         object;
+    /// };
+    ///
+    /// union GETFH4res switch (nfsstat4 status) {
+    ///  case NFS4_OK:
+    ///          GETFH4resok     resok4;
+    ///  default:
+    ///          void;
+    /// };
+    ///
+    /// struct LINK4args {
+    ///         /* SAVED_FH: source object */
+    ///         /* CURRENT_FH: target directory */
+    ///         component4      newname;
+    /// };
+    ///
+    /// struct LINK4resok {
+    ///         change_info4    cinfo;
+    /// };
+    ///
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 19]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// 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;
+    /// };
+    ///
+
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 20]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// 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;
+    /// };
+    ///
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 21]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// union LOCKU4res switch (nfsstat4 status) {
+    ///  case NFS4_OK:
+    ///          stateid4       lock_stateid;
+    ///  default:
+    ///          void;
+    /// };
+    ///
+    /// struct LOOKUP4args {
+    ///         /* CURRENT_FH: directory */
+    ///         component4      objname;
+    /// };
+    ///
+    /// struct LOOKUP4res {
+    ///         /* CURRENT_FH: object */
+    ///         nfsstat4        status;
+    /// };
+    ///
+    /// struct LOOKUPP4res {
+    ///         /* CURRENT_FH: directory */
+    ///         nfsstat4        status;
+    /// };
+    ///
+    /// struct NVERIFY4args {
+    ///         /* CURRENT_FH: object */
+    ///         fattr4          obj_attributes;
+    /// };
+    ///
+    /// struct NVERIFY4res {
+    ///         nfsstat4        status;
+    /// };
+    ///
+    /// 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;
+    /// /*
+    ///  * Various definitions for OPEN
+    ///  */
+    /// enum createmode4 {
+    ///         UNCHECKED4      = 0,
+    ///         GUARDED4        = 1,
+    ///         EXCLUSIVE4      = 2
+    /// };
+    ///
+
+
+
+Haynes & Noveck              Standards Track                   [Page 22]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// 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;
+    /// } ;
+    ///
+    /// enum open_delegation_type4 {
+    ///         OPEN_DELEGATE_NONE      = 0,
+    ///         OPEN_DELEGATE_READ      = 1,
+    ///         OPEN_DELEGATE_WRITE     = 2
+    /// };
+    ///
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 23]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// enum open_claim_type4 {
+    ///         CLAIM_NULL              = 0,
+    ///         CLAIM_PREVIOUS          = 1,
+    ///         CLAIM_DELEGATE_CUR      = 2,
+    ///         CLAIM_DELEGATE_PREV     = 3
+    /// };
+    ///
+    /// 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;
+    /// };
+
+
+
+Haynes & Noveck              Standards Track                   [Page 24]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    ///
+    /// /*
+    ///  * 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. */
+    /// };
+    ///
+
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 25]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// 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;
+    /// };
+    ///
+    /// struct OPENATTR4args {
+    ///         /* CURRENT_FH: object */
+    ///         bool    createdir;
+    /// };
+    ///
+    /// struct OPENATTR4res {
+    ///         /* CURRENT_FH: named attr directory */
+    ///         nfsstat4        status;
+    /// };
+    ///
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 26]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// 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;
+    /// };
+    ///
+    /// 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;
+    /// };
+    ///
+    /// struct PUTFH4args {
+    ///         nfs_fh4         object;
+    /// };
+    ///
+    /// struct PUTFH4res {
+    ///         /* CURRENT_FH: */
+    ///         nfsstat4        status;
+    /// };
+    ///
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 27]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// struct PUTPUBFH4res {
+    ///         /* CURRENT_FH: public fh */
+    ///         nfsstat4        status;
+    /// };
+    ///
+    /// struct PUTROOTFH4res {
+    ///         /* CURRENT_FH: root fh */
+    ///         nfsstat4        status;
+    /// };
+    ///
+    /// 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;
+    /// };
+    ///
+    /// 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;
+    /// };
+    ///
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 28]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// struct dirlist4 {
+    ///         entry4          *entries;
+    ///         bool            eof;
+    /// };
+    ///
+    /// struct READDIR4resok {
+    ///         verifier4       cookieverf;
+    ///         dirlist4        reply;
+    /// };
+    ///
+    ///
+    /// union READDIR4res switch (nfsstat4 status) {
+    ///  case NFS4_OK:
+    ///          READDIR4resok  resok4;
+    ///  default:
+    ///          void;
+    /// };
+    ///
+    ///
+    /// struct READLINK4resok {
+    ///         linktext4       link;
+    /// };
+    ///
+    /// union READLINK4res switch (nfsstat4 status) {
+    ///  case NFS4_OK:
+    ///          READLINK4resok resok4;
+    ///  default:
+    ///          void;
+    /// };
+    ///
+    /// struct REMOVE4args {
+    ///         /* CURRENT_FH: directory */
+    ///         component4      target;
+    /// };
+    ///
+    /// struct REMOVE4resok {
+    ///         change_info4    cinfo;
+    /// };
+    ///
+    /// union REMOVE4res switch (nfsstat4 status) {
+    ///  case NFS4_OK:
+    ///          REMOVE4resok   resok4;
+    ///  default:
+    ///          void;
+    /// };
+    ///
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 29]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// 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;
+    /// };
+    ///
+    /// struct RENEW4args {
+    ///         clientid4       clientid;
+    /// };
+    ///
+    /// struct RENEW4res {
+    ///         nfsstat4        status;
+    /// };
+    ///
+    /// struct RESTOREFH4res {
+    ///         /* CURRENT_FH: value of saved fh */
+    ///         nfsstat4        status;
+    /// };
+    ///
+    /// struct SAVEFH4res {
+    ///         /* SAVED_FH: value of current fh */
+    ///         nfsstat4        status;
+    /// };
+    ///
+    /// struct SECINFO4args {
+    ///         /* CURRENT_FH: directory */
+    ///         component4      name;
+    /// };
+    ///
+
+
+
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 30]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// /*
+    ///  * From RFC 2203
+    ///  */
+    /// 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;
+    /// };
+    ///
+    /// /* RPCSEC_GSS has a value of '6'.  See RFC 2203 */
+    /// 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;
+    /// };
+    ///
+    /// struct SETATTR4args {
+    ///         /* CURRENT_FH: target object */
+    ///         stateid4        stateid;
+    ///         fattr4          obj_attributes;
+    /// };
+    ///
+    /// struct SETATTR4res {
+    ///         nfsstat4        status;
+    ///         bitmap4         attrsset;
+    /// };
+    ///
+    /// struct SETCLIENTID4args {
+    ///         nfs_client_id4  client;
+    ///         cb_client4      callback;
+    ///         uint32_t        callback_ident;
+    /// };
+
+
+
+Haynes & Noveck              Standards Track                   [Page 31]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    ///
+    /// 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;
+    /// };
+    ///
+    /// struct VERIFY4args {
+    ///         /* CURRENT_FH: object */
+    ///         fattr4          obj_attributes;
+    /// };
+    ///
+    /// struct VERIFY4res {
+    ///         nfsstat4        status;
+    /// };
+    ///
+    /// 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<>;
+    /// };
+    ///
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 32]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// struct WRITE4resok {
+    ///         count4          count;
+    ///         stable_how4     committed;
+    ///         verifier4       writeverf;
+    /// };
+    ///
+    /// union WRITE4res switch (nfsstat4 status) {
+    ///  case NFS4_OK:
+    ///          WRITE4resok    resok4;
+    ///  default:
+    ///          void;
+    /// };
+    ///
+    /// struct RELEASE_LOCKOWNER4args {
+    ///         lock_owner4     lock_owner;
+    /// };
+    ///
+    /// struct RELEASE_LOCKOWNER4res {
+    ///         nfsstat4        status;
+    /// };
+    ///
+    /// 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,
+
+
+
+Haynes & Noveck              Standards Track                   [Page 33]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    ///  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_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;
+
+
+
+Haynes & Noveck              Standards Track                   [Page 34]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    ///  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_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;
+
+
+
+Haynes & Noveck              Standards Track                   [Page 35]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    ///  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_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;
+    ///
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 36]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// /*
+    ///  * NFS4 callback procedure definitions and program
+    ///  */
+    /// 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;
+    /// };
+    ///
+    /// 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
+    /// };
+    ///
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 37]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+    /// 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;
+
+
+
+
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 38]
+
+RFC 7531                        NFSv4 XDR                     March 2015
+
+
+3.  Security Considerations
+
+   See the Security Considerations section of [RFC7530].
+
+4.  Normative References
+
+   [RFC4506]  Eisler, M., Ed., "XDR: External Data Representation
+              Standard", STD 67, RFC 4506, May 2006,
+              <http://www.rfc-editor.org/info/rfc4506>.
+
+   [RFC7530]  Haynes, T., Ed., and D. Noveck, Ed., "Network File System
+              (NFS) Version 4 Protocol", RFC 7530, March 2015,
+              <http://www.rfc-editor.org/info/rfc7530>.
+
+Acknowledgments
+
+   Tom Haynes would like to thank NetApp, Inc. for its funding of his
+   time on this project.
+
+   David Quigley tested the extraction of the .x file from this document
+   and corrected the two resulting errors.
+
+Authors' Addresses
+
+   Thomas Haynes (editor)
+   Primary Data, Inc.
+   4300 El Camino Real Ste 100
+   Los Altos, CA  94022
+   United States
+
+   Phone: +1 408 215 1519
+   EMail: thomas.haynes@primarydata.com
+
+
+   David Noveck (editor)
+   Dell
+   300 Innovative Way
+   Nashua, NH  03062
+   United States
+
+   Phone: +1 781 572 8038
+   EMail: dave_noveck@dell.com
+
+
+
+
+
+
+
+
+
+Haynes & Noveck              Standards Track                   [Page 39]
+