From 853474d387690b04b8f74cba92d74d41edbdd9a1 Mon Sep 17 00:00:00 2001 From: Ronnie Sahlberg Date: Tue, 29 Nov 2016 05:35:58 -0800 Subject: [PATCH] Add NFSv4 protocol definitions Signed-off-by: Ronnie Sahlberg --- Makefile.am | 2 +- configure.ac | 1 + include/Makefile.am | 1 + include/nfsc/libnfs-raw.h | 34 + include/nfsc/libnfs-zdr.h | 2 + lib/Makefile.am | 2 + lib/libnfs-win32.def | 2 + nfs4/Makefile.am | 25 + nfs4/libnfs-raw-nfs4.c | 3273 +++++++++++++++++++++++++++++++++++++ nfs4/libnfs-raw-nfs4.h | 1987 ++++++++++++++++++++++ nfs4/nfs4.c | 221 +++ nfs4/nfs4.x | 1668 +++++++++++++++++++ 12 files changed, 7217 insertions(+), 1 deletion(-) create mode 100644 nfs4/Makefile.am create mode 100644 nfs4/libnfs-raw-nfs4.c create mode 100644 nfs4/libnfs-raw-nfs4.h create mode 100644 nfs4/nfs4.c create mode 100644 nfs4/nfs4.x diff --git a/Makefile.am b/Makefile.am index 7ef41fc..753cfe7 100644 --- a/Makefile.am +++ b/Makefile.am @@ -1,4 +1,4 @@ -SUBDIRS = doc mount nfs nlm nsm portmap rquota lib include $(MAYBE_UTILS) . $(MAYBE_EXAMPLES) +SUBDIRS = doc mount nfs nfs4 nlm nsm portmap rquota lib include $(MAYBE_UTILS) . $(MAYBE_EXAMPLES) ACLOCAL_AMFLAGS = -I m4 pkgconfigdir = $(libdir)/pkgconfig diff --git a/configure.ac b/configure.ac index 490435d..46fe09c 100644 --- a/configure.ac +++ b/configure.ac @@ -217,6 +217,7 @@ AC_CONFIG_FILES([Makefile] [lib/Makefile] [mount/Makefile] [nfs/Makefile] + [nfs4/Makefile] [nlm/Makefile] [nsm/Makefile] [portmap/Makefile] diff --git a/include/Makefile.am b/include/Makefile.am index b5d43c2..b411e4c 100644 --- a/include/Makefile.am +++ b/include/Makefile.am @@ -6,6 +6,7 @@ dist_nfsc_HEADERS = \ ../mount/libnfs-raw-mount.h \ ../portmap/libnfs-raw-portmap.h \ ../nfs/libnfs-raw-nfs.h \ + ../nfs4/libnfs-raw-nfs4.h \ ../nlm/libnfs-raw-nlm.h \ ../nsm/libnfs-raw-nsm.h \ ../rquota/libnfs-raw-rquota.h diff --git a/include/nfsc/libnfs-raw.h b/include/nfsc/libnfs-raw.h index 3b38df4..9aa639f 100644 --- a/include/nfsc/libnfs-raw.h +++ b/include/nfsc/libnfs-raw.h @@ -1,3 +1,4 @@ +/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ /* Copyright (C) 2010 by Ronnie Sahlberg @@ -1699,6 +1700,39 @@ EXTERN int rpc_nsm1_simucrash_async(struct rpc_context *rpc, rpc_cb cb, void *pr struct NSM1_NOTIFYargs; EXTERN int rpc_nsm1_notify_async(struct rpc_context *rpc, rpc_cb cb, struct NSM1_NOTIFYargs *args, void *private_data); +/* + * Call NFS4/NULL + * Function returns + * 0 : The call was initiated. The callback will be invoked when the call completes. + * <0 : An error occured when trying to set up the call. The callback will not be invoked. + * + * When the callback is invoked, status indicates the result: + * RPC_STATUS_SUCCESS : We got a successful response from the nfs daemon. + * data is NULL. + * RPC_STATUS_ERROR : An error occured when trying to contact the nfs daemon. + * data is the error string. + * RPC_STATUS_CANCEL : The connection attempt was aborted before it could complete. + * data is NULL. + */ +EXTERN int rpc_nfs4_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data); + +/* + * Call NFS4/COMPOUND + * Function returns + * 0 : The call was initiated. The callback will be invoked when the call completes. + * <0 : An error occured when trying to set up the call. The callback will not be invoked. + * + * When the callback is invoked, status indicates the result: + * RPC_STATUS_SUCCESS : We got a successful response from the nfs daemon. + * data is COMPOUND4res + * RPC_STATUS_ERROR : An error occured when trying to contact the nfs daemon. + * data is the error string. + * RPC_STATUS_CANCEL : The connection attempt was aborted before it could complete. + * data is NULL. + */ +struct COMPOUND4args; +EXTERN int rpc_nfs4_compound_async(struct rpc_context *rpc, rpc_cb cb, struct COMPOUND4args *args, void *private_data); + /* * Call /NULL * Function returns diff --git a/include/nfsc/libnfs-zdr.h b/include/nfsc/libnfs-zdr.h index 53fb5a6..a2b372b 100644 --- a/include/nfsc/libnfs-zdr.h +++ b/include/nfsc/libnfs-zdr.h @@ -221,9 +221,11 @@ void libnfs_zdr_destroy(ZDR *zdrs); bool_t libnfs_zdr_bytes(ZDR *zdrs, char **bufp, uint32_t *size, uint32_t maxsize); #define zdr_u_int libnfs_zdr_u_int +#define zdr_uint32_t libnfs_zdr_u_int bool_t libnfs_zdr_u_int(ZDR *zdrs, uint32_t *u); #define zdr_int libnfs_zdr_int +#define zdr_int32_t libnfs_zdr_int bool_t libnfs_zdr_int(ZDR *zdrs, int32_t *i); #define zdr_uint64_t libnfs_zdr_uint64_t diff --git a/lib/Makefile.am b/lib/Makefile.am index 67f6dbf..21b96bc 100644 --- a/lib/Makefile.am +++ b/lib/Makefile.am @@ -6,6 +6,7 @@ libnfs_la_CPPFLAGS = -I$(abs_top_srcdir)/include \ -I$(abs_top_srcdir)/include/nfsc \ -I$(abs_top_srcdir)/mount \ -I$(abs_top_srcdir)/nfs \ + -I$(abs_top_srcdir)/nfs4 \ -I$(abs_top_srcdir)/nlm \ -I$(abs_top_srcdir)/nsm \ -I$(abs_top_srcdir)/portmap \ @@ -29,6 +30,7 @@ libnfs_la_LDFLAGS = -version-info $(SOCURRENT):$(SOREVISION):$(SOAGE) libnfs_la_LIBADD = \ ../mount/libmount.la \ ../nfs/libnfs.la \ + ../nfs4/libnfs4.la \ ../nlm/libnlm.la \ ../nsm/libnsm.la \ ../portmap/libportmap.la \ diff --git a/lib/libnfs-win32.def b/lib/libnfs-win32.def index a0f2f66..1ba7161 100644 --- a/lib/libnfs-win32.def +++ b/lib/libnfs-win32.def @@ -200,6 +200,8 @@ rpc_nfs3_readlink_async rpc_nfs3_symlink_async rpc_nfs3_rename_async rpc_nfs3_link_async +rpc_nfs4_compound_async +rpc_nfs4_null_async rpc_nlm4_null_async rpc_nlm4_test_async rpc_nlm4_lock_async diff --git a/nfs4/Makefile.am b/nfs4/Makefile.am new file mode 100644 index 0000000..c1ec6d0 --- /dev/null +++ b/nfs4/Makefile.am @@ -0,0 +1,25 @@ +noinst_LTLIBRARIES = libnfs4.la + +nfs4_SOURCES_GENERATED = +nfs4_HEADERS_GENERATED = +nfs4_GENERATED = $(nfs4_SOURCES_GENERATED) $(nfs4_HEADERS_GENERATED) + +CLEANFILES = $(nfs_GENERATED) nfs4-stamp + +libnfs4_la_CPPFLAGS = -I$(abs_top_srcdir)/include \ + -I$(abs_top_srcdir)/include/nfsc \ + -I$(abs_top_srcdir)/win32 +libnfs4_la_SOURCES = \ + $(nfs4_SOURCES_GENERATED) \ + nfs4.c libnfs-raw-nfs4.c libnfs-raw-nfs4.h + +$(nfs4_GENERATED) : nfs4-stamp +nfs4-stamp : nfs4.x + rm -f $(nfs_GENERATED) + touch nfs4-stamp + +compile_rpc: + cat nfs4.x | head -29 >libnfs-raw-nfs4.h + rpcgen -h nfs4.x | sed -e "s/#include /#include /" -e "s/xdr/zdr/g" -e "s/XDR/ZDR/g" -e "s/#define _NFS_H_RPCGEN/#define _NFS_H_RPCGEN\n#include /g" -e "s/#define NFS3_COOKIEVERFSIZE 8/#define NFS3_COOKIEVERFSIZE 8\n\n/g" -e "s/ CLIENT / void /g" -e "s/SVCXPRT /void /g" -e "s/bool_t/uint32_t/g" >> libnfs-raw-nfs4.h + cat nfs4.x | head -29 >libnfs-raw-nfs4.c + rpcgen -c nfs4.x | sed -e "s/#include \".*nfs4.h\"/#include \"libnfs-xdr.h\"\n#include \"libnfs-raw-nfs4.h\"/" -e "s/xdr/zdr/g" -e "s/XDR/ZDR/g" -e "s/register int32_t \*buf;/register int32_t *buf;\n buf = NULL;/" -e "s/bool_t/uint32_t/g" >> libnfs-raw-nfs4.c diff --git a/nfs4/libnfs-raw-nfs4.c b/nfs4/libnfs-raw-nfs4.c new file mode 100644 index 0000000..42b027b --- /dev/null +++ b/nfs4/libnfs-raw-nfs4.c @@ -0,0 +1,3273 @@ +/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ +/* + * The definitions in this file are based on RFC3530. + */ + +/* RFC3530 contains the following copyright statement: + + + Copyright (C) The Internet Society (2003). All Rights Reserved. + + This document and translations of it may be copied and furnished to + others, and derivative works that comment on or otherwise explain it + or assist in its implementation may be prepared, copied, published + and distributed, in whole or in part, without restriction of any + kind, provided that the above copyright notice and this paragraph are + included on all such copies and derivative works. However, this + document itself may not be modified in any way, such as by removing + the copyright notice or references to the Internet Society or other + Internet organizations, except as needed for the purpose of + developing Internet standards in which case the procedures for + copyrights defined in the Internet Standards process must be + followed, or as required to translate it into languages other than + English. + + The limited permissions granted above are perpetual and will not be + revoked by the Internet Society or its successors or assigns. + + This document and the information contained herein is provided on an + "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING +/* + * Please do not edit this file. + * It was generated using rpcgen. + */ + +#include "libnfs-zdr.h" +#include "libnfs-raw-nfs4.h" + +uint32_t +zdr_nfs_ftype4 (ZDR *zdrs, nfs_ftype4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_enum (zdrs, (enum_t *) objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_nfsstat4 (ZDR *zdrs, nfsstat4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_enum (zdrs, (enum_t *) objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_bitmap4 (ZDR *zdrs, bitmap4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_array (zdrs, (char **)&objp->bitmap4_val, (u_int *) &objp->bitmap4_len, ~0, + sizeof (uint32_t), (zdrproc_t) zdr_uint32_t)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_offset4 (ZDR *zdrs, offset4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_count4 (ZDR *zdrs, count4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_length4 (ZDR *zdrs, length4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_clientid4 (ZDR *zdrs, clientid4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_seqid4 (ZDR *zdrs, seqid4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_utf8string (ZDR *zdrs, utf8string *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bytes (zdrs, (char **)&objp->utf8string_val, (u_int *) &objp->utf8string_len, ~0)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_utf8str_cis (ZDR *zdrs, utf8str_cis *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_utf8string (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_utf8str_cs (ZDR *zdrs, utf8str_cs *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_utf8string (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_utf8str_mixed (ZDR *zdrs, utf8str_mixed *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_utf8string (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_component4 (ZDR *zdrs, component4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_utf8str_cs (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_pathname4 (ZDR *zdrs, pathname4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_array (zdrs, (char **)&objp->pathname4_val, (u_int *) &objp->pathname4_len, ~0, + sizeof (component4), (zdrproc_t) zdr_component4)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_nfs_lockid4 (ZDR *zdrs, nfs_lockid4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_nfs_cookie4 (ZDR *zdrs, nfs_cookie4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_linktext4 (ZDR *zdrs, linktext4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_utf8str_cs (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_sec_oid4 (ZDR *zdrs, sec_oid4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bytes (zdrs, (char **)&objp->sec_oid4_val, (u_int *) &objp->sec_oid4_len, ~0)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_qop4 (ZDR *zdrs, qop4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_mode4 (ZDR *zdrs, mode4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_changeid4 (ZDR *zdrs, changeid4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_verifier4 (ZDR *zdrs, verifier4 objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_opaque (zdrs, objp, NFS4_VERIFIER_SIZE)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_nfstime4 (ZDR *zdrs, nfstime4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_int64_t (zdrs, &objp->seconds)) + return FALSE; + if (!zdr_uint32_t (zdrs, &objp->nseconds)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_time_how4 (ZDR *zdrs, time_how4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_enum (zdrs, (enum_t *) objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_settime4 (ZDR *zdrs, settime4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_time_how4 (zdrs, &objp->set_it)) + return FALSE; + switch (objp->set_it) { + case SET_TO_CLIENT_TIME4: + if (!zdr_nfstime4 (zdrs, &objp->settime4_u.time)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_nfs_fh4 (ZDR *zdrs, nfs_fh4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bytes (zdrs, (char **)&objp->nfs_fh4_val, (u_int *) &objp->nfs_fh4_len, NFS4_FHSIZE)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fsid4 (ZDR *zdrs, fsid4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, &objp->major)) + return FALSE; + if (!zdr_uint64_t (zdrs, &objp->minor)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fs_location4 (ZDR *zdrs, fs_location4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_array (zdrs, (char **)&objp->server.server_val, (u_int *) &objp->server.server_len, ~0, + sizeof (utf8str_cis), (zdrproc_t) zdr_utf8str_cis)) + return FALSE; + if (!zdr_pathname4 (zdrs, &objp->rootpath)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fs_locations4 (ZDR *zdrs, fs_locations4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_pathname4 (zdrs, &objp->fs_root)) + return FALSE; + if (!zdr_array (zdrs, (char **)&objp->locations.locations_val, (u_int *) &objp->locations.locations_len, ~0, + sizeof (fs_location4), (zdrproc_t) zdr_fs_location4)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_acetype4 (ZDR *zdrs, acetype4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_aceflag4 (ZDR *zdrs, aceflag4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_acemask4 (ZDR *zdrs, acemask4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_nfsace4 (ZDR *zdrs, nfsace4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_acetype4 (zdrs, &objp->type)) + return FALSE; + if (!zdr_aceflag4 (zdrs, &objp->flag)) + return FALSE; + if (!zdr_acemask4 (zdrs, &objp->access_mask)) + return FALSE; + if (!zdr_utf8str_mixed (zdrs, &objp->who)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_specdata4 (ZDR *zdrs, specdata4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, &objp->specdata1)) + return FALSE; + if (!zdr_uint32_t (zdrs, &objp->specdata2)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_supported_attrs (ZDR *zdrs, fattr4_supported_attrs *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bitmap4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_type (ZDR *zdrs, fattr4_type *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfs_ftype4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_fh_expire_type (ZDR *zdrs, fattr4_fh_expire_type *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_change (ZDR *zdrs, fattr4_change *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_changeid4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_size (ZDR *zdrs, fattr4_size *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_link_support (ZDR *zdrs, fattr4_link_support *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_symlink_support (ZDR *zdrs, fattr4_symlink_support *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_named_attr (ZDR *zdrs, fattr4_named_attr *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_fsid (ZDR *zdrs, fattr4_fsid *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_fsid4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_unique_handles (ZDR *zdrs, fattr4_unique_handles *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_lease_time (ZDR *zdrs, fattr4_lease_time *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_rdattr_error (ZDR *zdrs, fattr4_rdattr_error *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_acl (ZDR *zdrs, fattr4_acl *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_array (zdrs, (char **)&objp->fattr4_acl_val, (u_int *) &objp->fattr4_acl_len, ~0, + sizeof (nfsace4), (zdrproc_t) zdr_nfsace4)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_aclsupport (ZDR *zdrs, fattr4_aclsupport *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_archive (ZDR *zdrs, fattr4_archive *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_cansettime (ZDR *zdrs, fattr4_cansettime *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_case_insensitive (ZDR *zdrs, fattr4_case_insensitive *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_case_preserving (ZDR *zdrs, fattr4_case_preserving *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_chown_restricted (ZDR *zdrs, fattr4_chown_restricted *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_fileid (ZDR *zdrs, fattr4_fileid *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_files_avail (ZDR *zdrs, fattr4_files_avail *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_filehandle (ZDR *zdrs, fattr4_filehandle *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfs_fh4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_files_free (ZDR *zdrs, fattr4_files_free *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_files_total (ZDR *zdrs, fattr4_files_total *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_fs_locations (ZDR *zdrs, fattr4_fs_locations *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_fs_locations4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_hidden (ZDR *zdrs, fattr4_hidden *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_homogeneous (ZDR *zdrs, fattr4_homogeneous *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_maxfilesize (ZDR *zdrs, fattr4_maxfilesize *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_maxlink (ZDR *zdrs, fattr4_maxlink *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_maxname (ZDR *zdrs, fattr4_maxname *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_maxread (ZDR *zdrs, fattr4_maxread *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_maxwrite (ZDR *zdrs, fattr4_maxwrite *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_mimetype (ZDR *zdrs, fattr4_mimetype *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_utf8str_cs (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_mode (ZDR *zdrs, fattr4_mode *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_mode4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_mounted_on_fileid (ZDR *zdrs, fattr4_mounted_on_fileid *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_no_trunc (ZDR *zdrs, fattr4_no_trunc *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_numlinks (ZDR *zdrs, fattr4_numlinks *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_owner (ZDR *zdrs, fattr4_owner *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_utf8str_mixed (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_owner_group (ZDR *zdrs, fattr4_owner_group *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_utf8str_mixed (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_quota_avail_hard (ZDR *zdrs, fattr4_quota_avail_hard *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_quota_avail_soft (ZDR *zdrs, fattr4_quota_avail_soft *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_quota_used (ZDR *zdrs, fattr4_quota_used *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_rawdev (ZDR *zdrs, fattr4_rawdev *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_specdata4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_space_avail (ZDR *zdrs, fattr4_space_avail *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_space_free (ZDR *zdrs, fattr4_space_free *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_space_total (ZDR *zdrs, fattr4_space_total *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_space_used (ZDR *zdrs, fattr4_space_used *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint64_t (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_system (ZDR *zdrs, fattr4_system *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_time_access (ZDR *zdrs, fattr4_time_access *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfstime4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_time_access_set (ZDR *zdrs, fattr4_time_access_set *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_settime4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_time_backup (ZDR *zdrs, fattr4_time_backup *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfstime4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_time_create (ZDR *zdrs, fattr4_time_create *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfstime4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_time_delta (ZDR *zdrs, fattr4_time_delta *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfstime4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_time_metadata (ZDR *zdrs, fattr4_time_metadata *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfstime4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_time_modify (ZDR *zdrs, fattr4_time_modify *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfstime4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4_time_modify_set (ZDR *zdrs, fattr4_time_modify_set *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_settime4 (zdrs, objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_attrlist4 (ZDR *zdrs, attrlist4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bytes (zdrs, (char **)&objp->attrlist4_val, (u_int *) &objp->attrlist4_len, ~0)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_fattr4 (ZDR *zdrs, fattr4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bitmap4 (zdrs, &objp->attrmask)) + return FALSE; + if (!zdr_attrlist4 (zdrs, &objp->attr_vals)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_change_info4 (ZDR *zdrs, change_info4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, &objp->atomic)) + return FALSE; + if (!zdr_changeid4 (zdrs, &objp->before)) + return FALSE; + if (!zdr_changeid4 (zdrs, &objp->after)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_clientaddr4 (ZDR *zdrs, clientaddr4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_string (zdrs, &objp->r_netid, ~0)) + return FALSE; + if (!zdr_string (zdrs, &objp->r_addr, ~0)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_cb_client4 (ZDR *zdrs, cb_client4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, &objp->cb_program)) + return FALSE; + if (!zdr_clientaddr4 (zdrs, &objp->cb_location)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_stateid4 (ZDR *zdrs, stateid4 *objp) +{ + register int32_t *buf; + buf = NULL; + + int i; + if (!zdr_uint32_t (zdrs, &objp->seqid)) + return FALSE; + if (!zdr_opaque (zdrs, objp->other, 12)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_nfs_client_id4 (ZDR *zdrs, nfs_client_id4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_verifier4 (zdrs, objp->verifier)) + return FALSE; + if (!zdr_bytes (zdrs, (char **)&objp->id.id_val, (u_int *) &objp->id.id_len, NFS4_OPAQUE_LIMIT)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_open_owner4 (ZDR *zdrs, open_owner4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_clientid4 (zdrs, &objp->clientid)) + return FALSE; + if (!zdr_bytes (zdrs, (char **)&objp->owner.owner_val, (u_int *) &objp->owner.owner_len, NFS4_OPAQUE_LIMIT)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_lock_owner4 (ZDR *zdrs, lock_owner4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_clientid4 (zdrs, &objp->clientid)) + return FALSE; + if (!zdr_bytes (zdrs, (char **)&objp->owner.owner_val, (u_int *) &objp->owner.owner_len, NFS4_OPAQUE_LIMIT)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_nfs_lock_type4 (ZDR *zdrs, nfs_lock_type4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_enum (zdrs, (enum_t *) objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_ACCESS4args (ZDR *zdrs, ACCESS4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, &objp->access)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_ACCESS4resok (ZDR *zdrs, ACCESS4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, &objp->supported)) + return FALSE; + if (!zdr_uint32_t (zdrs, &objp->access)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_ACCESS4res (ZDR *zdrs, ACCESS4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_ACCESS4resok (zdrs, &objp->ACCESS4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_CLOSE4args (ZDR *zdrs, CLOSE4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_seqid4 (zdrs, &objp->seqid)) + return FALSE; + if (!zdr_stateid4 (zdrs, &objp->open_stateid)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_CLOSE4res (ZDR *zdrs, CLOSE4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_stateid4 (zdrs, &objp->CLOSE4res_u.open_stateid)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_COMMIT4args (ZDR *zdrs, COMMIT4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_offset4 (zdrs, &objp->offset)) + return FALSE; + if (!zdr_count4 (zdrs, &objp->count)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_COMMIT4resok (ZDR *zdrs, COMMIT4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_verifier4 (zdrs, objp->writeverf)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_COMMIT4res (ZDR *zdrs, COMMIT4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_COMMIT4resok (zdrs, &objp->COMMIT4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_createtype4 (ZDR *zdrs, createtype4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfs_ftype4 (zdrs, &objp->type)) + return FALSE; + switch (objp->type) { + case NF4LNK: + if (!zdr_linktext4 (zdrs, &objp->createtype4_u.linkdata)) + return FALSE; + break; + case NF4BLK: + case NF4CHR: + if (!zdr_specdata4 (zdrs, &objp->createtype4_u.devdata)) + return FALSE; + break; + case NF4SOCK: + case NF4FIFO: + case NF4DIR: + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_CREATE4args (ZDR *zdrs, CREATE4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_createtype4 (zdrs, &objp->objtype)) + return FALSE; + if (!zdr_component4 (zdrs, &objp->objname)) + return FALSE; + if (!zdr_fattr4 (zdrs, &objp->createattrs)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_CREATE4resok (ZDR *zdrs, CREATE4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_change_info4 (zdrs, &objp->cinfo)) + return FALSE; + if (!zdr_bitmap4 (zdrs, &objp->attrset)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_CREATE4res (ZDR *zdrs, CREATE4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_CREATE4resok (zdrs, &objp->CREATE4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_DELEGPURGE4args (ZDR *zdrs, DELEGPURGE4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_clientid4 (zdrs, &objp->clientid)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_DELEGPURGE4res (ZDR *zdrs, DELEGPURGE4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_DELEGRETURN4args (ZDR *zdrs, DELEGRETURN4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->deleg_stateid)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_DELEGRETURN4res (ZDR *zdrs, DELEGRETURN4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_GETATTR4args (ZDR *zdrs, GETATTR4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bitmap4 (zdrs, &objp->attr_request)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_GETATTR4resok (ZDR *zdrs, GETATTR4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_fattr4 (zdrs, &objp->obj_attributes)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_GETATTR4res (ZDR *zdrs, GETATTR4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_GETATTR4resok (zdrs, &objp->GETATTR4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_GETFH4resok (ZDR *zdrs, GETFH4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfs_fh4 (zdrs, &objp->object)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_GETFH4res (ZDR *zdrs, GETFH4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_GETFH4resok (zdrs, &objp->GETFH4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_LINK4args (ZDR *zdrs, LINK4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_component4 (zdrs, &objp->newname)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_LINK4resok (ZDR *zdrs, LINK4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_change_info4 (zdrs, &objp->cinfo)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_LINK4res (ZDR *zdrs, LINK4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_LINK4resok (zdrs, &objp->LINK4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_open_to_lock_owner4 (ZDR *zdrs, open_to_lock_owner4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_seqid4 (zdrs, &objp->open_seqid)) + return FALSE; + if (!zdr_stateid4 (zdrs, &objp->open_stateid)) + return FALSE; + if (!zdr_seqid4 (zdrs, &objp->lock_seqid)) + return FALSE; + if (!zdr_lock_owner4 (zdrs, &objp->lock_owner)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_exist_lock_owner4 (ZDR *zdrs, exist_lock_owner4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->lock_stateid)) + return FALSE; + if (!zdr_seqid4 (zdrs, &objp->lock_seqid)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_locker4 (ZDR *zdrs, locker4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, &objp->new_lock_owner)) + return FALSE; + switch (objp->new_lock_owner) { + case TRUE: + if (!zdr_open_to_lock_owner4 (zdrs, &objp->locker4_u.open_owner)) + return FALSE; + break; + case FALSE: + if (!zdr_exist_lock_owner4 (zdrs, &objp->locker4_u.lock_owner)) + return FALSE; + break; + default: + return FALSE; + } + return TRUE; +} + +uint32_t +zdr_LOCK4args (ZDR *zdrs, LOCK4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfs_lock_type4 (zdrs, &objp->locktype)) + return FALSE; + if (!zdr_bool (zdrs, &objp->reclaim)) + return FALSE; + if (!zdr_offset4 (zdrs, &objp->offset)) + return FALSE; + if (!zdr_length4 (zdrs, &objp->length)) + return FALSE; + if (!zdr_locker4 (zdrs, &objp->locker)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_LOCK4denied (ZDR *zdrs, LOCK4denied *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_offset4 (zdrs, &objp->offset)) + return FALSE; + if (!zdr_length4 (zdrs, &objp->length)) + return FALSE; + if (!zdr_nfs_lock_type4 (zdrs, &objp->locktype)) + return FALSE; + if (!zdr_lock_owner4 (zdrs, &objp->owner)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_LOCK4resok (ZDR *zdrs, LOCK4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->lock_stateid)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_LOCK4res (ZDR *zdrs, LOCK4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_LOCK4resok (zdrs, &objp->LOCK4res_u.resok4)) + return FALSE; + break; + case NFS4ERR_DENIED: + if (!zdr_LOCK4denied (zdrs, &objp->LOCK4res_u.denied)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_LOCKT4args (ZDR *zdrs, LOCKT4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfs_lock_type4 (zdrs, &objp->locktype)) + return FALSE; + if (!zdr_offset4 (zdrs, &objp->offset)) + return FALSE; + if (!zdr_length4 (zdrs, &objp->length)) + return FALSE; + if (!zdr_lock_owner4 (zdrs, &objp->owner)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_LOCKT4res (ZDR *zdrs, LOCKT4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4ERR_DENIED: + if (!zdr_LOCK4denied (zdrs, &objp->LOCKT4res_u.denied)) + return FALSE; + break; + case NFS4_OK: + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_LOCKU4args (ZDR *zdrs, LOCKU4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfs_lock_type4 (zdrs, &objp->locktype)) + return FALSE; + if (!zdr_seqid4 (zdrs, &objp->seqid)) + return FALSE; + if (!zdr_stateid4 (zdrs, &objp->lock_stateid)) + return FALSE; + if (!zdr_offset4 (zdrs, &objp->offset)) + return FALSE; + if (!zdr_length4 (zdrs, &objp->length)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_LOCKU4res (ZDR *zdrs, LOCKU4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_stateid4 (zdrs, &objp->LOCKU4res_u.lock_stateid)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_LOOKUP4args (ZDR *zdrs, LOOKUP4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_component4 (zdrs, &objp->objname)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_LOOKUP4res (ZDR *zdrs, LOOKUP4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_LOOKUPP4res (ZDR *zdrs, LOOKUPP4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_NVERIFY4args (ZDR *zdrs, NVERIFY4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_fattr4 (zdrs, &objp->obj_attributes)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_NVERIFY4res (ZDR *zdrs, NVERIFY4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_createmode4 (ZDR *zdrs, createmode4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_enum (zdrs, (enum_t *) objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_createhow4 (ZDR *zdrs, createhow4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_createmode4 (zdrs, &objp->mode)) + return FALSE; + switch (objp->mode) { + case UNCHECKED4: + case GUARDED4: + if (!zdr_fattr4 (zdrs, &objp->createhow4_u.createattrs)) + return FALSE; + break; + case EXCLUSIVE4: + if (!zdr_verifier4 (zdrs, objp->createhow4_u.createverf)) + return FALSE; + break; + default: + return FALSE; + } + return TRUE; +} + +uint32_t +zdr_opentype4 (ZDR *zdrs, opentype4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_enum (zdrs, (enum_t *) objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_openflag4 (ZDR *zdrs, openflag4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_opentype4 (zdrs, &objp->opentype)) + return FALSE; + switch (objp->opentype) { + case OPEN4_CREATE: + if (!zdr_createhow4 (zdrs, &objp->openflag4_u.how)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_limit_by4 (ZDR *zdrs, limit_by4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_enum (zdrs, (enum_t *) objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_nfs_modified_limit4 (ZDR *zdrs, nfs_modified_limit4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_uint32_t (zdrs, &objp->num_blocks)) + return FALSE; + if (!zdr_uint32_t (zdrs, &objp->bytes_per_block)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_nfs_space_limit4 (ZDR *zdrs, nfs_space_limit4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_limit_by4 (zdrs, &objp->limitby)) + return FALSE; + switch (objp->limitby) { + case NFS_LIMIT_SIZE: + if (!zdr_uint64_t (zdrs, &objp->nfs_space_limit4_u.filesize)) + return FALSE; + break; + case NFS_LIMIT_BLOCKS: + if (!zdr_nfs_modified_limit4 (zdrs, &objp->nfs_space_limit4_u.mod_blocks)) + return FALSE; + break; + default: + return FALSE; + } + return TRUE; +} + +uint32_t +zdr_open_delegation_type4 (ZDR *zdrs, open_delegation_type4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_enum (zdrs, (enum_t *) objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_open_claim_type4 (ZDR *zdrs, open_claim_type4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_enum (zdrs, (enum_t *) objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_open_claim_delegate_cur4 (ZDR *zdrs, open_claim_delegate_cur4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->delegate_stateid)) + return FALSE; + if (!zdr_component4 (zdrs, &objp->file)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_open_claim4 (ZDR *zdrs, open_claim4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_open_claim_type4 (zdrs, &objp->claim)) + return FALSE; + switch (objp->claim) { + case CLAIM_NULL: + if (!zdr_component4 (zdrs, &objp->open_claim4_u.file)) + return FALSE; + break; + case CLAIM_PREVIOUS: + if (!zdr_open_delegation_type4 (zdrs, &objp->open_claim4_u.delegate_type)) + return FALSE; + break; + case CLAIM_DELEGATE_CUR: + if (!zdr_open_claim_delegate_cur4 (zdrs, &objp->open_claim4_u.delegate_cur_info)) + return FALSE; + break; + case CLAIM_DELEGATE_PREV: + if (!zdr_component4 (zdrs, &objp->open_claim4_u.file_delegate_prev)) + return FALSE; + break; + default: + return FALSE; + } + return TRUE; +} + +uint32_t +zdr_OPEN4args (ZDR *zdrs, OPEN4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_seqid4 (zdrs, &objp->seqid)) + return FALSE; + if (!zdr_uint32_t (zdrs, &objp->share_access)) + return FALSE; + if (!zdr_uint32_t (zdrs, &objp->share_deny)) + return FALSE; + if (!zdr_open_owner4 (zdrs, &objp->owner)) + return FALSE; + if (!zdr_openflag4 (zdrs, &objp->openhow)) + return FALSE; + if (!zdr_open_claim4 (zdrs, &objp->claim)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_open_read_delegation4 (ZDR *zdrs, open_read_delegation4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->stateid)) + return FALSE; + if (!zdr_bool (zdrs, &objp->recall)) + return FALSE; + if (!zdr_nfsace4 (zdrs, &objp->permissions)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_open_write_delegation4 (ZDR *zdrs, open_write_delegation4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->stateid)) + return FALSE; + if (!zdr_bool (zdrs, &objp->recall)) + return FALSE; + if (!zdr_nfs_space_limit4 (zdrs, &objp->space_limit)) + return FALSE; + if (!zdr_nfsace4 (zdrs, &objp->permissions)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_open_delegation4 (ZDR *zdrs, open_delegation4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_open_delegation_type4 (zdrs, &objp->delegation_type)) + return FALSE; + switch (objp->delegation_type) { + case OPEN_DELEGATE_NONE: + break; + case OPEN_DELEGATE_READ: + if (!zdr_open_read_delegation4 (zdrs, &objp->open_delegation4_u.read)) + return FALSE; + break; + case OPEN_DELEGATE_WRITE: + if (!zdr_open_write_delegation4 (zdrs, &objp->open_delegation4_u.write)) + return FALSE; + break; + default: + return FALSE; + } + return TRUE; +} + +uint32_t +zdr_OPEN4resok (ZDR *zdrs, OPEN4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->stateid)) + return FALSE; + if (!zdr_change_info4 (zdrs, &objp->cinfo)) + return FALSE; + if (!zdr_uint32_t (zdrs, &objp->rflags)) + return FALSE; + if (!zdr_bitmap4 (zdrs, &objp->attrset)) + return FALSE; + if (!zdr_open_delegation4 (zdrs, &objp->delegation)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_OPEN4res (ZDR *zdrs, OPEN4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_OPEN4resok (zdrs, &objp->OPEN4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_OPENATTR4args (ZDR *zdrs, OPENATTR4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, &objp->createdir)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_OPENATTR4res (ZDR *zdrs, OPENATTR4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_OPEN_CONFIRM4args (ZDR *zdrs, OPEN_CONFIRM4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->open_stateid)) + return FALSE; + if (!zdr_seqid4 (zdrs, &objp->seqid)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_OPEN_CONFIRM4resok (ZDR *zdrs, OPEN_CONFIRM4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->open_stateid)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_OPEN_CONFIRM4res (ZDR *zdrs, OPEN_CONFIRM4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_OPEN_CONFIRM4resok (zdrs, &objp->OPEN_CONFIRM4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_OPEN_DOWNGRADE4args (ZDR *zdrs, OPEN_DOWNGRADE4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->open_stateid)) + return FALSE; + if (!zdr_seqid4 (zdrs, &objp->seqid)) + return FALSE; + if (!zdr_uint32_t (zdrs, &objp->share_access)) + return FALSE; + if (!zdr_uint32_t (zdrs, &objp->share_deny)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_OPEN_DOWNGRADE4resok (ZDR *zdrs, OPEN_DOWNGRADE4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->open_stateid)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_OPEN_DOWNGRADE4res (ZDR *zdrs, OPEN_DOWNGRADE4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_OPEN_DOWNGRADE4resok (zdrs, &objp->OPEN_DOWNGRADE4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_PUTFH4args (ZDR *zdrs, PUTFH4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfs_fh4 (zdrs, &objp->object)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_PUTFH4res (ZDR *zdrs, PUTFH4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_PUTPUBFH4res (ZDR *zdrs, PUTPUBFH4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_PUTROOTFH4res (ZDR *zdrs, PUTROOTFH4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_READ4args (ZDR *zdrs, READ4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->stateid)) + return FALSE; + if (!zdr_offset4 (zdrs, &objp->offset)) + return FALSE; + if (!zdr_count4 (zdrs, &objp->count)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_READ4resok (ZDR *zdrs, READ4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_bool (zdrs, &objp->eof)) + return FALSE; + if (!zdr_bytes (zdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_READ4res (ZDR *zdrs, READ4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_READ4resok (zdrs, &objp->READ4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_READDIR4args (ZDR *zdrs, READDIR4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfs_cookie4 (zdrs, &objp->cookie)) + return FALSE; + if (!zdr_verifier4 (zdrs, objp->cookieverf)) + return FALSE; + if (!zdr_count4 (zdrs, &objp->dircount)) + return FALSE; + if (!zdr_count4 (zdrs, &objp->maxcount)) + return FALSE; + if (!zdr_bitmap4 (zdrs, &objp->attr_request)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_entry4 (ZDR *zdrs, entry4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfs_cookie4 (zdrs, &objp->cookie)) + return FALSE; + if (!zdr_component4 (zdrs, &objp->name)) + return FALSE; + if (!zdr_fattr4 (zdrs, &objp->attrs)) + return FALSE; + if (!zdr_pointer (zdrs, (char **)&objp->nextentry, sizeof (entry4), (zdrproc_t) zdr_entry4)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_dirlist4 (ZDR *zdrs, dirlist4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_pointer (zdrs, (char **)&objp->entries, sizeof (entry4), (zdrproc_t) zdr_entry4)) + return FALSE; + if (!zdr_bool (zdrs, &objp->eof)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_READDIR4resok (ZDR *zdrs, READDIR4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_verifier4 (zdrs, objp->cookieverf)) + return FALSE; + if (!zdr_dirlist4 (zdrs, &objp->reply)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_READDIR4res (ZDR *zdrs, READDIR4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_READDIR4resok (zdrs, &objp->READDIR4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_READLINK4resok (ZDR *zdrs, READLINK4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_linktext4 (zdrs, &objp->link)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_READLINK4res (ZDR *zdrs, READLINK4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_READLINK4resok (zdrs, &objp->READLINK4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_REMOVE4args (ZDR *zdrs, REMOVE4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_component4 (zdrs, &objp->target)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_REMOVE4resok (ZDR *zdrs, REMOVE4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_change_info4 (zdrs, &objp->cinfo)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_REMOVE4res (ZDR *zdrs, REMOVE4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_REMOVE4resok (zdrs, &objp->REMOVE4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_RENAME4args (ZDR *zdrs, RENAME4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_component4 (zdrs, &objp->oldname)) + return FALSE; + if (!zdr_component4 (zdrs, &objp->newname)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_RENAME4resok (ZDR *zdrs, RENAME4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_change_info4 (zdrs, &objp->source_cinfo)) + return FALSE; + if (!zdr_change_info4 (zdrs, &objp->target_cinfo)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_RENAME4res (ZDR *zdrs, RENAME4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_RENAME4resok (zdrs, &objp->RENAME4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_RENEW4args (ZDR *zdrs, RENEW4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_clientid4 (zdrs, &objp->clientid)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_RENEW4res (ZDR *zdrs, RENEW4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_RESTOREFH4res (ZDR *zdrs, RESTOREFH4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_SAVEFH4res (ZDR *zdrs, SAVEFH4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_SETATTR4args (ZDR *zdrs, SETATTR4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->stateid)) + return FALSE; + if (!zdr_fattr4 (zdrs, &objp->obj_attributes)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_SETATTR4res (ZDR *zdrs, SETATTR4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + if (!zdr_bitmap4 (zdrs, &objp->attrsset)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_SETCLIENTID4args (ZDR *zdrs, SETCLIENTID4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfs_client_id4 (zdrs, &objp->client)) + return FALSE; + if (!zdr_cb_client4 (zdrs, &objp->callback)) + return FALSE; + if (!zdr_uint32_t (zdrs, &objp->callback_ident)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_SETCLIENTID4resok (ZDR *zdrs, SETCLIENTID4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_clientid4 (zdrs, &objp->clientid)) + return FALSE; + if (!zdr_verifier4 (zdrs, objp->setclientid_confirm)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_SETCLIENTID4res (ZDR *zdrs, SETCLIENTID4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_SETCLIENTID4resok (zdrs, &objp->SETCLIENTID4res_u.resok4)) + return FALSE; + break; + case NFS4ERR_CLID_INUSE: + if (!zdr_clientaddr4 (zdrs, &objp->SETCLIENTID4res_u.client_using)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_SETCLIENTID_CONFIRM4args (ZDR *zdrs, SETCLIENTID_CONFIRM4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_clientid4 (zdrs, &objp->clientid)) + return FALSE; + if (!zdr_verifier4 (zdrs, objp->setclientid_confirm)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_SETCLIENTID_CONFIRM4res (ZDR *zdrs, SETCLIENTID_CONFIRM4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_VERIFY4args (ZDR *zdrs, VERIFY4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_fattr4 (zdrs, &objp->obj_attributes)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_VERIFY4res (ZDR *zdrs, VERIFY4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_stable_how4 (ZDR *zdrs, stable_how4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_enum (zdrs, (enum_t *) objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_WRITE4args (ZDR *zdrs, WRITE4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->stateid)) + return FALSE; + if (!zdr_offset4 (zdrs, &objp->offset)) + return FALSE; + if (!zdr_stable_how4 (zdrs, &objp->stable)) + return FALSE; + if (!zdr_bytes (zdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_WRITE4resok (ZDR *zdrs, WRITE4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_count4 (zdrs, &objp->count)) + return FALSE; + if (!zdr_stable_how4 (zdrs, &objp->committed)) + return FALSE; + if (!zdr_verifier4 (zdrs, objp->writeverf)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_WRITE4res (ZDR *zdrs, WRITE4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_WRITE4resok (zdrs, &objp->WRITE4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_RELEASE_LOCKOWNER4args (ZDR *zdrs, RELEASE_LOCKOWNER4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_lock_owner4 (zdrs, &objp->lock_owner)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_RELEASE_LOCKOWNER4res (ZDR *zdrs, RELEASE_LOCKOWNER4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_ILLEGAL4res (ZDR *zdrs, ILLEGAL4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_nfs_opnum4 (ZDR *zdrs, nfs_opnum4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_enum (zdrs, (enum_t *) objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_nfs_argop4 (ZDR *zdrs, nfs_argop4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfs_opnum4 (zdrs, &objp->argop)) + return FALSE; + switch (objp->argop) { + case OP_ACCESS: + if (!zdr_ACCESS4args (zdrs, &objp->nfs_argop4_u.opaccess)) + return FALSE; + break; + case OP_CLOSE: + if (!zdr_CLOSE4args (zdrs, &objp->nfs_argop4_u.opclose)) + return FALSE; + break; + case OP_COMMIT: + if (!zdr_COMMIT4args (zdrs, &objp->nfs_argop4_u.opcommit)) + return FALSE; + break; + case OP_CREATE: + if (!zdr_CREATE4args (zdrs, &objp->nfs_argop4_u.opcreate)) + return FALSE; + break; + case OP_DELEGPURGE: + if (!zdr_DELEGPURGE4args (zdrs, &objp->nfs_argop4_u.opdelegpurge)) + return FALSE; + break; + case OP_DELEGRETURN: + if (!zdr_DELEGRETURN4args (zdrs, &objp->nfs_argop4_u.opdelegreturn)) + return FALSE; + break; + case OP_GETATTR: + if (!zdr_GETATTR4args (zdrs, &objp->nfs_argop4_u.opgetattr)) + return FALSE; + break; + case OP_GETFH: + break; + case OP_LINK: + if (!zdr_LINK4args (zdrs, &objp->nfs_argop4_u.oplink)) + return FALSE; + break; + case OP_LOCK: + if (!zdr_LOCK4args (zdrs, &objp->nfs_argop4_u.oplock)) + return FALSE; + break; + case OP_LOCKT: + if (!zdr_LOCKT4args (zdrs, &objp->nfs_argop4_u.oplockt)) + return FALSE; + break; + case OP_LOCKU: + if (!zdr_LOCKU4args (zdrs, &objp->nfs_argop4_u.oplocku)) + return FALSE; + break; + case OP_LOOKUP: + if (!zdr_LOOKUP4args (zdrs, &objp->nfs_argop4_u.oplookup)) + return FALSE; + break; + case OP_LOOKUPP: + break; + case OP_NVERIFY: + if (!zdr_NVERIFY4args (zdrs, &objp->nfs_argop4_u.opnverify)) + return FALSE; + break; + case OP_OPEN: + if (!zdr_OPEN4args (zdrs, &objp->nfs_argop4_u.opopen)) + return FALSE; + break; + case OP_OPENATTR: + if (!zdr_OPENATTR4args (zdrs, &objp->nfs_argop4_u.opopenattr)) + return FALSE; + break; + case OP_OPEN_CONFIRM: + if (!zdr_OPEN_CONFIRM4args (zdrs, &objp->nfs_argop4_u.opopen_confirm)) + return FALSE; + break; + case OP_OPEN_DOWNGRADE: + if (!zdr_OPEN_DOWNGRADE4args (zdrs, &objp->nfs_argop4_u.opopen_downgrade)) + return FALSE; + break; + case OP_PUTFH: + if (!zdr_PUTFH4args (zdrs, &objp->nfs_argop4_u.opputfh)) + return FALSE; + break; + case OP_PUTPUBFH: + break; + case OP_PUTROOTFH: + break; + case OP_READ: + if (!zdr_READ4args (zdrs, &objp->nfs_argop4_u.opread)) + return FALSE; + break; + case OP_READDIR: + if (!zdr_READDIR4args (zdrs, &objp->nfs_argop4_u.opreaddir)) + return FALSE; + break; + case OP_READLINK: + break; + case OP_REMOVE: + if (!zdr_REMOVE4args (zdrs, &objp->nfs_argop4_u.opremove)) + return FALSE; + break; + case OP_RENAME: + if (!zdr_RENAME4args (zdrs, &objp->nfs_argop4_u.oprename)) + return FALSE; + break; + case OP_RENEW: + if (!zdr_RENEW4args (zdrs, &objp->nfs_argop4_u.oprenew)) + return FALSE; + break; + case OP_RESTOREFH: + break; + case OP_SAVEFH: + break; + case OP_SETATTR: + if (!zdr_SETATTR4args (zdrs, &objp->nfs_argop4_u.opsetattr)) + return FALSE; + break; + case OP_SETCLIENTID: + if (!zdr_SETCLIENTID4args (zdrs, &objp->nfs_argop4_u.opsetclientid)) + return FALSE; + break; + case OP_SETCLIENTID_CONFIRM: + if (!zdr_SETCLIENTID_CONFIRM4args (zdrs, &objp->nfs_argop4_u.opsetclientid_confirm)) + return FALSE; + break; + case OP_VERIFY: + if (!zdr_VERIFY4args (zdrs, &objp->nfs_argop4_u.opverify)) + return FALSE; + break; + case OP_WRITE: + if (!zdr_WRITE4args (zdrs, &objp->nfs_argop4_u.opwrite)) + return FALSE; + break; + case OP_RELEASE_LOCKOWNER: + if (!zdr_RELEASE_LOCKOWNER4args (zdrs, &objp->nfs_argop4_u.oprelease_lockowner)) + return FALSE; + break; + case OP_ILLEGAL: + break; + default: + return FALSE; + } + return TRUE; +} + +uint32_t +zdr_nfs_resop4 (ZDR *zdrs, nfs_resop4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfs_opnum4 (zdrs, &objp->resop)) + return FALSE; + switch (objp->resop) { + case OP_ACCESS: + if (!zdr_ACCESS4res (zdrs, &objp->nfs_resop4_u.opaccess)) + return FALSE; + break; + case OP_CLOSE: + if (!zdr_CLOSE4res (zdrs, &objp->nfs_resop4_u.opclose)) + return FALSE; + break; + case OP_COMMIT: + if (!zdr_COMMIT4res (zdrs, &objp->nfs_resop4_u.opcommit)) + return FALSE; + break; + case OP_CREATE: + if (!zdr_CREATE4res (zdrs, &objp->nfs_resop4_u.opcreate)) + return FALSE; + break; + case OP_DELEGPURGE: + if (!zdr_DELEGPURGE4res (zdrs, &objp->nfs_resop4_u.opdelegpurge)) + return FALSE; + break; + case OP_DELEGRETURN: + if (!zdr_DELEGRETURN4res (zdrs, &objp->nfs_resop4_u.opdelegreturn)) + return FALSE; + break; + case OP_GETATTR: + if (!zdr_GETATTR4res (zdrs, &objp->nfs_resop4_u.opgetattr)) + return FALSE; + break; + case OP_GETFH: + if (!zdr_GETFH4res (zdrs, &objp->nfs_resop4_u.opgetfh)) + return FALSE; + break; + case OP_LINK: + if (!zdr_LINK4res (zdrs, &objp->nfs_resop4_u.oplink)) + return FALSE; + break; + case OP_LOCK: + if (!zdr_LOCK4res (zdrs, &objp->nfs_resop4_u.oplock)) + return FALSE; + break; + case OP_LOCKT: + if (!zdr_LOCKT4res (zdrs, &objp->nfs_resop4_u.oplockt)) + return FALSE; + break; + case OP_LOCKU: + if (!zdr_LOCKU4res (zdrs, &objp->nfs_resop4_u.oplocku)) + return FALSE; + break; + case OP_LOOKUP: + if (!zdr_LOOKUP4res (zdrs, &objp->nfs_resop4_u.oplookup)) + return FALSE; + break; + case OP_LOOKUPP: + if (!zdr_LOOKUPP4res (zdrs, &objp->nfs_resop4_u.oplookupp)) + return FALSE; + break; + case OP_NVERIFY: + if (!zdr_NVERIFY4res (zdrs, &objp->nfs_resop4_u.opnverify)) + return FALSE; + break; + case OP_OPEN: + if (!zdr_OPEN4res (zdrs, &objp->nfs_resop4_u.opopen)) + return FALSE; + break; + case OP_OPENATTR: + if (!zdr_OPENATTR4res (zdrs, &objp->nfs_resop4_u.opopenattr)) + return FALSE; + break; + case OP_OPEN_CONFIRM: + if (!zdr_OPEN_CONFIRM4res (zdrs, &objp->nfs_resop4_u.opopen_confirm)) + return FALSE; + break; + case OP_OPEN_DOWNGRADE: + if (!zdr_OPEN_DOWNGRADE4res (zdrs, &objp->nfs_resop4_u.opopen_downgrade)) + return FALSE; + break; + case OP_PUTFH: + if (!zdr_PUTFH4res (zdrs, &objp->nfs_resop4_u.opputfh)) + return FALSE; + break; + case OP_PUTPUBFH: + if (!zdr_PUTPUBFH4res (zdrs, &objp->nfs_resop4_u.opputpubfh)) + return FALSE; + break; + case OP_PUTROOTFH: + if (!zdr_PUTROOTFH4res (zdrs, &objp->nfs_resop4_u.opputrootfh)) + return FALSE; + break; + case OP_READ: + if (!zdr_READ4res (zdrs, &objp->nfs_resop4_u.opread)) + return FALSE; + break; + case OP_READDIR: + if (!zdr_READDIR4res (zdrs, &objp->nfs_resop4_u.opreaddir)) + return FALSE; + break; + case OP_READLINK: + if (!zdr_READLINK4res (zdrs, &objp->nfs_resop4_u.opreadlink)) + return FALSE; + break; + case OP_REMOVE: + if (!zdr_REMOVE4res (zdrs, &objp->nfs_resop4_u.opremove)) + return FALSE; + break; + case OP_RENAME: + if (!zdr_RENAME4res (zdrs, &objp->nfs_resop4_u.oprename)) + return FALSE; + break; + case OP_RENEW: + if (!zdr_RENEW4res (zdrs, &objp->nfs_resop4_u.oprenew)) + return FALSE; + break; + case OP_RESTOREFH: + if (!zdr_RESTOREFH4res (zdrs, &objp->nfs_resop4_u.oprestorefh)) + return FALSE; + break; + case OP_SAVEFH: + if (!zdr_SAVEFH4res (zdrs, &objp->nfs_resop4_u.opsavefh)) + return FALSE; + break; + case OP_SETATTR: + if (!zdr_SETATTR4res (zdrs, &objp->nfs_resop4_u.opsetattr)) + return FALSE; + break; + case OP_SETCLIENTID: + if (!zdr_SETCLIENTID4res (zdrs, &objp->nfs_resop4_u.opsetclientid)) + return FALSE; + break; + case OP_SETCLIENTID_CONFIRM: + if (!zdr_SETCLIENTID_CONFIRM4res (zdrs, &objp->nfs_resop4_u.opsetclientid_confirm)) + return FALSE; + break; + case OP_VERIFY: + if (!zdr_VERIFY4res (zdrs, &objp->nfs_resop4_u.opverify)) + return FALSE; + break; + case OP_WRITE: + if (!zdr_WRITE4res (zdrs, &objp->nfs_resop4_u.opwrite)) + return FALSE; + break; + case OP_RELEASE_LOCKOWNER: + if (!zdr_RELEASE_LOCKOWNER4res (zdrs, &objp->nfs_resop4_u.oprelease_lockowner)) + return FALSE; + break; + case OP_ILLEGAL: + if (!zdr_ILLEGAL4res (zdrs, &objp->nfs_resop4_u.opillegal)) + return FALSE; + break; + default: + return FALSE; + } + return TRUE; +} + +uint32_t +zdr_COMPOUND4args (ZDR *zdrs, COMPOUND4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_utf8str_cs (zdrs, &objp->tag)) + return FALSE; + if (!zdr_uint32_t (zdrs, &objp->minorversion)) + return FALSE; + if (!zdr_array (zdrs, (char **)&objp->argarray.argarray_val, (u_int *) &objp->argarray.argarray_len, ~0, + sizeof (nfs_argop4), (zdrproc_t) zdr_nfs_argop4)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_COMPOUND4res (ZDR *zdrs, COMPOUND4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + if (!zdr_utf8str_cs (zdrs, &objp->tag)) + return FALSE; + if (!zdr_array (zdrs, (char **)&objp->resarray.resarray_val, (u_int *) &objp->resarray.resarray_len, ~0, + sizeof (nfs_resop4), (zdrproc_t) zdr_nfs_resop4)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_CB_GETATTR4args (ZDR *zdrs, CB_GETATTR4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfs_fh4 (zdrs, &objp->fh)) + return FALSE; + if (!zdr_bitmap4 (zdrs, &objp->attr_request)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_CB_GETATTR4resok (ZDR *zdrs, CB_GETATTR4resok *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_fattr4 (zdrs, &objp->obj_attributes)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_CB_GETATTR4res (ZDR *zdrs, CB_GETATTR4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS4_OK: + if (!zdr_CB_GETATTR4resok (zdrs, &objp->CB_GETATTR4res_u.resok4)) + return FALSE; + break; + default: + break; + } + return TRUE; +} + +uint32_t +zdr_CB_RECALL4args (ZDR *zdrs, CB_RECALL4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_stateid4 (zdrs, &objp->stateid)) + return FALSE; + if (!zdr_bool (zdrs, &objp->truncate)) + return FALSE; + if (!zdr_nfs_fh4 (zdrs, &objp->fh)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_CB_RECALL4res (ZDR *zdrs, CB_RECALL4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_CB_ILLEGAL4res (ZDR *zdrs, CB_ILLEGAL4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_nfs_cb_opnum4 (ZDR *zdrs, nfs_cb_opnum4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_enum (zdrs, (enum_t *) objp)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_nfs_cb_argop4 (ZDR *zdrs, nfs_cb_argop4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_u_int (zdrs, &objp->argop)) + return FALSE; + switch (objp->argop) { + case OP_CB_GETATTR: + if (!zdr_CB_GETATTR4args (zdrs, &objp->nfs_cb_argop4_u.opcbgetattr)) + return FALSE; + break; + case OP_CB_RECALL: + if (!zdr_CB_RECALL4args (zdrs, &objp->nfs_cb_argop4_u.opcbrecall)) + return FALSE; + break; + case OP_CB_ILLEGAL: + break; + default: + return FALSE; + } + return TRUE; +} + +uint32_t +zdr_nfs_cb_resop4 (ZDR *zdrs, nfs_cb_resop4 *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_u_int (zdrs, &objp->resop)) + return FALSE; + switch (objp->resop) { + case OP_CB_GETATTR: + if (!zdr_CB_GETATTR4res (zdrs, &objp->nfs_cb_resop4_u.opcbgetattr)) + return FALSE; + break; + case OP_CB_RECALL: + if (!zdr_CB_RECALL4res (zdrs, &objp->nfs_cb_resop4_u.opcbrecall)) + return FALSE; + break; + case OP_CB_ILLEGAL: + if (!zdr_CB_ILLEGAL4res (zdrs, &objp->nfs_cb_resop4_u.opcbillegal)) + return FALSE; + break; + default: + return FALSE; + } + return TRUE; +} + +uint32_t +zdr_CB_COMPOUND4args (ZDR *zdrs, CB_COMPOUND4args *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_utf8str_cs (zdrs, &objp->tag)) + return FALSE; + if (!zdr_uint32_t (zdrs, &objp->minorversion)) + return FALSE; + if (!zdr_uint32_t (zdrs, &objp->callback_ident)) + return FALSE; + if (!zdr_array (zdrs, (char **)&objp->argarray.argarray_val, (u_int *) &objp->argarray.argarray_len, ~0, + sizeof (nfs_cb_argop4), (zdrproc_t) zdr_nfs_cb_argop4)) + return FALSE; + return TRUE; +} + +uint32_t +zdr_CB_COMPOUND4res (ZDR *zdrs, CB_COMPOUND4res *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!zdr_nfsstat4 (zdrs, &objp->status)) + return FALSE; + if (!zdr_utf8str_cs (zdrs, &objp->tag)) + return FALSE; + if (!zdr_array (zdrs, (char **)&objp->resarray.resarray_val, (u_int *) &objp->resarray.resarray_len, ~0, + sizeof (nfs_cb_resop4), (zdrproc_t) zdr_nfs_cb_resop4)) + return FALSE; + return TRUE; +} diff --git a/nfs4/libnfs-raw-nfs4.h b/nfs4/libnfs-raw-nfs4.h new file mode 100644 index 0000000..ef91a3c --- /dev/null +++ b/nfs4/libnfs-raw-nfs4.h @@ -0,0 +1,1987 @@ +/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ +/* + * The definitions in this file are based on RFC3530. + */ + +/* RFC3530 contains the following copyright statement: + + + Copyright (C) The Internet Society (2003). All Rights Reserved. + + This document and translations of it may be copied and furnished to + others, and derivative works that comment on or otherwise explain it + or assist in its implementation may be prepared, copied, published + and distributed, in whole or in part, without restriction of any + kind, provided that the above copyright notice and this paragraph are + included on all such copies and derivative works. However, this + document itself may not be modified in any way, such as by removing + the copyright notice or references to the Internet Society or other + Internet organizations, except as needed for the purpose of + developing Internet standards in which case the procedures for + copyrights defined in the Internet Standards process must be + followed, or as required to translate it into languages other than + English. + + The limited permissions granted above are perpetual and will not be + revoked by the Internet Society or its successors or assigns. + + This document and the information contained herein is provided on an + "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING +/* + * Please do not edit this file. + * It was generated using rpcgen. + */ + +#ifndef _NFS4_H_RPCGEN +#define _NFS4_H_RPCGEN + +#include + + +#ifdef __cplusplus +extern "C" { +#endif + +#define NFS4_FHSIZE 128 +#define NFS4_VERIFIER_SIZE 8 +#define NFS4_OPAQUE_LIMIT 1024 + +enum nfs_ftype4 { + NF4REG = 1, + NF4DIR = 2, + NF4BLK = 3, + NF4CHR = 4, + NF4LNK = 5, + NF4SOCK = 6, + NF4FIFO = 7, + NF4ATTRDIR = 8, + NF4NAMEDATTR = 9, +}; +typedef enum nfs_ftype4 nfs_ftype4; + +enum nfsstat4 { + NFS4_OK = 0, + NFS4ERR_PERM = 1, + NFS4ERR_NOENT = 2, + NFS4ERR_IO = 5, + NFS4ERR_NXIO = 6, + NFS4ERR_ACCESS = 13, + NFS4ERR_EXIST = 17, + NFS4ERR_XDEV = 18, + NFS4ERR_NOTDIR = 20, + NFS4ERR_ISDIR = 21, + NFS4ERR_INVAL = 22, + NFS4ERR_FBIG = 27, + NFS4ERR_NOSPC = 28, + NFS4ERR_ROFS = 30, + NFS4ERR_MLINK = 31, + NFS4ERR_NAMETOOLONG = 63, + NFS4ERR_NOTEMPTY = 66, + NFS4ERR_DQUOT = 69, + NFS4ERR_STALE = 70, + NFS4ERR_BADHANDLE = 10001, + NFS4ERR_BAD_COOKIE = 10003, + NFS4ERR_NOTSUPP = 10004, + NFS4ERR_TOOSMALL = 10005, + NFS4ERR_SERVERFAULT = 10006, + NFS4ERR_BADTYPE = 10007, + NFS4ERR_DELAY = 10008, + NFS4ERR_SAME = 10009, + NFS4ERR_DENIED = 10010, + NFS4ERR_EXPIRED = 10011, + NFS4ERR_LOCKED = 10012, + NFS4ERR_GRACE = 10013, + NFS4ERR_FHEXPIRED = 10014, + NFS4ERR_SHARE_DENIED = 10015, + NFS4ERR_WRONGSEC = 10016, + NFS4ERR_CLID_INUSE = 10017, + NFS4ERR_RESOURCE = 10018, + NFS4ERR_MOVED = 10019, + NFS4ERR_NOFILEHANDLE = 10020, + NFS4ERR_MINOR_VERS_MISMATCH = 10021, + NFS4ERR_STALE_CLIENTID = 10022, + NFS4ERR_STALE_STATEID = 10023, + NFS4ERR_OLD_STATEID = 10024, + NFS4ERR_BAD_STATEID = 10025, + NFS4ERR_BAD_SEQID = 10026, + NFS4ERR_NOT_SAME = 10027, + NFS4ERR_LOCK_RANGE = 10028, + NFS4ERR_SYMLINK = 10029, + NFS4ERR_RESTOREFH = 10030, + NFS4ERR_LEASE_MOVED = 10031, + NFS4ERR_ATTRNOTSUPP = 10032, + NFS4ERR_NO_GRACE = 10033, + NFS4ERR_RECLAIM_BAD = 10034, + NFS4ERR_RECLAIM_CONFLICT = 10035, + NFS4ERR_BADZDR = 10036, + NFS4ERR_LOCKS_HELD = 10037, + NFS4ERR_OPENMODE = 10038, + NFS4ERR_BADOWNER = 10039, + NFS4ERR_BADCHAR = 10040, + NFS4ERR_BADNAME = 10041, + NFS4ERR_BAD_RANGE = 10042, + NFS4ERR_LOCK_NOTSUPP = 10043, + NFS4ERR_OP_ILLEGAL = 10044, + NFS4ERR_DEADLOCK = 10045, + NFS4ERR_FILE_OPEN = 10046, + NFS4ERR_ADMIN_REVOKED = 10047, + NFS4ERR_CB_PATH_DOWN = 10048, +}; +typedef enum nfsstat4 nfsstat4; + +typedef struct { + u_int bitmap4_len; + uint32_t *bitmap4_val; +} bitmap4; + +typedef uint64_t offset4; + +typedef uint32_t count4; + +typedef uint64_t length4; + +typedef uint64_t clientid4; + +typedef uint32_t seqid4; + +typedef struct { + u_int utf8string_len; + char *utf8string_val; +} utf8string; + +typedef utf8string utf8str_cis; + +typedef utf8string utf8str_cs; + +typedef utf8string utf8str_mixed; + +typedef utf8str_cs component4; + +typedef struct { + u_int pathname4_len; + component4 *pathname4_val; +} pathname4; + +typedef uint64_t nfs_lockid4; + +typedef uint64_t nfs_cookie4; + +typedef utf8str_cs linktext4; + +typedef struct { + u_int sec_oid4_len; + char *sec_oid4_val; +} sec_oid4; + +typedef uint32_t qop4; + +typedef uint32_t mode4; + +typedef uint64_t changeid4; + +typedef char verifier4[NFS4_VERIFIER_SIZE]; + +struct nfstime4 { + int64_t seconds; + uint32_t nseconds; +}; +typedef struct nfstime4 nfstime4; + +enum time_how4 { + SET_TO_SERVER_TIME4 = 0, + SET_TO_CLIENT_TIME4 = 1, +}; +typedef enum time_how4 time_how4; + +struct settime4 { + time_how4 set_it; + union { + nfstime4 time; + } settime4_u; +}; +typedef struct settime4 settime4; + +typedef struct { + u_int nfs_fh4_len; + char *nfs_fh4_val; +} nfs_fh4; + +struct fsid4 { + uint64_t major; + uint64_t minor; +}; +typedef struct fsid4 fsid4; + +struct fs_location4 { + struct { + u_int server_len; + utf8str_cis *server_val; + } server; + pathname4 rootpath; +}; +typedef struct fs_location4 fs_location4; + +struct fs_locations4 { + pathname4 fs_root; + struct { + u_int locations_len; + fs_location4 *locations_val; + } locations; +}; +typedef struct fs_locations4 fs_locations4; +#define ACL4_SUPPORT_ALLOW_ACL 0x00000001 +#define ACL4_SUPPORT_DENY_ACL 0x00000002 +#define ACL4_SUPPORT_AUDIT_ACL 0x00000004 +#define ACL4_SUPPORT_ALARM_ACL 0x00000008 + +typedef uint32_t acetype4; +#define ACE4_ACCESS_ALLOWED_ACE_TYPE 0x00000000 +#define ACE4_ACCESS_DENIED_ACE_TYPE 0x00000001 +#define ACE4_SYSTEM_AUDIT_ACE_TYPE 0x00000002 +#define ACE4_SYSTEM_ALARM_ACE_TYPE 0x00000003 + +typedef uint32_t aceflag4; +#define ACE4_FILE_INHERIT_ACE 0x00000001 +#define ACE4_DIRECTORY_INHERIT_ACE 0x00000002 +#define ACE4_NO_PROPAGATE_INHERIT_ACE 0x00000004 +#define ACE4_INHERIT_ONLY_ACE 0x00000008 +#define ACE4_SUCCESSFUL_ACCESS_ACE_FLAG 0x00000010 +#define ACE4_FAILED_ACCESS_ACE_FLAG 0x00000020 +#define ACE4_IDENTIFIER_GROUP 0x00000040 + +typedef uint32_t acemask4; +#define ACE4_READ_DATA 0x00000001 +#define ACE4_LIST_DIRECTORY 0x00000001 +#define ACE4_WRITE_DATA 0x00000002 +#define ACE4_ADD_FILE 0x00000002 +#define ACE4_APPEND_DATA 0x00000004 +#define ACE4_ADD_SUBDIRECTORY 0x00000004 +#define ACE4_READ_NAMED_ATTRS 0x00000008 +#define ACE4_WRITE_NAMED_ATTRS 0x00000010 +#define ACE4_EXECUTE 0x00000020 +#define ACE4_DELETE_CHILD 0x00000040 +#define ACE4_READ_ATTRIBUTES 0x00000080 +#define ACE4_WRITE_ATTRIBUTES 0x00000100 +#define ACE4_DELETE 0x00010000 +#define ACE4_READ_ACL 0x00020000 +#define ACE4_WRITE_ACL 0x00040000 +#define ACE4_WRITE_OWNER 0x00080000 +#define ACE4_SYNCHRONIZE 0x00100000 +#define ACE4_GENERIC_READ 0x00120081 +#define ACE4_GENERIC_WRITE 0x00160106 +#define ACE4_GENERIC_EXECUTE 0x001200A0 + +struct nfsace4 { + acetype4 type; + aceflag4 flag; + acemask4 access_mask; + utf8str_mixed who; +}; +typedef struct nfsace4 nfsace4; +#define MODE4_SUID 0x800 +#define MODE4_SGID 0x400 +#define MODE4_SVTX 0x200 +#define MODE4_RUSR 0x100 +#define MODE4_WUSR 0x080 +#define MODE4_XUSR 0x040 +#define MODE4_RGRP 0x020 +#define MODE4_WGRP 0x010 +#define MODE4_XGRP 0x008 +#define MODE4_ROTH 0x004 +#define MODE4_WOTH 0x002 +#define MODE4_XOTH 0x001 + +struct specdata4 { + uint32_t specdata1; + uint32_t specdata2; +}; +typedef struct specdata4 specdata4; +#define FH4_PERSISTENT 0x00000000 +#define FH4_NOEXPIRE_WITH_OPEN 0x00000001 +#define FH4_VOLATILE_ANY 0x00000002 +#define FH4_VOL_MIGRATION 0x00000004 +#define 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 uint32_t fattr4_link_support; + +typedef uint32_t fattr4_symlink_support; + +typedef uint32_t fattr4_named_attr; + +typedef fsid4 fattr4_fsid; + +typedef uint32_t fattr4_unique_handles; + +typedef uint32_t fattr4_lease_time; + +typedef nfsstat4 fattr4_rdattr_error; + +typedef struct { + u_int fattr4_acl_len; + nfsace4 *fattr4_acl_val; +} fattr4_acl; + +typedef uint32_t fattr4_aclsupport; + +typedef uint32_t fattr4_archive; + +typedef uint32_t fattr4_cansettime; + +typedef uint32_t fattr4_case_insensitive; + +typedef uint32_t fattr4_case_preserving; + +typedef uint32_t 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 uint32_t fattr4_hidden; + +typedef uint32_t 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 uint32_t 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 uint32_t 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; +#define FATTR4_SUPPORTED_ATTRS 0 +#define FATTR4_TYPE 1 +#define FATTR4_FH_EXPIRE_TYPE 2 +#define FATTR4_CHANGE 3 +#define FATTR4_SIZE 4 +#define FATTR4_LINK_SUPPORT 5 +#define FATTR4_SYMLINK_SUPPORT 6 +#define FATTR4_NAMED_ATTR 7 +#define FATTR4_FSID 8 +#define FATTR4_UNIQUE_HANDLES 9 +#define FATTR4_LEASE_TIME 10 +#define FATTR4_RDATTR_ERROR 11 +#define FATTR4_FILEHANDLE 19 +#define FATTR4_ACL 12 +#define FATTR4_ACLSUPPORT 13 +#define FATTR4_ARCHIVE 14 +#define FATTR4_CANSETTIME 15 +#define FATTR4_CASE_INSENSITIVE 16 +#define FATTR4_CASE_PRESERVING 17 +#define FATTR4_CHOWN_RESTRICTED 18 +#define FATTR4_FILEID 20 +#define FATTR4_FILES_AVAIL 21 +#define FATTR4_FILES_FREE 22 +#define FATTR4_FILES_TOTAL 23 +#define FATTR4_FS_LOCATIONS 24 +#define FATTR4_HIDDEN 25 +#define FATTR4_HOMOGENEOUS 26 +#define FATTR4_MAXFILESIZE 27 +#define FATTR4_MAXLINK 28 +#define FATTR4_MAXNAME 29 +#define FATTR4_MAXREAD 30 +#define FATTR4_MAXWRITE 31 +#define FATTR4_MIMETYPE 32 +#define FATTR4_MODE 33 +#define FATTR4_NO_TRUNC 34 +#define FATTR4_NUMLINKS 35 +#define FATTR4_OWNER 36 +#define FATTR4_OWNER_GROUP 37 +#define FATTR4_QUOTA_AVAIL_HARD 38 +#define FATTR4_QUOTA_AVAIL_SOFT 39 +#define FATTR4_QUOTA_USED 40 +#define FATTR4_RAWDEV 41 +#define FATTR4_SPACE_AVAIL 42 +#define FATTR4_SPACE_FREE 43 +#define FATTR4_SPACE_TOTAL 44 +#define FATTR4_SPACE_USED 45 +#define FATTR4_SYSTEM 46 +#define FATTR4_TIME_ACCESS 47 +#define FATTR4_TIME_ACCESS_SET 48 +#define FATTR4_TIME_BACKUP 49 +#define FATTR4_TIME_CREATE 50 +#define FATTR4_TIME_DELTA 51 +#define FATTR4_TIME_METADATA 52 +#define FATTR4_TIME_MODIFY 53 +#define FATTR4_TIME_MODIFY_SET 54 +#define FATTR4_MOUNTED_ON_FILEID 55 + +typedef struct { + u_int attrlist4_len; + char *attrlist4_val; +} attrlist4; + +struct fattr4 { + bitmap4 attrmask; + attrlist4 attr_vals; +}; +typedef struct fattr4 fattr4; + +struct change_info4 { + uint32_t atomic; + changeid4 before; + changeid4 after; +}; +typedef struct change_info4 change_info4; + +struct clientaddr4 { + char *r_netid; + char *r_addr; +}; +typedef struct clientaddr4 clientaddr4; + +struct cb_client4 { + uint32_t cb_program; + clientaddr4 cb_location; +}; +typedef struct cb_client4 cb_client4; + +struct stateid4 { + uint32_t seqid; + char other[12]; +}; +typedef struct stateid4 stateid4; + +struct nfs_client_id4 { + verifier4 verifier; + struct { + u_int id_len; + char *id_val; + } id; +}; +typedef struct nfs_client_id4 nfs_client_id4; + +struct open_owner4 { + clientid4 clientid; + struct { + u_int owner_len; + char *owner_val; + } owner; +}; +typedef struct open_owner4 open_owner4; + +struct lock_owner4 { + clientid4 clientid; + struct { + u_int owner_len; + char *owner_val; + } owner; +}; +typedef struct lock_owner4 lock_owner4; + +enum nfs_lock_type4 { + READ_LT = 1, + WRITE_LT = 2, + READW_LT = 3, + WRITEW_LT = 4, +}; +typedef enum nfs_lock_type4 nfs_lock_type4; +#define ACCESS4_READ 0x00000001 +#define ACCESS4_LOOKUP 0x00000002 +#define ACCESS4_MODIFY 0x00000004 +#define ACCESS4_EXTEND 0x00000008 +#define ACCESS4_DELETE 0x00000010 +#define ACCESS4_EXECUTE 0x00000020 + +struct ACCESS4args { + uint32_t access; +}; +typedef struct ACCESS4args ACCESS4args; + +struct ACCESS4resok { + uint32_t supported; + uint32_t access; +}; +typedef struct ACCESS4resok ACCESS4resok; + +struct ACCESS4res { + nfsstat4 status; + union { + ACCESS4resok resok4; + } ACCESS4res_u; +}; +typedef struct ACCESS4res ACCESS4res; + +struct CLOSE4args { + seqid4 seqid; + stateid4 open_stateid; +}; +typedef struct CLOSE4args CLOSE4args; + +struct CLOSE4res { + nfsstat4 status; + union { + stateid4 open_stateid; + } CLOSE4res_u; +}; +typedef struct CLOSE4res CLOSE4res; + +struct COMMIT4args { + offset4 offset; + count4 count; +}; +typedef struct COMMIT4args COMMIT4args; + +struct COMMIT4resok { + verifier4 writeverf; +}; +typedef struct COMMIT4resok COMMIT4resok; + +struct COMMIT4res { + nfsstat4 status; + union { + COMMIT4resok resok4; + } COMMIT4res_u; +}; +typedef struct COMMIT4res COMMIT4res; + +struct createtype4 { + nfs_ftype4 type; + union { + linktext4 linkdata; + specdata4 devdata; + } createtype4_u; +}; +typedef struct createtype4 createtype4; + +struct CREATE4args { + createtype4 objtype; + component4 objname; + fattr4 createattrs; +}; +typedef struct CREATE4args CREATE4args; + +struct CREATE4resok { + change_info4 cinfo; + bitmap4 attrset; +}; +typedef struct CREATE4resok CREATE4resok; + +struct CREATE4res { + nfsstat4 status; + union { + CREATE4resok resok4; + } CREATE4res_u; +}; +typedef struct CREATE4res CREATE4res; + +struct DELEGPURGE4args { + clientid4 clientid; +}; +typedef struct DELEGPURGE4args DELEGPURGE4args; + +struct DELEGPURGE4res { + nfsstat4 status; +}; +typedef struct DELEGPURGE4res DELEGPURGE4res; + +struct DELEGRETURN4args { + stateid4 deleg_stateid; +}; +typedef struct DELEGRETURN4args DELEGRETURN4args; + +struct DELEGRETURN4res { + nfsstat4 status; +}; +typedef struct DELEGRETURN4res DELEGRETURN4res; + +struct GETATTR4args { + bitmap4 attr_request; +}; +typedef struct GETATTR4args GETATTR4args; + +struct GETATTR4resok { + fattr4 obj_attributes; +}; +typedef struct GETATTR4resok GETATTR4resok; + +struct GETATTR4res { + nfsstat4 status; + union { + GETATTR4resok resok4; + } GETATTR4res_u; +}; +typedef struct GETATTR4res GETATTR4res; + +struct GETFH4resok { + nfs_fh4 object; +}; +typedef struct GETFH4resok GETFH4resok; + +struct GETFH4res { + nfsstat4 status; + union { + GETFH4resok resok4; + } GETFH4res_u; +}; +typedef struct GETFH4res GETFH4res; + +struct LINK4args { + component4 newname; +}; +typedef struct LINK4args LINK4args; + +struct LINK4resok { + change_info4 cinfo; +}; +typedef struct LINK4resok LINK4resok; + +struct LINK4res { + nfsstat4 status; + union { + LINK4resok resok4; + } LINK4res_u; +}; +typedef struct LINK4res LINK4res; + +struct open_to_lock_owner4 { + seqid4 open_seqid; + stateid4 open_stateid; + seqid4 lock_seqid; + lock_owner4 lock_owner; +}; +typedef struct open_to_lock_owner4 open_to_lock_owner4; + +struct exist_lock_owner4 { + stateid4 lock_stateid; + seqid4 lock_seqid; +}; +typedef struct exist_lock_owner4 exist_lock_owner4; + +struct locker4 { + uint32_t new_lock_owner; + union { + open_to_lock_owner4 open_owner; + exist_lock_owner4 lock_owner; + } locker4_u; +}; +typedef struct locker4 locker4; + +struct LOCK4args { + nfs_lock_type4 locktype; + uint32_t reclaim; + offset4 offset; + length4 length; + locker4 locker; +}; +typedef struct LOCK4args LOCK4args; + +struct LOCK4denied { + offset4 offset; + length4 length; + nfs_lock_type4 locktype; + lock_owner4 owner; +}; +typedef struct LOCK4denied LOCK4denied; + +struct LOCK4resok { + stateid4 lock_stateid; +}; +typedef struct LOCK4resok LOCK4resok; + +struct LOCK4res { + nfsstat4 status; + union { + LOCK4resok resok4; + LOCK4denied denied; + } LOCK4res_u; +}; +typedef struct LOCK4res LOCK4res; + +struct LOCKT4args { + nfs_lock_type4 locktype; + offset4 offset; + length4 length; + lock_owner4 owner; +}; +typedef struct LOCKT4args LOCKT4args; + +struct LOCKT4res { + nfsstat4 status; + union { + LOCK4denied denied; + } LOCKT4res_u; +}; +typedef struct LOCKT4res LOCKT4res; + +struct LOCKU4args { + nfs_lock_type4 locktype; + seqid4 seqid; + stateid4 lock_stateid; + offset4 offset; + length4 length; +}; +typedef struct LOCKU4args LOCKU4args; + +struct LOCKU4res { + nfsstat4 status; + union { + stateid4 lock_stateid; + } LOCKU4res_u; +}; +typedef struct LOCKU4res LOCKU4res; + +struct LOOKUP4args { + component4 objname; +}; +typedef struct LOOKUP4args LOOKUP4args; + +struct LOOKUP4res { + nfsstat4 status; +}; +typedef struct LOOKUP4res LOOKUP4res; + +struct LOOKUPP4res { + nfsstat4 status; +}; +typedef struct LOOKUPP4res LOOKUPP4res; + +struct NVERIFY4args { + fattr4 obj_attributes; +}; +typedef struct NVERIFY4args NVERIFY4args; + +struct NVERIFY4res { + nfsstat4 status; +}; +typedef struct NVERIFY4res NVERIFY4res; + +enum createmode4 { + UNCHECKED4 = 0, + GUARDED4 = 1, + EXCLUSIVE4 = 2, +}; +typedef enum createmode4 createmode4; + +struct createhow4 { + createmode4 mode; + union { + fattr4 createattrs; + verifier4 createverf; + } createhow4_u; +}; +typedef struct createhow4 createhow4; + +enum opentype4 { + OPEN4_NOCREATE = 0, + OPEN4_CREATE = 1, +}; +typedef enum opentype4 opentype4; + +struct openflag4 { + opentype4 opentype; + union { + createhow4 how; + } openflag4_u; +}; +typedef struct openflag4 openflag4; + +enum limit_by4 { + NFS_LIMIT_SIZE = 1, + NFS_LIMIT_BLOCKS = 2, +}; +typedef enum limit_by4 limit_by4; + +struct nfs_modified_limit4 { + uint32_t num_blocks; + uint32_t bytes_per_block; +}; +typedef struct nfs_modified_limit4 nfs_modified_limit4; + +struct nfs_space_limit4 { + limit_by4 limitby; + union { + uint64_t filesize; + nfs_modified_limit4 mod_blocks; + } nfs_space_limit4_u; +}; +typedef struct nfs_space_limit4 nfs_space_limit4; +#define OPEN4_SHARE_ACCESS_READ 0x00000001 +#define OPEN4_SHARE_ACCESS_WRITE 0x00000002 +#define OPEN4_SHARE_ACCESS_BOTH 0x00000003 +#define OPEN4_SHARE_DENY_NONE 0x00000000 +#define OPEN4_SHARE_DENY_READ 0x00000001 +#define OPEN4_SHARE_DENY_WRITE 0x00000002 +#define OPEN4_SHARE_DENY_BOTH 0x00000003 + +enum open_delegation_type4 { + OPEN_DELEGATE_NONE = 0, + OPEN_DELEGATE_READ = 1, + OPEN_DELEGATE_WRITE = 2, +}; +typedef enum open_delegation_type4 open_delegation_type4; + +enum open_claim_type4 { + CLAIM_NULL = 0, + CLAIM_PREVIOUS = 1, + CLAIM_DELEGATE_CUR = 2, + CLAIM_DELEGATE_PREV = 3, +}; +typedef enum open_claim_type4 open_claim_type4; + +struct open_claim_delegate_cur4 { + stateid4 delegate_stateid; + component4 file; +}; +typedef struct open_claim_delegate_cur4 open_claim_delegate_cur4; + +struct open_claim4 { + open_claim_type4 claim; + union { + component4 file; + open_delegation_type4 delegate_type; + open_claim_delegate_cur4 delegate_cur_info; + component4 file_delegate_prev; + } open_claim4_u; +}; +typedef struct open_claim4 open_claim4; + +struct OPEN4args { + seqid4 seqid; + uint32_t share_access; + uint32_t share_deny; + open_owner4 owner; + openflag4 openhow; + open_claim4 claim; +}; +typedef struct OPEN4args OPEN4args; + +struct open_read_delegation4 { + stateid4 stateid; + uint32_t recall; + nfsace4 permissions; +}; +typedef struct open_read_delegation4 open_read_delegation4; + +struct open_write_delegation4 { + stateid4 stateid; + uint32_t recall; + nfs_space_limit4 space_limit; + nfsace4 permissions; +}; +typedef struct open_write_delegation4 open_write_delegation4; + +struct open_delegation4 { + open_delegation_type4 delegation_type; + union { + open_read_delegation4 read; + open_write_delegation4 write; + } open_delegation4_u; +}; +typedef struct open_delegation4 open_delegation4; +#define OPEN4_RESULT_CONFIRM 0x00000002 +#define OPEN4_RESULT_LOCKTYPE_POSIX 0x00000004 + +struct OPEN4resok { + stateid4 stateid; + change_info4 cinfo; + uint32_t rflags; + bitmap4 attrset; + open_delegation4 delegation; +}; +typedef struct OPEN4resok OPEN4resok; + +struct OPEN4res { + nfsstat4 status; + union { + OPEN4resok resok4; + } OPEN4res_u; +}; +typedef struct OPEN4res OPEN4res; + +struct OPENATTR4args { + uint32_t createdir; +}; +typedef struct OPENATTR4args OPENATTR4args; + +struct OPENATTR4res { + nfsstat4 status; +}; +typedef struct OPENATTR4res OPENATTR4res; + +struct OPEN_CONFIRM4args { + stateid4 open_stateid; + seqid4 seqid; +}; +typedef struct OPEN_CONFIRM4args OPEN_CONFIRM4args; + +struct OPEN_CONFIRM4resok { + stateid4 open_stateid; +}; +typedef struct OPEN_CONFIRM4resok OPEN_CONFIRM4resok; + +struct OPEN_CONFIRM4res { + nfsstat4 status; + union { + OPEN_CONFIRM4resok resok4; + } OPEN_CONFIRM4res_u; +}; +typedef struct OPEN_CONFIRM4res OPEN_CONFIRM4res; + +struct OPEN_DOWNGRADE4args { + stateid4 open_stateid; + seqid4 seqid; + uint32_t share_access; + uint32_t share_deny; +}; +typedef struct OPEN_DOWNGRADE4args OPEN_DOWNGRADE4args; + +struct OPEN_DOWNGRADE4resok { + stateid4 open_stateid; +}; +typedef struct OPEN_DOWNGRADE4resok OPEN_DOWNGRADE4resok; + +struct OPEN_DOWNGRADE4res { + nfsstat4 status; + union { + OPEN_DOWNGRADE4resok resok4; + } OPEN_DOWNGRADE4res_u; +}; +typedef struct OPEN_DOWNGRADE4res OPEN_DOWNGRADE4res; + +struct PUTFH4args { + nfs_fh4 object; +}; +typedef struct PUTFH4args PUTFH4args; + +struct PUTFH4res { + nfsstat4 status; +}; +typedef struct PUTFH4res PUTFH4res; + +struct PUTPUBFH4res { + nfsstat4 status; +}; +typedef struct PUTPUBFH4res PUTPUBFH4res; + +struct PUTROOTFH4res { + nfsstat4 status; +}; +typedef struct PUTROOTFH4res PUTROOTFH4res; + +struct READ4args { + stateid4 stateid; + offset4 offset; + count4 count; +}; +typedef struct READ4args READ4args; + +struct READ4resok { + uint32_t eof; + struct { + u_int data_len; + char *data_val; + } data; +}; +typedef struct READ4resok READ4resok; + +struct READ4res { + nfsstat4 status; + union { + READ4resok resok4; + } READ4res_u; +}; +typedef struct READ4res READ4res; + +struct READDIR4args { + nfs_cookie4 cookie; + verifier4 cookieverf; + count4 dircount; + count4 maxcount; + bitmap4 attr_request; +}; +typedef struct READDIR4args READDIR4args; + +struct entry4 { + nfs_cookie4 cookie; + component4 name; + fattr4 attrs; + struct entry4 *nextentry; +}; +typedef struct entry4 entry4; + +struct dirlist4 { + entry4 *entries; + uint32_t eof; +}; +typedef struct dirlist4 dirlist4; + +struct READDIR4resok { + verifier4 cookieverf; + dirlist4 reply; +}; +typedef struct READDIR4resok READDIR4resok; + +struct READDIR4res { + nfsstat4 status; + union { + READDIR4resok resok4; + } READDIR4res_u; +}; +typedef struct READDIR4res READDIR4res; + +struct READLINK4resok { + linktext4 link; +}; +typedef struct READLINK4resok READLINK4resok; + +struct READLINK4res { + nfsstat4 status; + union { + READLINK4resok resok4; + } READLINK4res_u; +}; +typedef struct READLINK4res READLINK4res; + +struct REMOVE4args { + component4 target; +}; +typedef struct REMOVE4args REMOVE4args; + +struct REMOVE4resok { + change_info4 cinfo; +}; +typedef struct REMOVE4resok REMOVE4resok; + +struct REMOVE4res { + nfsstat4 status; + union { + REMOVE4resok resok4; + } REMOVE4res_u; +}; +typedef struct REMOVE4res REMOVE4res; + +struct RENAME4args { + component4 oldname; + component4 newname; +}; +typedef struct RENAME4args RENAME4args; + +struct RENAME4resok { + change_info4 source_cinfo; + change_info4 target_cinfo; +}; +typedef struct RENAME4resok RENAME4resok; + +struct RENAME4res { + nfsstat4 status; + union { + RENAME4resok resok4; + } RENAME4res_u; +}; +typedef struct RENAME4res RENAME4res; + +struct RENEW4args { + clientid4 clientid; +}; +typedef struct RENEW4args RENEW4args; + +struct RENEW4res { + nfsstat4 status; +}; +typedef struct RENEW4res RENEW4res; + +struct RESTOREFH4res { + nfsstat4 status; +}; +typedef struct RESTOREFH4res RESTOREFH4res; + +struct SAVEFH4res { + nfsstat4 status; +}; +typedef struct SAVEFH4res SAVEFH4res; + +struct SETATTR4args { + stateid4 stateid; + fattr4 obj_attributes; +}; +typedef struct SETATTR4args SETATTR4args; + +struct SETATTR4res { + nfsstat4 status; + bitmap4 attrsset; +}; +typedef struct SETATTR4res SETATTR4res; + +struct SETCLIENTID4args { + nfs_client_id4 client; + cb_client4 callback; + uint32_t callback_ident; +}; +typedef struct SETCLIENTID4args SETCLIENTID4args; + +struct SETCLIENTID4resok { + clientid4 clientid; + verifier4 setclientid_confirm; +}; +typedef struct SETCLIENTID4resok SETCLIENTID4resok; + +struct SETCLIENTID4res { + nfsstat4 status; + union { + SETCLIENTID4resok resok4; + clientaddr4 client_using; + } SETCLIENTID4res_u; +}; +typedef struct SETCLIENTID4res SETCLIENTID4res; + +struct SETCLIENTID_CONFIRM4args { + clientid4 clientid; + verifier4 setclientid_confirm; +}; +typedef struct SETCLIENTID_CONFIRM4args SETCLIENTID_CONFIRM4args; + +struct SETCLIENTID_CONFIRM4res { + nfsstat4 status; +}; +typedef struct SETCLIENTID_CONFIRM4res SETCLIENTID_CONFIRM4res; + +struct VERIFY4args { + fattr4 obj_attributes; +}; +typedef struct VERIFY4args VERIFY4args; + +struct VERIFY4res { + nfsstat4 status; +}; +typedef struct VERIFY4res VERIFY4res; + +enum stable_how4 { + UNSTABLE4 = 0, + DATA_SYNC4 = 1, + FILE_SYNC4 = 2, +}; +typedef enum stable_how4 stable_how4; + +struct WRITE4args { + stateid4 stateid; + offset4 offset; + stable_how4 stable; + struct { + u_int data_len; + char *data_val; + } data; +}; +typedef struct WRITE4args WRITE4args; + +struct WRITE4resok { + count4 count; + stable_how4 committed; + verifier4 writeverf; +}; +typedef struct WRITE4resok WRITE4resok; + +struct WRITE4res { + nfsstat4 status; + union { + WRITE4resok resok4; + } WRITE4res_u; +}; +typedef struct WRITE4res WRITE4res; + +struct RELEASE_LOCKOWNER4args { + lock_owner4 lock_owner; +}; +typedef struct RELEASE_LOCKOWNER4args RELEASE_LOCKOWNER4args; + +struct RELEASE_LOCKOWNER4res { + nfsstat4 status; +}; +typedef struct RELEASE_LOCKOWNER4res RELEASE_LOCKOWNER4res; + +struct ILLEGAL4res { + nfsstat4 status; +}; +typedef struct ILLEGAL4res ILLEGAL4res; + +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_ILLEGAL = 10044, +}; +typedef enum nfs_opnum4 nfs_opnum4; + +struct nfs_argop4 { + nfs_opnum4 argop; + union { + ACCESS4args opaccess; + CLOSE4args opclose; + COMMIT4args opcommit; + CREATE4args opcreate; + DELEGPURGE4args opdelegpurge; + DELEGRETURN4args opdelegreturn; + GETATTR4args opgetattr; + LINK4args oplink; + LOCK4args oplock; + LOCKT4args oplockt; + LOCKU4args oplocku; + LOOKUP4args oplookup; + NVERIFY4args opnverify; + OPEN4args opopen; + OPENATTR4args opopenattr; + OPEN_CONFIRM4args opopen_confirm; + OPEN_DOWNGRADE4args opopen_downgrade; + PUTFH4args opputfh; + READ4args opread; + READDIR4args opreaddir; + REMOVE4args opremove; + RENAME4args oprename; + RENEW4args oprenew; + SETATTR4args opsetattr; + SETCLIENTID4args opsetclientid; + SETCLIENTID_CONFIRM4args opsetclientid_confirm; + VERIFY4args opverify; + WRITE4args opwrite; + RELEASE_LOCKOWNER4args oprelease_lockowner; + } nfs_argop4_u; +}; +typedef struct nfs_argop4 nfs_argop4; + +struct nfs_resop4 { + nfs_opnum4 resop; + union { + ACCESS4res opaccess; + CLOSE4res opclose; + COMMIT4res opcommit; + CREATE4res opcreate; + DELEGPURGE4res opdelegpurge; + DELEGRETURN4res opdelegreturn; + GETATTR4res opgetattr; + GETFH4res opgetfh; + LINK4res oplink; + LOCK4res oplock; + LOCKT4res oplockt; + LOCKU4res oplocku; + LOOKUP4res oplookup; + LOOKUPP4res oplookupp; + NVERIFY4res opnverify; + OPEN4res opopen; + OPENATTR4res opopenattr; + OPEN_CONFIRM4res opopen_confirm; + OPEN_DOWNGRADE4res opopen_downgrade; + PUTFH4res opputfh; + PUTPUBFH4res opputpubfh; + PUTROOTFH4res opputrootfh; + READ4res opread; + READDIR4res opreaddir; + READLINK4res opreadlink; + REMOVE4res opremove; + RENAME4res oprename; + RENEW4res oprenew; + RESTOREFH4res oprestorefh; + SAVEFH4res opsavefh; + SETATTR4res opsetattr; + SETCLIENTID4res opsetclientid; + SETCLIENTID_CONFIRM4res opsetclientid_confirm; + VERIFY4res opverify; + WRITE4res opwrite; + RELEASE_LOCKOWNER4res oprelease_lockowner; + ILLEGAL4res opillegal; + } nfs_resop4_u; +}; +typedef struct nfs_resop4 nfs_resop4; + +struct COMPOUND4args { + utf8str_cs tag; + uint32_t minorversion; + struct { + u_int argarray_len; + nfs_argop4 *argarray_val; + } argarray; +}; +typedef struct COMPOUND4args COMPOUND4args; + +struct COMPOUND4res { + nfsstat4 status; + utf8str_cs tag; + struct { + u_int resarray_len; + nfs_resop4 *resarray_val; + } resarray; +}; +typedef struct COMPOUND4res COMPOUND4res; + +struct CB_GETATTR4args { + nfs_fh4 fh; + bitmap4 attr_request; +}; +typedef struct CB_GETATTR4args CB_GETATTR4args; + +struct CB_GETATTR4resok { + fattr4 obj_attributes; +}; +typedef struct CB_GETATTR4resok CB_GETATTR4resok; + +struct CB_GETATTR4res { + nfsstat4 status; + union { + CB_GETATTR4resok resok4; + } CB_GETATTR4res_u; +}; +typedef struct CB_GETATTR4res CB_GETATTR4res; + +struct CB_RECALL4args { + stateid4 stateid; + uint32_t truncate; + nfs_fh4 fh; +}; +typedef struct CB_RECALL4args CB_RECALL4args; + +struct CB_RECALL4res { + nfsstat4 status; +}; +typedef struct CB_RECALL4res CB_RECALL4res; + +struct CB_ILLEGAL4res { + nfsstat4 status; +}; +typedef struct CB_ILLEGAL4res CB_ILLEGAL4res; + +enum nfs_cb_opnum4 { + OP_CB_GETATTR = 3, + OP_CB_RECALL = 4, + OP_CB_ILLEGAL = 10044, +}; +typedef enum nfs_cb_opnum4 nfs_cb_opnum4; + +struct nfs_cb_argop4 { + u_int argop; + union { + CB_GETATTR4args opcbgetattr; + CB_RECALL4args opcbrecall; + } nfs_cb_argop4_u; +}; +typedef struct nfs_cb_argop4 nfs_cb_argop4; + +struct nfs_cb_resop4 { + u_int resop; + union { + CB_GETATTR4res opcbgetattr; + CB_RECALL4res opcbrecall; + CB_ILLEGAL4res opcbillegal; + } nfs_cb_resop4_u; +}; +typedef struct nfs_cb_resop4 nfs_cb_resop4; + +struct CB_COMPOUND4args { + utf8str_cs tag; + uint32_t minorversion; + uint32_t callback_ident; + struct { + u_int argarray_len; + nfs_cb_argop4 *argarray_val; + } argarray; +}; +typedef struct CB_COMPOUND4args CB_COMPOUND4args; + +struct CB_COMPOUND4res { + nfsstat4 status; + utf8str_cs tag; + struct { + u_int resarray_len; + nfs_cb_resop4 *resarray_val; + } resarray; +}; +typedef struct CB_COMPOUND4res CB_COMPOUND4res; + +#define NFS4_PROGRAM 100003 +#define NFS_V4 4 + +#if defined(__STDC__) || defined(__cplusplus) +#define NFSPROC4_NULL 0 +extern void * nfsproc4_null_4(void *, void *); +extern void * nfsproc4_null_4_svc(void *, struct svc_req *); +#define NFSPROC4_COMPOUND 1 +extern COMPOUND4res * nfsproc4_compound_4(COMPOUND4args *, void *); +extern COMPOUND4res * nfsproc4_compound_4_svc(COMPOUND4args *, struct svc_req *); +extern int nfs4_program_4_freeresult (void *, zdrproc_t, caddr_t); + +#else /* K&R C */ +#define NFSPROC4_NULL 0 +extern void * nfsproc4_null_4(); +extern void * nfsproc4_null_4_svc(); +#define NFSPROC4_COMPOUND 1 +extern COMPOUND4res * nfsproc4_compound_4(); +extern COMPOUND4res * nfsproc4_compound_4_svc(); +extern int nfs4_program_4_freeresult (); +#endif /* K&R C */ + +#define NFS4_CALLBACK 0x40000000 +#define NFS_CB 1 + +#if defined(__STDC__) || defined(__cplusplus) +#define CB_NULL 0 +extern void * cb_null_1(void *, void *); +extern void * cb_null_1_svc(void *, struct svc_req *); +#define CB_COMPOUND 1 +extern CB_COMPOUND4res * cb_compound_1(CB_COMPOUND4args *, void *); +extern CB_COMPOUND4res * cb_compound_1_svc(CB_COMPOUND4args *, struct svc_req *); +extern int nfs4_callback_1_freeresult (void *, zdrproc_t, caddr_t); + +#else /* K&R C */ +#define CB_NULL 0 +extern void * cb_null_1(); +extern void * cb_null_1_svc(); +#define CB_COMPOUND 1 +extern CB_COMPOUND4res * cb_compound_1(); +extern CB_COMPOUND4res * cb_compound_1_svc(); +extern int nfs4_callback_1_freeresult (); +#endif /* K&R C */ + +/* the zdr functions */ + +#if defined(__STDC__) || defined(__cplusplus) +extern uint32_t zdr_nfs_ftype4 (ZDR *, nfs_ftype4*); +extern uint32_t zdr_nfsstat4 (ZDR *, nfsstat4*); +extern uint32_t zdr_bitmap4 (ZDR *, bitmap4*); +extern uint32_t zdr_offset4 (ZDR *, offset4*); +extern uint32_t zdr_count4 (ZDR *, count4*); +extern uint32_t zdr_length4 (ZDR *, length4*); +extern uint32_t zdr_clientid4 (ZDR *, clientid4*); +extern uint32_t zdr_seqid4 (ZDR *, seqid4*); +extern uint32_t zdr_utf8string (ZDR *, utf8string*); +extern uint32_t zdr_utf8str_cis (ZDR *, utf8str_cis*); +extern uint32_t zdr_utf8str_cs (ZDR *, utf8str_cs*); +extern uint32_t zdr_utf8str_mixed (ZDR *, utf8str_mixed*); +extern uint32_t zdr_component4 (ZDR *, component4*); +extern uint32_t zdr_pathname4 (ZDR *, pathname4*); +extern uint32_t zdr_nfs_lockid4 (ZDR *, nfs_lockid4*); +extern uint32_t zdr_nfs_cookie4 (ZDR *, nfs_cookie4*); +extern uint32_t zdr_linktext4 (ZDR *, linktext4*); +extern uint32_t zdr_sec_oid4 (ZDR *, sec_oid4*); +extern uint32_t zdr_qop4 (ZDR *, qop4*); +extern uint32_t zdr_mode4 (ZDR *, mode4*); +extern uint32_t zdr_changeid4 (ZDR *, changeid4*); +extern uint32_t zdr_verifier4 (ZDR *, verifier4); +extern uint32_t zdr_nfstime4 (ZDR *, nfstime4*); +extern uint32_t zdr_time_how4 (ZDR *, time_how4*); +extern uint32_t zdr_settime4 (ZDR *, settime4*); +extern uint32_t zdr_nfs_fh4 (ZDR *, nfs_fh4*); +extern uint32_t zdr_fsid4 (ZDR *, fsid4*); +extern uint32_t zdr_fs_location4 (ZDR *, fs_location4*); +extern uint32_t zdr_fs_locations4 (ZDR *, fs_locations4*); +extern uint32_t zdr_acetype4 (ZDR *, acetype4*); +extern uint32_t zdr_aceflag4 (ZDR *, aceflag4*); +extern uint32_t zdr_acemask4 (ZDR *, acemask4*); +extern uint32_t zdr_nfsace4 (ZDR *, nfsace4*); +extern uint32_t zdr_specdata4 (ZDR *, specdata4*); +extern uint32_t zdr_fattr4_supported_attrs (ZDR *, fattr4_supported_attrs*); +extern uint32_t zdr_fattr4_type (ZDR *, fattr4_type*); +extern uint32_t zdr_fattr4_fh_expire_type (ZDR *, fattr4_fh_expire_type*); +extern uint32_t zdr_fattr4_change (ZDR *, fattr4_change*); +extern uint32_t zdr_fattr4_size (ZDR *, fattr4_size*); +extern uint32_t zdr_fattr4_link_support (ZDR *, fattr4_link_support*); +extern uint32_t zdr_fattr4_symlink_support (ZDR *, fattr4_symlink_support*); +extern uint32_t zdr_fattr4_named_attr (ZDR *, fattr4_named_attr*); +extern uint32_t zdr_fattr4_fsid (ZDR *, fattr4_fsid*); +extern uint32_t zdr_fattr4_unique_handles (ZDR *, fattr4_unique_handles*); +extern uint32_t zdr_fattr4_lease_time (ZDR *, fattr4_lease_time*); +extern uint32_t zdr_fattr4_rdattr_error (ZDR *, fattr4_rdattr_error*); +extern uint32_t zdr_fattr4_acl (ZDR *, fattr4_acl*); +extern uint32_t zdr_fattr4_aclsupport (ZDR *, fattr4_aclsupport*); +extern uint32_t zdr_fattr4_archive (ZDR *, fattr4_archive*); +extern uint32_t zdr_fattr4_cansettime (ZDR *, fattr4_cansettime*); +extern uint32_t zdr_fattr4_case_insensitive (ZDR *, fattr4_case_insensitive*); +extern uint32_t zdr_fattr4_case_preserving (ZDR *, fattr4_case_preserving*); +extern uint32_t zdr_fattr4_chown_restricted (ZDR *, fattr4_chown_restricted*); +extern uint32_t zdr_fattr4_fileid (ZDR *, fattr4_fileid*); +extern uint32_t zdr_fattr4_files_avail (ZDR *, fattr4_files_avail*); +extern uint32_t zdr_fattr4_filehandle (ZDR *, fattr4_filehandle*); +extern uint32_t zdr_fattr4_files_free (ZDR *, fattr4_files_free*); +extern uint32_t zdr_fattr4_files_total (ZDR *, fattr4_files_total*); +extern uint32_t zdr_fattr4_fs_locations (ZDR *, fattr4_fs_locations*); +extern uint32_t zdr_fattr4_hidden (ZDR *, fattr4_hidden*); +extern uint32_t zdr_fattr4_homogeneous (ZDR *, fattr4_homogeneous*); +extern uint32_t zdr_fattr4_maxfilesize (ZDR *, fattr4_maxfilesize*); +extern uint32_t zdr_fattr4_maxlink (ZDR *, fattr4_maxlink*); +extern uint32_t zdr_fattr4_maxname (ZDR *, fattr4_maxname*); +extern uint32_t zdr_fattr4_maxread (ZDR *, fattr4_maxread*); +extern uint32_t zdr_fattr4_maxwrite (ZDR *, fattr4_maxwrite*); +extern uint32_t zdr_fattr4_mimetype (ZDR *, fattr4_mimetype*); +extern uint32_t zdr_fattr4_mode (ZDR *, fattr4_mode*); +extern uint32_t zdr_fattr4_mounted_on_fileid (ZDR *, fattr4_mounted_on_fileid*); +extern uint32_t zdr_fattr4_no_trunc (ZDR *, fattr4_no_trunc*); +extern uint32_t zdr_fattr4_numlinks (ZDR *, fattr4_numlinks*); +extern uint32_t zdr_fattr4_owner (ZDR *, fattr4_owner*); +extern uint32_t zdr_fattr4_owner_group (ZDR *, fattr4_owner_group*); +extern uint32_t zdr_fattr4_quota_avail_hard (ZDR *, fattr4_quota_avail_hard*); +extern uint32_t zdr_fattr4_quota_avail_soft (ZDR *, fattr4_quota_avail_soft*); +extern uint32_t zdr_fattr4_quota_used (ZDR *, fattr4_quota_used*); +extern uint32_t zdr_fattr4_rawdev (ZDR *, fattr4_rawdev*); +extern uint32_t zdr_fattr4_space_avail (ZDR *, fattr4_space_avail*); +extern uint32_t zdr_fattr4_space_free (ZDR *, fattr4_space_free*); +extern uint32_t zdr_fattr4_space_total (ZDR *, fattr4_space_total*); +extern uint32_t zdr_fattr4_space_used (ZDR *, fattr4_space_used*); +extern uint32_t zdr_fattr4_system (ZDR *, fattr4_system*); +extern uint32_t zdr_fattr4_time_access (ZDR *, fattr4_time_access*); +extern uint32_t zdr_fattr4_time_access_set (ZDR *, fattr4_time_access_set*); +extern uint32_t zdr_fattr4_time_backup (ZDR *, fattr4_time_backup*); +extern uint32_t zdr_fattr4_time_create (ZDR *, fattr4_time_create*); +extern uint32_t zdr_fattr4_time_delta (ZDR *, fattr4_time_delta*); +extern uint32_t zdr_fattr4_time_metadata (ZDR *, fattr4_time_metadata*); +extern uint32_t zdr_fattr4_time_modify (ZDR *, fattr4_time_modify*); +extern uint32_t zdr_fattr4_time_modify_set (ZDR *, fattr4_time_modify_set*); +extern uint32_t zdr_attrlist4 (ZDR *, attrlist4*); +extern uint32_t zdr_fattr4 (ZDR *, fattr4*); +extern uint32_t zdr_change_info4 (ZDR *, change_info4*); +extern uint32_t zdr_clientaddr4 (ZDR *, clientaddr4*); +extern uint32_t zdr_cb_client4 (ZDR *, cb_client4*); +extern uint32_t zdr_stateid4 (ZDR *, stateid4*); +extern uint32_t zdr_nfs_client_id4 (ZDR *, nfs_client_id4*); +extern uint32_t zdr_open_owner4 (ZDR *, open_owner4*); +extern uint32_t zdr_lock_owner4 (ZDR *, lock_owner4*); +extern uint32_t zdr_nfs_lock_type4 (ZDR *, nfs_lock_type4*); +extern uint32_t zdr_ACCESS4args (ZDR *, ACCESS4args*); +extern uint32_t zdr_ACCESS4resok (ZDR *, ACCESS4resok*); +extern uint32_t zdr_ACCESS4res (ZDR *, ACCESS4res*); +extern uint32_t zdr_CLOSE4args (ZDR *, CLOSE4args*); +extern uint32_t zdr_CLOSE4res (ZDR *, CLOSE4res*); +extern uint32_t zdr_COMMIT4args (ZDR *, COMMIT4args*); +extern uint32_t zdr_COMMIT4resok (ZDR *, COMMIT4resok*); +extern uint32_t zdr_COMMIT4res (ZDR *, COMMIT4res*); +extern uint32_t zdr_createtype4 (ZDR *, createtype4*); +extern uint32_t zdr_CREATE4args (ZDR *, CREATE4args*); +extern uint32_t zdr_CREATE4resok (ZDR *, CREATE4resok*); +extern uint32_t zdr_CREATE4res (ZDR *, CREATE4res*); +extern uint32_t zdr_DELEGPURGE4args (ZDR *, DELEGPURGE4args*); +extern uint32_t zdr_DELEGPURGE4res (ZDR *, DELEGPURGE4res*); +extern uint32_t zdr_DELEGRETURN4args (ZDR *, DELEGRETURN4args*); +extern uint32_t zdr_DELEGRETURN4res (ZDR *, DELEGRETURN4res*); +extern uint32_t zdr_GETATTR4args (ZDR *, GETATTR4args*); +extern uint32_t zdr_GETATTR4resok (ZDR *, GETATTR4resok*); +extern uint32_t zdr_GETATTR4res (ZDR *, GETATTR4res*); +extern uint32_t zdr_GETFH4resok (ZDR *, GETFH4resok*); +extern uint32_t zdr_GETFH4res (ZDR *, GETFH4res*); +extern uint32_t zdr_LINK4args (ZDR *, LINK4args*); +extern uint32_t zdr_LINK4resok (ZDR *, LINK4resok*); +extern uint32_t zdr_LINK4res (ZDR *, LINK4res*); +extern uint32_t zdr_open_to_lock_owner4 (ZDR *, open_to_lock_owner4*); +extern uint32_t zdr_exist_lock_owner4 (ZDR *, exist_lock_owner4*); +extern uint32_t zdr_locker4 (ZDR *, locker4*); +extern uint32_t zdr_LOCK4args (ZDR *, LOCK4args*); +extern uint32_t zdr_LOCK4denied (ZDR *, LOCK4denied*); +extern uint32_t zdr_LOCK4resok (ZDR *, LOCK4resok*); +extern uint32_t zdr_LOCK4res (ZDR *, LOCK4res*); +extern uint32_t zdr_LOCKT4args (ZDR *, LOCKT4args*); +extern uint32_t zdr_LOCKT4res (ZDR *, LOCKT4res*); +extern uint32_t zdr_LOCKU4args (ZDR *, LOCKU4args*); +extern uint32_t zdr_LOCKU4res (ZDR *, LOCKU4res*); +extern uint32_t zdr_LOOKUP4args (ZDR *, LOOKUP4args*); +extern uint32_t zdr_LOOKUP4res (ZDR *, LOOKUP4res*); +extern uint32_t zdr_LOOKUPP4res (ZDR *, LOOKUPP4res*); +extern uint32_t zdr_NVERIFY4args (ZDR *, NVERIFY4args*); +extern uint32_t zdr_NVERIFY4res (ZDR *, NVERIFY4res*); +extern uint32_t zdr_createmode4 (ZDR *, createmode4*); +extern uint32_t zdr_createhow4 (ZDR *, createhow4*); +extern uint32_t zdr_opentype4 (ZDR *, opentype4*); +extern uint32_t zdr_openflag4 (ZDR *, openflag4*); +extern uint32_t zdr_limit_by4 (ZDR *, limit_by4*); +extern uint32_t zdr_nfs_modified_limit4 (ZDR *, nfs_modified_limit4*); +extern uint32_t zdr_nfs_space_limit4 (ZDR *, nfs_space_limit4*); +extern uint32_t zdr_open_delegation_type4 (ZDR *, open_delegation_type4*); +extern uint32_t zdr_open_claim_type4 (ZDR *, open_claim_type4*); +extern uint32_t zdr_open_claim_delegate_cur4 (ZDR *, open_claim_delegate_cur4*); +extern uint32_t zdr_open_claim4 (ZDR *, open_claim4*); +extern uint32_t zdr_OPEN4args (ZDR *, OPEN4args*); +extern uint32_t zdr_open_read_delegation4 (ZDR *, open_read_delegation4*); +extern uint32_t zdr_open_write_delegation4 (ZDR *, open_write_delegation4*); +extern uint32_t zdr_open_delegation4 (ZDR *, open_delegation4*); +extern uint32_t zdr_OPEN4resok (ZDR *, OPEN4resok*); +extern uint32_t zdr_OPEN4res (ZDR *, OPEN4res*); +extern uint32_t zdr_OPENATTR4args (ZDR *, OPENATTR4args*); +extern uint32_t zdr_OPENATTR4res (ZDR *, OPENATTR4res*); +extern uint32_t zdr_OPEN_CONFIRM4args (ZDR *, OPEN_CONFIRM4args*); +extern uint32_t zdr_OPEN_CONFIRM4resok (ZDR *, OPEN_CONFIRM4resok*); +extern uint32_t zdr_OPEN_CONFIRM4res (ZDR *, OPEN_CONFIRM4res*); +extern uint32_t zdr_OPEN_DOWNGRADE4args (ZDR *, OPEN_DOWNGRADE4args*); +extern uint32_t zdr_OPEN_DOWNGRADE4resok (ZDR *, OPEN_DOWNGRADE4resok*); +extern uint32_t zdr_OPEN_DOWNGRADE4res (ZDR *, OPEN_DOWNGRADE4res*); +extern uint32_t zdr_PUTFH4args (ZDR *, PUTFH4args*); +extern uint32_t zdr_PUTFH4res (ZDR *, PUTFH4res*); +extern uint32_t zdr_PUTPUBFH4res (ZDR *, PUTPUBFH4res*); +extern uint32_t zdr_PUTROOTFH4res (ZDR *, PUTROOTFH4res*); +extern uint32_t zdr_READ4args (ZDR *, READ4args*); +extern uint32_t zdr_READ4resok (ZDR *, READ4resok*); +extern uint32_t zdr_READ4res (ZDR *, READ4res*); +extern uint32_t zdr_READDIR4args (ZDR *, READDIR4args*); +extern uint32_t zdr_entry4 (ZDR *, entry4*); +extern uint32_t zdr_dirlist4 (ZDR *, dirlist4*); +extern uint32_t zdr_READDIR4resok (ZDR *, READDIR4resok*); +extern uint32_t zdr_READDIR4res (ZDR *, READDIR4res*); +extern uint32_t zdr_READLINK4resok (ZDR *, READLINK4resok*); +extern uint32_t zdr_READLINK4res (ZDR *, READLINK4res*); +extern uint32_t zdr_REMOVE4args (ZDR *, REMOVE4args*); +extern uint32_t zdr_REMOVE4resok (ZDR *, REMOVE4resok*); +extern uint32_t zdr_REMOVE4res (ZDR *, REMOVE4res*); +extern uint32_t zdr_RENAME4args (ZDR *, RENAME4args*); +extern uint32_t zdr_RENAME4resok (ZDR *, RENAME4resok*); +extern uint32_t zdr_RENAME4res (ZDR *, RENAME4res*); +extern uint32_t zdr_RENEW4args (ZDR *, RENEW4args*); +extern uint32_t zdr_RENEW4res (ZDR *, RENEW4res*); +extern uint32_t zdr_RESTOREFH4res (ZDR *, RESTOREFH4res*); +extern uint32_t zdr_SAVEFH4res (ZDR *, SAVEFH4res*); +extern uint32_t zdr_SETATTR4args (ZDR *, SETATTR4args*); +extern uint32_t zdr_SETATTR4res (ZDR *, SETATTR4res*); +extern uint32_t zdr_SETCLIENTID4args (ZDR *, SETCLIENTID4args*); +extern uint32_t zdr_SETCLIENTID4resok (ZDR *, SETCLIENTID4resok*); +extern uint32_t zdr_SETCLIENTID4res (ZDR *, SETCLIENTID4res*); +extern uint32_t zdr_SETCLIENTID_CONFIRM4args (ZDR *, SETCLIENTID_CONFIRM4args*); +extern uint32_t zdr_SETCLIENTID_CONFIRM4res (ZDR *, SETCLIENTID_CONFIRM4res*); +extern uint32_t zdr_VERIFY4args (ZDR *, VERIFY4args*); +extern uint32_t zdr_VERIFY4res (ZDR *, VERIFY4res*); +extern uint32_t zdr_stable_how4 (ZDR *, stable_how4*); +extern uint32_t zdr_WRITE4args (ZDR *, WRITE4args*); +extern uint32_t zdr_WRITE4resok (ZDR *, WRITE4resok*); +extern uint32_t zdr_WRITE4res (ZDR *, WRITE4res*); +extern uint32_t zdr_RELEASE_LOCKOWNER4args (ZDR *, RELEASE_LOCKOWNER4args*); +extern uint32_t zdr_RELEASE_LOCKOWNER4res (ZDR *, RELEASE_LOCKOWNER4res*); +extern uint32_t zdr_ILLEGAL4res (ZDR *, ILLEGAL4res*); +extern uint32_t zdr_nfs_opnum4 (ZDR *, nfs_opnum4*); +extern uint32_t zdr_nfs_argop4 (ZDR *, nfs_argop4*); +extern uint32_t zdr_nfs_resop4 (ZDR *, nfs_resop4*); +extern uint32_t zdr_COMPOUND4args (ZDR *, COMPOUND4args*); +extern uint32_t zdr_COMPOUND4res (ZDR *, COMPOUND4res*); +extern uint32_t zdr_CB_GETATTR4args (ZDR *, CB_GETATTR4args*); +extern uint32_t zdr_CB_GETATTR4resok (ZDR *, CB_GETATTR4resok*); +extern uint32_t zdr_CB_GETATTR4res (ZDR *, CB_GETATTR4res*); +extern uint32_t zdr_CB_RECALL4args (ZDR *, CB_RECALL4args*); +extern uint32_t zdr_CB_RECALL4res (ZDR *, CB_RECALL4res*); +extern uint32_t zdr_CB_ILLEGAL4res (ZDR *, CB_ILLEGAL4res*); +extern uint32_t zdr_nfs_cb_opnum4 (ZDR *, nfs_cb_opnum4*); +extern uint32_t zdr_nfs_cb_argop4 (ZDR *, nfs_cb_argop4*); +extern uint32_t zdr_nfs_cb_resop4 (ZDR *, nfs_cb_resop4*); +extern uint32_t zdr_CB_COMPOUND4args (ZDR *, CB_COMPOUND4args*); +extern uint32_t zdr_CB_COMPOUND4res (ZDR *, CB_COMPOUND4res*); + +#else /* K&R C */ +extern uint32_t zdr_nfs_ftype4 (); +extern uint32_t zdr_nfsstat4 (); +extern uint32_t zdr_bitmap4 (); +extern uint32_t zdr_offset4 (); +extern uint32_t zdr_count4 (); +extern uint32_t zdr_length4 (); +extern uint32_t zdr_clientid4 (); +extern uint32_t zdr_seqid4 (); +extern uint32_t zdr_utf8string (); +extern uint32_t zdr_utf8str_cis (); +extern uint32_t zdr_utf8str_cs (); +extern uint32_t zdr_utf8str_mixed (); +extern uint32_t zdr_component4 (); +extern uint32_t zdr_pathname4 (); +extern uint32_t zdr_nfs_lockid4 (); +extern uint32_t zdr_nfs_cookie4 (); +extern uint32_t zdr_linktext4 (); +extern uint32_t zdr_sec_oid4 (); +extern uint32_t zdr_qop4 (); +extern uint32_t zdr_mode4 (); +extern uint32_t zdr_changeid4 (); +extern uint32_t zdr_verifier4 (); +extern uint32_t zdr_nfstime4 (); +extern uint32_t zdr_time_how4 (); +extern uint32_t zdr_settime4 (); +extern uint32_t zdr_nfs_fh4 (); +extern uint32_t zdr_fsid4 (); +extern uint32_t zdr_fs_location4 (); +extern uint32_t zdr_fs_locations4 (); +extern uint32_t zdr_acetype4 (); +extern uint32_t zdr_aceflag4 (); +extern uint32_t zdr_acemask4 (); +extern uint32_t zdr_nfsace4 (); +extern uint32_t zdr_specdata4 (); +extern uint32_t zdr_fattr4_supported_attrs (); +extern uint32_t zdr_fattr4_type (); +extern uint32_t zdr_fattr4_fh_expire_type (); +extern uint32_t zdr_fattr4_change (); +extern uint32_t zdr_fattr4_size (); +extern uint32_t zdr_fattr4_link_support (); +extern uint32_t zdr_fattr4_symlink_support (); +extern uint32_t zdr_fattr4_named_attr (); +extern uint32_t zdr_fattr4_fsid (); +extern uint32_t zdr_fattr4_unique_handles (); +extern uint32_t zdr_fattr4_lease_time (); +extern uint32_t zdr_fattr4_rdattr_error (); +extern uint32_t zdr_fattr4_acl (); +extern uint32_t zdr_fattr4_aclsupport (); +extern uint32_t zdr_fattr4_archive (); +extern uint32_t zdr_fattr4_cansettime (); +extern uint32_t zdr_fattr4_case_insensitive (); +extern uint32_t zdr_fattr4_case_preserving (); +extern uint32_t zdr_fattr4_chown_restricted (); +extern uint32_t zdr_fattr4_fileid (); +extern uint32_t zdr_fattr4_files_avail (); +extern uint32_t zdr_fattr4_filehandle (); +extern uint32_t zdr_fattr4_files_free (); +extern uint32_t zdr_fattr4_files_total (); +extern uint32_t zdr_fattr4_fs_locations (); +extern uint32_t zdr_fattr4_hidden (); +extern uint32_t zdr_fattr4_homogeneous (); +extern uint32_t zdr_fattr4_maxfilesize (); +extern uint32_t zdr_fattr4_maxlink (); +extern uint32_t zdr_fattr4_maxname (); +extern uint32_t zdr_fattr4_maxread (); +extern uint32_t zdr_fattr4_maxwrite (); +extern uint32_t zdr_fattr4_mimetype (); +extern uint32_t zdr_fattr4_mode (); +extern uint32_t zdr_fattr4_mounted_on_fileid (); +extern uint32_t zdr_fattr4_no_trunc (); +extern uint32_t zdr_fattr4_numlinks (); +extern uint32_t zdr_fattr4_owner (); +extern uint32_t zdr_fattr4_owner_group (); +extern uint32_t zdr_fattr4_quota_avail_hard (); +extern uint32_t zdr_fattr4_quota_avail_soft (); +extern uint32_t zdr_fattr4_quota_used (); +extern uint32_t zdr_fattr4_rawdev (); +extern uint32_t zdr_fattr4_space_avail (); +extern uint32_t zdr_fattr4_space_free (); +extern uint32_t zdr_fattr4_space_total (); +extern uint32_t zdr_fattr4_space_used (); +extern uint32_t zdr_fattr4_system (); +extern uint32_t zdr_fattr4_time_access (); +extern uint32_t zdr_fattr4_time_access_set (); +extern uint32_t zdr_fattr4_time_backup (); +extern uint32_t zdr_fattr4_time_create (); +extern uint32_t zdr_fattr4_time_delta (); +extern uint32_t zdr_fattr4_time_metadata (); +extern uint32_t zdr_fattr4_time_modify (); +extern uint32_t zdr_fattr4_time_modify_set (); +extern uint32_t zdr_attrlist4 (); +extern uint32_t zdr_fattr4 (); +extern uint32_t zdr_change_info4 (); +extern uint32_t zdr_clientaddr4 (); +extern uint32_t zdr_cb_client4 (); +extern uint32_t zdr_stateid4 (); +extern uint32_t zdr_nfs_client_id4 (); +extern uint32_t zdr_open_owner4 (); +extern uint32_t zdr_lock_owner4 (); +extern uint32_t zdr_nfs_lock_type4 (); +extern uint32_t zdr_ACCESS4args (); +extern uint32_t zdr_ACCESS4resok (); +extern uint32_t zdr_ACCESS4res (); +extern uint32_t zdr_CLOSE4args (); +extern uint32_t zdr_CLOSE4res (); +extern uint32_t zdr_COMMIT4args (); +extern uint32_t zdr_COMMIT4resok (); +extern uint32_t zdr_COMMIT4res (); +extern uint32_t zdr_createtype4 (); +extern uint32_t zdr_CREATE4args (); +extern uint32_t zdr_CREATE4resok (); +extern uint32_t zdr_CREATE4res (); +extern uint32_t zdr_DELEGPURGE4args (); +extern uint32_t zdr_DELEGPURGE4res (); +extern uint32_t zdr_DELEGRETURN4args (); +extern uint32_t zdr_DELEGRETURN4res (); +extern uint32_t zdr_GETATTR4args (); +extern uint32_t zdr_GETATTR4resok (); +extern uint32_t zdr_GETATTR4res (); +extern uint32_t zdr_GETFH4resok (); +extern uint32_t zdr_GETFH4res (); +extern uint32_t zdr_LINK4args (); +extern uint32_t zdr_LINK4resok (); +extern uint32_t zdr_LINK4res (); +extern uint32_t zdr_open_to_lock_owner4 (); +extern uint32_t zdr_exist_lock_owner4 (); +extern uint32_t zdr_locker4 (); +extern uint32_t zdr_LOCK4args (); +extern uint32_t zdr_LOCK4denied (); +extern uint32_t zdr_LOCK4resok (); +extern uint32_t zdr_LOCK4res (); +extern uint32_t zdr_LOCKT4args (); +extern uint32_t zdr_LOCKT4res (); +extern uint32_t zdr_LOCKU4args (); +extern uint32_t zdr_LOCKU4res (); +extern uint32_t zdr_LOOKUP4args (); +extern uint32_t zdr_LOOKUP4res (); +extern uint32_t zdr_LOOKUPP4res (); +extern uint32_t zdr_NVERIFY4args (); +extern uint32_t zdr_NVERIFY4res (); +extern uint32_t zdr_createmode4 (); +extern uint32_t zdr_createhow4 (); +extern uint32_t zdr_opentype4 (); +extern uint32_t zdr_openflag4 (); +extern uint32_t zdr_limit_by4 (); +extern uint32_t zdr_nfs_modified_limit4 (); +extern uint32_t zdr_nfs_space_limit4 (); +extern uint32_t zdr_open_delegation_type4 (); +extern uint32_t zdr_open_claim_type4 (); +extern uint32_t zdr_open_claim_delegate_cur4 (); +extern uint32_t zdr_open_claim4 (); +extern uint32_t zdr_OPEN4args (); +extern uint32_t zdr_open_read_delegation4 (); +extern uint32_t zdr_open_write_delegation4 (); +extern uint32_t zdr_open_delegation4 (); +extern uint32_t zdr_OPEN4resok (); +extern uint32_t zdr_OPEN4res (); +extern uint32_t zdr_OPENATTR4args (); +extern uint32_t zdr_OPENATTR4res (); +extern uint32_t zdr_OPEN_CONFIRM4args (); +extern uint32_t zdr_OPEN_CONFIRM4resok (); +extern uint32_t zdr_OPEN_CONFIRM4res (); +extern uint32_t zdr_OPEN_DOWNGRADE4args (); +extern uint32_t zdr_OPEN_DOWNGRADE4resok (); +extern uint32_t zdr_OPEN_DOWNGRADE4res (); +extern uint32_t zdr_PUTFH4args (); +extern uint32_t zdr_PUTFH4res (); +extern uint32_t zdr_PUTPUBFH4res (); +extern uint32_t zdr_PUTROOTFH4res (); +extern uint32_t zdr_READ4args (); +extern uint32_t zdr_READ4resok (); +extern uint32_t zdr_READ4res (); +extern uint32_t zdr_READDIR4args (); +extern uint32_t zdr_entry4 (); +extern uint32_t zdr_dirlist4 (); +extern uint32_t zdr_READDIR4resok (); +extern uint32_t zdr_READDIR4res (); +extern uint32_t zdr_READLINK4resok (); +extern uint32_t zdr_READLINK4res (); +extern uint32_t zdr_REMOVE4args (); +extern uint32_t zdr_REMOVE4resok (); +extern uint32_t zdr_REMOVE4res (); +extern uint32_t zdr_RENAME4args (); +extern uint32_t zdr_RENAME4resok (); +extern uint32_t zdr_RENAME4res (); +extern uint32_t zdr_RENEW4args (); +extern uint32_t zdr_RENEW4res (); +extern uint32_t zdr_RESTOREFH4res (); +extern uint32_t zdr_SAVEFH4res (); +extern uint32_t zdr_SETATTR4args (); +extern uint32_t zdr_SETATTR4res (); +extern uint32_t zdr_SETCLIENTID4args (); +extern uint32_t zdr_SETCLIENTID4resok (); +extern uint32_t zdr_SETCLIENTID4res (); +extern uint32_t zdr_SETCLIENTID_CONFIRM4args (); +extern uint32_t zdr_SETCLIENTID_CONFIRM4res (); +extern uint32_t zdr_VERIFY4args (); +extern uint32_t zdr_VERIFY4res (); +extern uint32_t zdr_stable_how4 (); +extern uint32_t zdr_WRITE4args (); +extern uint32_t zdr_WRITE4resok (); +extern uint32_t zdr_WRITE4res (); +extern uint32_t zdr_RELEASE_LOCKOWNER4args (); +extern uint32_t zdr_RELEASE_LOCKOWNER4res (); +extern uint32_t zdr_ILLEGAL4res (); +extern uint32_t zdr_nfs_opnum4 (); +extern uint32_t zdr_nfs_argop4 (); +extern uint32_t zdr_nfs_resop4 (); +extern uint32_t zdr_COMPOUND4args (); +extern uint32_t zdr_COMPOUND4res (); +extern uint32_t zdr_CB_GETATTR4args (); +extern uint32_t zdr_CB_GETATTR4resok (); +extern uint32_t zdr_CB_GETATTR4res (); +extern uint32_t zdr_CB_RECALL4args (); +extern uint32_t zdr_CB_RECALL4res (); +extern uint32_t zdr_CB_ILLEGAL4res (); +extern uint32_t zdr_nfs_cb_opnum4 (); +extern uint32_t zdr_nfs_cb_argop4 (); +extern uint32_t zdr_nfs_cb_resop4 (); +extern uint32_t zdr_CB_COMPOUND4args (); +extern uint32_t zdr_CB_COMPOUND4res (); + +#endif /* K&R C */ + +#ifdef __cplusplus +} +#endif + +#endif /* !_NFS4_H_RPCGEN */ diff --git a/nfs4/nfs4.c b/nfs4/nfs4.c new file mode 100644 index 0000000..f7d5816 --- /dev/null +++ b/nfs4/nfs4.c @@ -0,0 +1,221 @@ +/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ +/* + Copyright (C) 2016 by Ronnie Sahlberg + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, see . +*/ + +#ifdef WIN32 +#include "win32_compat.h" +#else +#include +#endif/*WIN32*/ + +#include +#include +#include +#include "libnfs-zdr.h" +#include "libnfs.h" +#include "libnfs-raw.h" +#include "libnfs-private.h" +#include "libnfs-raw-nfs4.h" + +char *nfsstat4_to_str(int error) +{ + switch (error) { + case NFS4_OK: return "NFS4_OK"; break; + case NFS4ERR_PERM: return "NFS4ERR_PERM"; break; + case NFS4ERR_NOENT: return "NFS4ERR_NOENT"; break; + case NFS4ERR_IO: return "NFS4ERR_IO"; break; + case NFS4ERR_NXIO: return "NFS4ERR_NXIO"; break; + case NFS4ERR_ACCESS: return "NFS4ERR_ACCESS"; break; + case NFS4ERR_EXIST: return "NFS4ERR_EXIST"; break; + case NFS4ERR_XDEV: return "NFS4ERR_XDEV"; break; + case NFS4ERR_NOTDIR: return "NFS4ERR_NOTDIR"; break; + case NFS4ERR_ISDIR: return "NFS4ERR_ISDIR"; break; + case NFS4ERR_INVAL: return "NFS4ERR_INVAL"; break; + case NFS4ERR_FBIG: return "NFS4ERR_FBIG"; break; + case NFS4ERR_NOSPC: return "NFS4ERR_NOSPC"; break; + case NFS4ERR_ROFS: return"NFS4ERR_ROFS"; break; + case NFS4ERR_MLINK: return "NFS4ERR_MLINK"; break; + case NFS4ERR_NAMETOOLONG: return "NFS4ERR_NAMETOOLONG"; break; + case NFS4ERR_NOTEMPTY: return "NFS4ERR_NOTEMPTY"; break; + case NFS4ERR_DQUOT: return "NFS4ERR_DQUOT"; break; + case NFS4ERR_STALE: return "NFS4ERR_STALE"; break; + case NFS4ERR_BADHANDLE: return "NFS4ERR_BADHANDLE"; break; + case NFS4ERR_BAD_COOKIE: return "NFS4ERR_BAD_COOKIE"; break; + case NFS4ERR_NOTSUPP: return "NFS4ERR_NOTSUPP"; break; + case NFS4ERR_TOOSMALL: return "NFS4ERR_TOOSMALL"; break; + case NFS4ERR_SERVERFAULT: return "NFS4ERR_SERVERFAULT"; break; + case NFS4ERR_BADTYPE: return "NFS4ERR_BADTYPE"; break; + case NFS4ERR_DELAY: return "NFS4ERR_DELAY"; break; + case NFS4ERR_SAME: return "NFS4ERR_SAME"; break; + case NFS4ERR_DENIED: return "NFS4ERR_DENIED"; break; + case NFS4ERR_EXPIRED: return "NFS4ERR_EXPIRED"; break; + case NFS4ERR_LOCKED: return "NFS4ERR_LOCKED"; break; + case NFS4ERR_GRACE: return "NFS4ERR_GRACE"; break; + case NFS4ERR_FHEXPIRED: return "NFS4ERR_FHEXPIRED"; break; + case NFS4ERR_SHARE_DENIED: return "NFS4ERR_SHARE_DENIED"; break; + case NFS4ERR_WRONGSEC: return "NFS4ERR_WRONGSEC"; break; + case NFS4ERR_CLID_INUSE: return "NFS4ERR_CLID_INUSE"; break; + case NFS4ERR_RESOURCE: return "NFS4ERR_RESOURCE"; break; + case NFS4ERR_MOVED: return "NFS4ERR_MOVED"; break; + case NFS4ERR_NOFILEHANDLE: return "NFS4ERR_NOFILEHANDLE"; break; + case NFS4ERR_MINOR_VERS_MISMATCH: return "NFS4ERR_MINOR_VERS_MISMATCH"; break; + case NFS4ERR_STALE_CLIENTID: return "NFS4ERR_STALE_CLIENTID"; break; + case NFS4ERR_STALE_STATEID: return "NFS4ERR_STALE_STATEID"; break; + case NFS4ERR_OLD_STATEID: return "NFS4ERR_OLD_STATEID"; break; + case NFS4ERR_BAD_STATEID: return "NFS4ERR_BAD_STATEID"; break; + case NFS4ERR_BAD_SEQID: return "NFS4ERR_BAD_SEQID"; break; + case NFS4ERR_NOT_SAME: return "NFS4ERR_NOT_SAME"; break; + case NFS4ERR_LOCK_RANGE: return "NFS4ERR_LOCK_RANGE"; break; + case NFS4ERR_SYMLINK: return "NFS4ERR_SYMLINK"; break; + case NFS4ERR_RESTOREFH: return "NFS4ERR_RESTOREFH"; break; + case NFS4ERR_LEASE_MOVED: return "NFS4ERR_LEASE_MOVED"; break; + case NFS4ERR_ATTRNOTSUPP: return "NFS4ERR_ATTRNOTSUPP"; break; + case NFS4ERR_NO_GRACE: return "NFS4ERR_NO_GRACE"; break; + case NFS4ERR_RECLAIM_BAD: return "NFS4ERR_RECLAIM_BAD"; break; + case NFS4ERR_RECLAIM_CONFLICT: return "NFS4ERR_RECLAIM_CONFLICT"; break; + case NFS4ERR_BADZDR: return "NFS4ERR_BADZDR"; break; + case NFS4ERR_LOCKS_HELD: return "NFS4ERR_LOCKS_HELD"; break; + case NFS4ERR_OPENMODE: return "NFS4ERR_OPENMODE"; break; + case NFS4ERR_BADOWNER: return "NFS4ERR_BADOWNER"; break; + case NFS4ERR_BADCHAR: return "NFS4ERR_BADCHAR"; break; + case NFS4ERR_BADNAME: return "NFS4ERR_BADNAME"; break; + case NFS4ERR_BAD_RANGE: return "NFS4ERR_BAD_RANGE"; break; + case NFS4ERR_LOCK_NOTSUPP: return "NFS4ERR_LOCK_NOTSUPP"; break; + case NFS4ERR_OP_ILLEGAL: return "NFS4ERR_OP_ILLEGAL"; break; + case NFS4ERR_DEADLOCK: return "NFS4ERR_DEADLOCK"; break; + case NFS4ERR_FILE_OPEN: return "NFS4ERR_FILE_OPEN"; break; + case NFS4ERR_ADMIN_REVOKED: return "NFS4ERR_ADMIN_REVOKED"; break; + case NFS4ERR_CB_PATH_DOWN: return "NFS4ERR_CB_PATH_DOWN"; break; + }; + return "unknown nfsv4 error"; +} + +int nfsstat4_to_errno(int error) +{ + switch (error) { + case NFS4_OK: return 0; + case NFS4ERR_PERM: return -EPERM; + case NFS4ERR_NOENT: return -ENOENT ; + case NFS4ERR_IO: return -EIO; + case NFS4ERR_NXIO: return -ENXIO; + case NFS4ERR_ACCESS: return -EACCES ; + case NFS4ERR_EXIST: return -EEXIST; + case NFS4ERR_XDEV: return -EXDEV; + case NFS4ERR_NOTDIR: return -ENOTDIR ; + case NFS4ERR_ISDIR: return -EISDIR ; + case NFS4ERR_INVAL: return -EINVAL; + case NFS4ERR_FBIG: return -EFBIG; + case NFS4ERR_NOSPC: return -ENOSPC; + case NFS4ERR_ROFS: return -EROFS; + case NFS4ERR_MLINK: return -EMLINK; + case NFS4ERR_NAMETOOLONG: return -ENAMETOOLONG; + case NFS4ERR_NOTEMPTY: return -ENOTEMPTY; + case NFS4ERR_DQUOT: return -ERANGE; + case NFS4ERR_STALE: return -EIO; + case NFS4ERR_BADHANDLE: return -EINVAL; + case NFS4ERR_BAD_COOKIE: return -EINVAL; + case NFS4ERR_NOTSUPP: return -EINVAL; + case NFS4ERR_TOOSMALL: return -EIO; + case NFS4ERR_SERVERFAULT: return -EIO; + case NFS4ERR_BADTYPE: return -EINVAL; + case NFS4ERR_DELAY: return -EIO; + case NFS4ERR_SAME: return -EIO; + case NFS4ERR_DENIED: return -EIO; + case NFS4ERR_EXPIRED: return -EIO; + case NFS4ERR_LOCKED: return -EIO; + case NFS4ERR_GRACE: return -EIO; + case NFS4ERR_FHEXPIRED: return -EIO; + case NFS4ERR_SHARE_DENIED: return -EIO; + case NFS4ERR_WRONGSEC: return -EIO; + case NFS4ERR_CLID_INUSE: return -EIO; + case NFS4ERR_RESOURCE: return -EIO; + case NFS4ERR_MOVED: return -EIO; + case NFS4ERR_NOFILEHANDLE: return -EIO; + case NFS4ERR_MINOR_VERS_MISMATCH: return -EIO; + case NFS4ERR_STALE_CLIENTID: return -EIO; + case NFS4ERR_STALE_STATEID: return -EIO; + case NFS4ERR_OLD_STATEID: return -EIO; + case NFS4ERR_BAD_STATEID: return -EINVAL; + case NFS4ERR_BAD_SEQID: return -EINVAL; + case NFS4ERR_NOT_SAME: return -EIO; + case NFS4ERR_LOCK_RANGE: return -EIO; + case NFS4ERR_SYMLINK: return -EIO; + case NFS4ERR_RESTOREFH: return -EIO; + case NFS4ERR_ATTRNOTSUPP: return -EINVAL; + case NFS4ERR_NO_GRACE: return -EIO; + case NFS4ERR_RECLAIM_BAD: return -EIO; + case NFS4ERR_RECLAIM_CONFLICT: return -EIO; + case NFS4ERR_BADZDR: return -EINVAL; + case NFS4ERR_LOCKS_HELD: return -EIO; + case NFS4ERR_OPENMODE: return -EIO; + case NFS4ERR_BADOWNER: return -EINVAL; + case NFS4ERR_BADCHAR: return -EINVAL; + case NFS4ERR_BADNAME: return -EINVAL; + case NFS4ERR_BAD_RANGE: return -EINVAL; + case NFS4ERR_LOCK_NOTSUPP: return -EINVAL; + case NFS4ERR_OP_ILLEGAL: return -EIO; + case NFS4ERR_DEADLOCK: return -EIO; + case NFS4ERR_FILE_OPEN: return -EIO; + case NFS4ERR_ADMIN_REVOKED: return -EIO; + case NFS4ERR_CB_PATH_DOWN: return -EIO; + }; + return -ERANGE; +} + +int rpc_nfs4_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data) +{ + struct rpc_pdu *pdu; + + pdu = rpc_allocate_pdu(rpc, NFS4_PROGRAM, NFS_V4, NFSPROC4_NULL, cb, private_data, (zdrproc_t)zdr_void, 0); + if (pdu == NULL) { + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS4/NULL call"); + return -1; + } + + if (rpc_queue_pdu(rpc, pdu) != 0) { + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS4/NULL call"); + rpc_free_pdu(rpc, pdu); + return -2; + } + + return 0; +} + +int rpc_nfs4_compound_async(struct rpc_context *rpc, rpc_cb cb, struct COMPOUND4args *args, void *private_data) +{ + struct rpc_pdu *pdu; + + pdu = rpc_allocate_pdu(rpc, NFS4_PROGRAM, NFS_V4, NFSPROC4_COMPOUND, cb, private_data, (zdrproc_t)zdr_COMPOUND4res, sizeof(COMPOUND4res)); + if (pdu == NULL) { + rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for NFS4/COMPOUND call"); + return -1; + } + + if (zdr_COMPOUND4args(&pdu->zdr, args) == 0) { + rpc_set_error(rpc, "ZDR error: Failed to encode COMPOUND4args"); + rpc_free_pdu(rpc, pdu); + return -2; + } + + if (rpc_queue_pdu(rpc, pdu) != 0) { + rpc_set_error(rpc, "Out of memory. Failed to queue pdu for NFS4/COMPOUND4 call"); + rpc_free_pdu(rpc, pdu); + return -3; + } + + return 0; +} diff --git a/nfs4/nfs4.x b/nfs4/nfs4.x new file mode 100644 index 0000000..9560e89 --- /dev/null +++ b/nfs4/nfs4.x @@ -0,0 +1,1668 @@ +/* -*- mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil; -*- */ +/* + * The definitions in this file are based on RFC3530. + */ + +/* RFC3530 contains the following copyright statement: + + + Copyright (C) The Internet Society (2003). All Rights Reserved. + + This document and translations of it may be copied and furnished to + others, and derivative works that comment on or otherwise explain it + or assist in its implementation may be prepared, copied, published + and distributed, in whole or in part, without restriction of any + kind, provided that the above copyright notice and this paragraph are + included on all such copies and derivative works. However, this + document itself may not be modified in any way, such as by removing + the copyright notice or references to the Internet Society or other + Internet organizations, except as needed for the purpose of + developing Internet standards in which case the procedures for + copyrights defined in the Internet Standards process must be + followed, or as required to translate it into languages other than + English. + + The limited permissions granted above are perpetual and will not be + revoked by the Internet Society or its successors or assigns. + + This document and the information contained herein is provided on an + "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING + TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING + BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION + HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF + MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. +*/ + +/* + * 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; + +/* + * 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 */ +}; + +/* + * 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 seqid4; +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]; + +/* + * 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 access handle + */ +typedef opaque nfs_fh4; + +/* + * 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; +}; + +struct open_owner4 { + clientid4 clientid; + opaque owner; +}; + +struct lock_owner4 { + clientid4 clientid; + opaque owner; +}; + +enum nfs_lock_type4 { + READ_LT = 1, + WRITE_LT = 2, + READW_LT = 3, /* blocking read */ + WRITEW_LT = 4 /* blocking write */ +}; + +/* + * 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 +}; + +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; +}; + +/* + * 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; +}; + +#if 0 +/* + * SECINFO: Obtain Available Security Mechanisms + */ +struct SECINFO4args { + /* CURRENT_FH: directory */ + component4 name; +}; + +/* + + * 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; +}; +#endif + +/* + * 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; +}; + +/* + * 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_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; +#if 0 + case OP_SECINFO: SECINFO4args opsecinfo; +#endif + 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; + case OP_RENAME: RENAME4res oprename; + case OP_RENEW: RENEW4res oprenew; + case OP_RESTOREFH: RESTOREFH4res oprestorefh; + case OP_SAVEFH: SAVEFH4res opsavefh; +#if 0 + case OP_SECINFO: SECINFO4res opsecinfo; +#endif + 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; + + + +/* + * 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;