Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * XDR support for nfsd |
| 3 | * |
| 4 | * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de> |
| 5 | */ |
| 6 | |
Al Viro | 3dadecc | 2013-01-24 02:18:08 -0500 | [diff] [blame] | 7 | #include "vfs.h" |
Boaz Harrosh | 9a74af2 | 2009-12-03 20:30:56 +0200 | [diff] [blame] | 8 | #include "xdr.h" |
J. Bruce Fields | 2e8138a | 2007-11-15 17:05:43 -0500 | [diff] [blame] | 9 | #include "auth.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | |
| 11 | #define NFSDDBG_FACILITY NFSDDBG_XDR |
| 12 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | /* |
| 14 | * Mapping of S_IF* types to NFS file types |
| 15 | */ |
| 16 | static u32 nfs_ftypes[] = { |
| 17 | NFNON, NFCHR, NFCHR, NFBAD, |
| 18 | NFDIR, NFBAD, NFBLK, NFBAD, |
| 19 | NFREG, NFBAD, NFLNK, NFBAD, |
| 20 | NFSOCK, NFBAD, NFLNK, NFBAD, |
| 21 | }; |
| 22 | |
| 23 | |
| 24 | /* |
| 25 | * XDR functions for basic NFS types |
| 26 | */ |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 27 | static __be32 * |
| 28 | decode_fh(__be32 *p, struct svc_fh *fhp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | { |
| 30 | fh_init(fhp, NFS_FHSIZE); |
| 31 | memcpy(&fhp->fh_handle.fh_base, p, NFS_FHSIZE); |
| 32 | fhp->fh_handle.fh_size = NFS_FHSIZE; |
| 33 | |
| 34 | /* FIXME: Look up export pointer here and verify |
| 35 | * Sun Secure RPC if requested */ |
| 36 | return p + (NFS_FHSIZE >> 2); |
| 37 | } |
| 38 | |
Andreas Gruenbacher | a257cdd | 2005-06-22 17:16:26 +0000 | [diff] [blame] | 39 | /* Helper function for NFSv2 ACL code */ |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 40 | __be32 *nfs2svc_decode_fh(__be32 *p, struct svc_fh *fhp) |
Andreas Gruenbacher | a257cdd | 2005-06-22 17:16:26 +0000 | [diff] [blame] | 41 | { |
| 42 | return decode_fh(p, fhp); |
| 43 | } |
| 44 | |
Adrian Bunk | 3ee6f61 | 2006-12-06 20:40:23 -0800 | [diff] [blame] | 45 | static __be32 * |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 46 | encode_fh(__be32 *p, struct svc_fh *fhp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | { |
| 48 | memcpy(p, &fhp->fh_handle.fh_base, NFS_FHSIZE); |
| 49 | return p + (NFS_FHSIZE>> 2); |
| 50 | } |
| 51 | |
| 52 | /* |
| 53 | * Decode a file name and make sure that the path contains |
| 54 | * no slashes or null bytes. |
| 55 | */ |
Adrian Bunk | 3ee6f61 | 2006-12-06 20:40:23 -0800 | [diff] [blame] | 56 | static __be32 * |
Chuck Lever | ee1a95b | 2007-11-01 16:56:58 -0400 | [diff] [blame] | 57 | decode_filename(__be32 *p, char **namp, unsigned int *lenp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | { |
| 59 | char *name; |
Chuck Lever | ee1a95b | 2007-11-01 16:56:58 -0400 | [diff] [blame] | 60 | unsigned int i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | |
| 62 | if ((p = xdr_decode_string_inplace(p, namp, lenp, NFS_MAXNAMLEN)) != NULL) { |
| 63 | for (i = 0, name = *namp; i < *lenp; i++, name++) { |
| 64 | if (*name == '\0' || *name == '/') |
| 65 | return NULL; |
| 66 | } |
| 67 | } |
| 68 | |
| 69 | return p; |
| 70 | } |
| 71 | |
Adrian Bunk | 3ee6f61 | 2006-12-06 20:40:23 -0800 | [diff] [blame] | 72 | static __be32 * |
Chuck Lever | 9c7544d | 2007-11-01 16:57:14 -0400 | [diff] [blame] | 73 | decode_pathname(__be32 *p, char **namp, unsigned int *lenp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 74 | { |
| 75 | char *name; |
Chuck Lever | 9c7544d | 2007-11-01 16:57:14 -0400 | [diff] [blame] | 76 | unsigned int i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 77 | |
| 78 | if ((p = xdr_decode_string_inplace(p, namp, lenp, NFS_MAXPATHLEN)) != NULL) { |
| 79 | for (i = 0, name = *namp; i < *lenp; i++, name++) { |
| 80 | if (*name == '\0') |
| 81 | return NULL; |
| 82 | } |
| 83 | } |
| 84 | |
| 85 | return p; |
| 86 | } |
| 87 | |
Adrian Bunk | 3ee6f61 | 2006-12-06 20:40:23 -0800 | [diff] [blame] | 88 | static __be32 * |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 89 | decode_sattr(__be32 *p, struct iattr *iap) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | { |
| 91 | u32 tmp, tmp1; |
| 92 | |
| 93 | iap->ia_valid = 0; |
| 94 | |
| 95 | /* Sun client bug compatibility check: some sun clients seem to |
| 96 | * put 0xffff in the mode field when they mean 0xffffffff. |
| 97 | * Quoting the 4.4BSD nfs server code: Nah nah nah nah na nah. |
| 98 | */ |
| 99 | if ((tmp = ntohl(*p++)) != (u32)-1 && tmp != 0xffff) { |
| 100 | iap->ia_valid |= ATTR_MODE; |
| 101 | iap->ia_mode = tmp; |
| 102 | } |
| 103 | if ((tmp = ntohl(*p++)) != (u32)-1) { |
Eric W. Biederman | 7c19723 | 2013-02-02 04:32:35 -0800 | [diff] [blame] | 104 | iap->ia_uid = make_kuid(&init_user_ns, tmp); |
| 105 | if (uid_valid(iap->ia_uid)) |
| 106 | iap->ia_valid |= ATTR_UID; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | } |
| 108 | if ((tmp = ntohl(*p++)) != (u32)-1) { |
Eric W. Biederman | 7c19723 | 2013-02-02 04:32:35 -0800 | [diff] [blame] | 109 | iap->ia_gid = make_kgid(&init_user_ns, tmp); |
| 110 | if (gid_valid(iap->ia_gid)) |
| 111 | iap->ia_valid |= ATTR_GID; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | } |
| 113 | if ((tmp = ntohl(*p++)) != (u32)-1) { |
| 114 | iap->ia_valid |= ATTR_SIZE; |
| 115 | iap->ia_size = tmp; |
| 116 | } |
| 117 | tmp = ntohl(*p++); tmp1 = ntohl(*p++); |
| 118 | if (tmp != (u32)-1 && tmp1 != (u32)-1) { |
| 119 | iap->ia_valid |= ATTR_ATIME | ATTR_ATIME_SET; |
| 120 | iap->ia_atime.tv_sec = tmp; |
| 121 | iap->ia_atime.tv_nsec = tmp1 * 1000; |
| 122 | } |
| 123 | tmp = ntohl(*p++); tmp1 = ntohl(*p++); |
| 124 | if (tmp != (u32)-1 && tmp1 != (u32)-1) { |
| 125 | iap->ia_valid |= ATTR_MTIME | ATTR_MTIME_SET; |
| 126 | iap->ia_mtime.tv_sec = tmp; |
| 127 | iap->ia_mtime.tv_nsec = tmp1 * 1000; |
| 128 | /* |
| 129 | * Passing the invalid value useconds=1000000 for mtime |
| 130 | * is a Sun convention for "set both mtime and atime to |
| 131 | * current server time". It's needed to make permissions |
| 132 | * checks for the "touch" program across v2 mounts to |
| 133 | * Solaris and Irix boxes work correctly. See description of |
| 134 | * sattr in section 6.1 of "NFS Illustrated" by |
| 135 | * Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5 |
| 136 | */ |
| 137 | if (tmp1 == 1000000) |
| 138 | iap->ia_valid &= ~(ATTR_ATIME_SET|ATTR_MTIME_SET); |
| 139 | } |
| 140 | return p; |
| 141 | } |
| 142 | |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 143 | static __be32 * |
| 144 | encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp, |
David Shaw | a334de2 | 2006-01-06 00:19:58 -0800 | [diff] [blame] | 145 | struct kstat *stat) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 147 | struct dentry *dentry = fhp->fh_dentry; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | int type; |
| 149 | struct timespec time; |
NeilBrown | af6a4e2 | 2007-02-14 00:33:12 -0800 | [diff] [blame] | 150 | u32 f; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 151 | |
David Shaw | a334de2 | 2006-01-06 00:19:58 -0800 | [diff] [blame] | 152 | type = (stat->mode & S_IFMT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | |
| 154 | *p++ = htonl(nfs_ftypes[type >> 12]); |
J. Bruce Fields | 082f31a | 2014-04-03 15:10:35 -0400 | [diff] [blame] | 155 | *p++ = htonl((u32) stat->mode); |
David Shaw | a334de2 | 2006-01-06 00:19:58 -0800 | [diff] [blame] | 156 | *p++ = htonl((u32) stat->nlink); |
Eric W. Biederman | 7c19723 | 2013-02-02 04:32:35 -0800 | [diff] [blame] | 157 | *p++ = htonl((u32) from_kuid(&init_user_ns, stat->uid)); |
| 158 | *p++ = htonl((u32) from_kgid(&init_user_ns, stat->gid)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | |
David Shaw | a334de2 | 2006-01-06 00:19:58 -0800 | [diff] [blame] | 160 | if (S_ISLNK(type) && stat->size > NFS_MAXPATHLEN) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | *p++ = htonl(NFS_MAXPATHLEN); |
| 162 | } else { |
David Shaw | a334de2 | 2006-01-06 00:19:58 -0800 | [diff] [blame] | 163 | *p++ = htonl((u32) stat->size); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | } |
David Shaw | a334de2 | 2006-01-06 00:19:58 -0800 | [diff] [blame] | 165 | *p++ = htonl((u32) stat->blksize); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | if (S_ISCHR(type) || S_ISBLK(type)) |
David Shaw | a334de2 | 2006-01-06 00:19:58 -0800 | [diff] [blame] | 167 | *p++ = htonl(new_encode_dev(stat->rdev)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | else |
| 169 | *p++ = htonl(0xffffffff); |
David Shaw | a334de2 | 2006-01-06 00:19:58 -0800 | [diff] [blame] | 170 | *p++ = htonl((u32) stat->blocks); |
NeilBrown | af6a4e2 | 2007-02-14 00:33:12 -0800 | [diff] [blame] | 171 | switch (fsid_source(fhp)) { |
| 172 | default: |
| 173 | case FSIDSOURCE_DEV: |
David Shaw | a334de2 | 2006-01-06 00:19:58 -0800 | [diff] [blame] | 174 | *p++ = htonl(new_encode_dev(stat->dev)); |
NeilBrown | af6a4e2 | 2007-02-14 00:33:12 -0800 | [diff] [blame] | 175 | break; |
| 176 | case FSIDSOURCE_FSID: |
| 177 | *p++ = htonl((u32) fhp->fh_export->ex_fsid); |
| 178 | break; |
| 179 | case FSIDSOURCE_UUID: |
| 180 | f = ((u32*)fhp->fh_export->ex_uuid)[0]; |
| 181 | f ^= ((u32*)fhp->fh_export->ex_uuid)[1]; |
| 182 | f ^= ((u32*)fhp->fh_export->ex_uuid)[2]; |
| 183 | f ^= ((u32*)fhp->fh_export->ex_uuid)[3]; |
| 184 | *p++ = htonl(f); |
| 185 | break; |
| 186 | } |
David Shaw | a334de2 | 2006-01-06 00:19:58 -0800 | [diff] [blame] | 187 | *p++ = htonl((u32) stat->ino); |
| 188 | *p++ = htonl((u32) stat->atime.tv_sec); |
| 189 | *p++ = htonl(stat->atime.tv_nsec ? stat->atime.tv_nsec / 1000 : 0); |
David Howells | 2b0143b | 2015-03-17 22:25:59 +0000 | [diff] [blame] | 190 | lease_get_mtime(d_inode(dentry), &time); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 191 | *p++ = htonl((u32) time.tv_sec); |
| 192 | *p++ = htonl(time.tv_nsec ? time.tv_nsec / 1000 : 0); |
David Shaw | a334de2 | 2006-01-06 00:19:58 -0800 | [diff] [blame] | 193 | *p++ = htonl((u32) stat->ctime.tv_sec); |
| 194 | *p++ = htonl(stat->ctime.tv_nsec ? stat->ctime.tv_nsec / 1000 : 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | |
| 196 | return p; |
| 197 | } |
| 198 | |
Andreas Gruenbacher | a257cdd | 2005-06-22 17:16:26 +0000 | [diff] [blame] | 199 | /* Helper function for NFSv2 ACL code */ |
J. Bruce Fields | 4f4a4fa | 2013-02-01 15:13:04 -0500 | [diff] [blame] | 200 | __be32 *nfs2svc_encode_fattr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp, struct kstat *stat) |
Andreas Gruenbacher | a257cdd | 2005-06-22 17:16:26 +0000 | [diff] [blame] | 201 | { |
J. Bruce Fields | 4f4a4fa | 2013-02-01 15:13:04 -0500 | [diff] [blame] | 202 | return encode_fattr(rqstp, p, fhp, stat); |
Andreas Gruenbacher | a257cdd | 2005-06-22 17:16:26 +0000 | [diff] [blame] | 203 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 204 | |
| 205 | /* |
| 206 | * XDR decode functions |
| 207 | */ |
| 208 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 209 | nfssvc_decode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 210 | { |
| 211 | return xdr_argsize_check(rqstp, p); |
| 212 | } |
| 213 | |
| 214 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 215 | nfssvc_decode_fhandle(struct svc_rqst *rqstp, __be32 *p, struct nfsd_fhandle *args) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 216 | { |
Benoit Taine | d40aa33 | 2014-05-22 16:32:30 +0200 | [diff] [blame] | 217 | p = decode_fh(p, &args->fh); |
| 218 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 219 | return 0; |
| 220 | return xdr_argsize_check(rqstp, p); |
| 221 | } |
| 222 | |
| 223 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 224 | nfssvc_decode_sattrargs(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 225 | struct nfsd_sattrargs *args) |
| 226 | { |
NeilBrown | 072f62e | 2007-05-09 02:34:57 -0700 | [diff] [blame] | 227 | p = decode_fh(p, &args->fh); |
| 228 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 229 | return 0; |
NeilBrown | 072f62e | 2007-05-09 02:34:57 -0700 | [diff] [blame] | 230 | p = decode_sattr(p, &args->attrs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 231 | |
| 232 | return xdr_argsize_check(rqstp, p); |
| 233 | } |
| 234 | |
| 235 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 236 | nfssvc_decode_diropargs(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | struct nfsd_diropargs *args) |
| 238 | { |
| 239 | if (!(p = decode_fh(p, &args->fh)) |
| 240 | || !(p = decode_filename(p, &args->name, &args->len))) |
| 241 | return 0; |
| 242 | |
Christophe JAILLET | d28c442 | 2016-07-02 08:24:32 +0200 | [diff] [blame] | 243 | return xdr_argsize_check(rqstp, p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 247 | nfssvc_decode_readargs(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 248 | struct nfsd_readargs *args) |
| 249 | { |
| 250 | unsigned int len; |
J. Bruce Fields | afc5940 | 2012-12-10 18:01:37 -0500 | [diff] [blame] | 251 | int v; |
Benoit Taine | d40aa33 | 2014-05-22 16:32:30 +0200 | [diff] [blame] | 252 | p = decode_fh(p, &args->fh); |
| 253 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | return 0; |
| 255 | |
| 256 | args->offset = ntohl(*p++); |
| 257 | len = args->count = ntohl(*p++); |
| 258 | p++; /* totalcount - unused */ |
| 259 | |
Kinglong Mee | 3c7aa15 | 2014-06-10 18:08:19 +0800 | [diff] [blame] | 260 | len = min_t(unsigned int, len, NFSSVC_MAXBLKSIZE_V2); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 261 | |
| 262 | /* set up somewhere to store response. |
| 263 | * We take pages, put them on reslist and include in iovec |
| 264 | */ |
| 265 | v=0; |
| 266 | while (len > 0) { |
J. Bruce Fields | afc5940 | 2012-12-10 18:01:37 -0500 | [diff] [blame] | 267 | struct page *p = *(rqstp->rq_next_page++); |
| 268 | |
| 269 | rqstp->rq_vec[v].iov_base = page_address(p); |
Kinglong Mee | 3c7aa15 | 2014-06-10 18:08:19 +0800 | [diff] [blame] | 270 | rqstp->rq_vec[v].iov_len = min_t(unsigned int, len, PAGE_SIZE); |
NeilBrown | 3cc03b1 | 2006-10-04 02:15:47 -0700 | [diff] [blame] | 271 | len -= rqstp->rq_vec[v].iov_len; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | v++; |
| 273 | } |
| 274 | args->vlen = v; |
J. Bruce Fields | 9512a16 | 2017-05-16 15:57:42 -0400 | [diff] [blame] | 275 | return xdr_argsize_check(rqstp, p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 276 | } |
| 277 | |
| 278 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 279 | nfssvc_decode_writeargs(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 280 | struct nfsd_writeargs *args) |
| 281 | { |
Peter Staubach | f34b956 | 2007-05-09 02:34:48 -0700 | [diff] [blame] | 282 | unsigned int len, hdr, dlen; |
J. Bruce Fields | db44bac | 2017-04-25 16:21:34 -0400 | [diff] [blame] | 283 | struct kvec *head = rqstp->rq_arg.head; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 284 | int v; |
Peter Staubach | f34b956 | 2007-05-09 02:34:48 -0700 | [diff] [blame] | 285 | |
Benoit Taine | d40aa33 | 2014-05-22 16:32:30 +0200 | [diff] [blame] | 286 | p = decode_fh(p, &args->fh); |
| 287 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 288 | return 0; |
| 289 | |
| 290 | p++; /* beginoffset */ |
| 291 | args->offset = ntohl(*p++); /* offset */ |
| 292 | p++; /* totalcount */ |
| 293 | len = args->len = ntohl(*p++); |
Peter Staubach | f34b956 | 2007-05-09 02:34:48 -0700 | [diff] [blame] | 294 | /* |
| 295 | * The protocol specifies a maximum of 8192 bytes. |
| 296 | */ |
Greg Banks | 7adae48 | 2006-10-04 02:15:47 -0700 | [diff] [blame] | 297 | if (len > NFSSVC_MAXBLKSIZE_V2) |
Peter Staubach | f34b956 | 2007-05-09 02:34:48 -0700 | [diff] [blame] | 298 | return 0; |
| 299 | |
| 300 | /* |
| 301 | * Check to make sure that we got the right number of |
| 302 | * bytes. |
Peter Staubach | f34b956 | 2007-05-09 02:34:48 -0700 | [diff] [blame] | 303 | */ |
J. Bruce Fields | db44bac | 2017-04-25 16:21:34 -0400 | [diff] [blame] | 304 | hdr = (void*)p - head->iov_base; |
J. Bruce Fields | 13bf9fb | 2017-04-21 15:26:30 -0400 | [diff] [blame] | 305 | if (hdr > head->iov_len) |
| 306 | return 0; |
J. Bruce Fields | db44bac | 2017-04-25 16:21:34 -0400 | [diff] [blame] | 307 | dlen = head->iov_len + rqstp->rq_arg.page_len - hdr; |
NeilBrown | 072f62e | 2007-05-09 02:34:57 -0700 | [diff] [blame] | 308 | |
Peter Staubach | f34b956 | 2007-05-09 02:34:48 -0700 | [diff] [blame] | 309 | /* |
| 310 | * Round the length of the data which was specified up to |
| 311 | * the next multiple of XDR units and then compare that |
| 312 | * against the length which was actually received. |
NeilBrown | ba67a39 | 2008-01-11 17:06:52 -0500 | [diff] [blame] | 313 | * Note that when RPCSEC/GSS (for example) is used, the |
| 314 | * data buffer can be padded so dlen might be larger |
| 315 | * than required. It must never be smaller. |
Peter Staubach | f34b956 | 2007-05-09 02:34:48 -0700 | [diff] [blame] | 316 | */ |
NeilBrown | ba67a39 | 2008-01-11 17:06:52 -0500 | [diff] [blame] | 317 | if (dlen < XDR_QUADLEN(len)*4) |
Peter Staubach | f34b956 | 2007-05-09 02:34:48 -0700 | [diff] [blame] | 318 | return 0; |
| 319 | |
| 320 | rqstp->rq_vec[0].iov_base = (void*)p; |
J. Bruce Fields | db44bac | 2017-04-25 16:21:34 -0400 | [diff] [blame] | 321 | rqstp->rq_vec[0].iov_len = head->iov_len - hdr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 322 | v = 0; |
NeilBrown | 3cc03b1 | 2006-10-04 02:15:47 -0700 | [diff] [blame] | 323 | while (len > rqstp->rq_vec[v].iov_len) { |
| 324 | len -= rqstp->rq_vec[v].iov_len; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 325 | v++; |
NeilBrown | 3cc03b1 | 2006-10-04 02:15:47 -0700 | [diff] [blame] | 326 | rqstp->rq_vec[v].iov_base = page_address(rqstp->rq_pages[v]); |
| 327 | rqstp->rq_vec[v].iov_len = PAGE_SIZE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 328 | } |
NeilBrown | 3cc03b1 | 2006-10-04 02:15:47 -0700 | [diff] [blame] | 329 | rqstp->rq_vec[v].iov_len = len; |
Peter Staubach | f34b956 | 2007-05-09 02:34:48 -0700 | [diff] [blame] | 330 | args->vlen = v + 1; |
| 331 | return 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 332 | } |
| 333 | |
| 334 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 335 | nfssvc_decode_createargs(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 336 | struct nfsd_createargs *args) |
| 337 | { |
NeilBrown | 072f62e | 2007-05-09 02:34:57 -0700 | [diff] [blame] | 338 | if ( !(p = decode_fh(p, &args->fh)) |
| 339 | || !(p = decode_filename(p, &args->name, &args->len))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 340 | return 0; |
NeilBrown | 072f62e | 2007-05-09 02:34:57 -0700 | [diff] [blame] | 341 | p = decode_sattr(p, &args->attrs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 342 | |
| 343 | return xdr_argsize_check(rqstp, p); |
| 344 | } |
| 345 | |
| 346 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 347 | nfssvc_decode_renameargs(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | struct nfsd_renameargs *args) |
| 349 | { |
| 350 | if (!(p = decode_fh(p, &args->ffh)) |
| 351 | || !(p = decode_filename(p, &args->fname, &args->flen)) |
| 352 | || !(p = decode_fh(p, &args->tfh)) |
| 353 | || !(p = decode_filename(p, &args->tname, &args->tlen))) |
| 354 | return 0; |
| 355 | |
| 356 | return xdr_argsize_check(rqstp, p); |
| 357 | } |
| 358 | |
| 359 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 360 | nfssvc_decode_readlinkargs(struct svc_rqst *rqstp, __be32 *p, struct nfsd_readlinkargs *args) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 361 | { |
Benoit Taine | d40aa33 | 2014-05-22 16:32:30 +0200 | [diff] [blame] | 362 | p = decode_fh(p, &args->fh); |
| 363 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 364 | return 0; |
J. Bruce Fields | afc5940 | 2012-12-10 18:01:37 -0500 | [diff] [blame] | 365 | args->buffer = page_address(*(rqstp->rq_next_page++)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 366 | |
J. Bruce Fields | 9512a16 | 2017-05-16 15:57:42 -0400 | [diff] [blame] | 367 | return xdr_argsize_check(rqstp, p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 368 | } |
| 369 | |
| 370 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 371 | nfssvc_decode_linkargs(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 372 | struct nfsd_linkargs *args) |
| 373 | { |
| 374 | if (!(p = decode_fh(p, &args->ffh)) |
| 375 | || !(p = decode_fh(p, &args->tfh)) |
| 376 | || !(p = decode_filename(p, &args->tname, &args->tlen))) |
| 377 | return 0; |
| 378 | |
| 379 | return xdr_argsize_check(rqstp, p); |
| 380 | } |
| 381 | |
| 382 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 383 | nfssvc_decode_symlinkargs(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 384 | struct nfsd_symlinkargs *args) |
| 385 | { |
NeilBrown | 072f62e | 2007-05-09 02:34:57 -0700 | [diff] [blame] | 386 | if ( !(p = decode_fh(p, &args->ffh)) |
| 387 | || !(p = decode_filename(p, &args->fname, &args->flen)) |
| 388 | || !(p = decode_pathname(p, &args->tname, &args->tlen))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 389 | return 0; |
NeilBrown | 072f62e | 2007-05-09 02:34:57 -0700 | [diff] [blame] | 390 | p = decode_sattr(p, &args->attrs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 391 | |
| 392 | return xdr_argsize_check(rqstp, p); |
| 393 | } |
| 394 | |
| 395 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 396 | nfssvc_decode_readdirargs(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 397 | struct nfsd_readdirargs *args) |
| 398 | { |
Benoit Taine | d40aa33 | 2014-05-22 16:32:30 +0200 | [diff] [blame] | 399 | p = decode_fh(p, &args->fh); |
| 400 | if (!p) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 401 | return 0; |
| 402 | args->cookie = ntohl(*p++); |
| 403 | args->count = ntohl(*p++); |
Kinglong Mee | 3c7aa15 | 2014-06-10 18:08:19 +0800 | [diff] [blame] | 404 | args->count = min_t(u32, args->count, PAGE_SIZE); |
J. Bruce Fields | afc5940 | 2012-12-10 18:01:37 -0500 | [diff] [blame] | 405 | args->buffer = page_address(*(rqstp->rq_next_page++)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 406 | |
J. Bruce Fields | 9512a16 | 2017-05-16 15:57:42 -0400 | [diff] [blame] | 407 | return xdr_argsize_check(rqstp, p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 408 | } |
| 409 | |
| 410 | /* |
| 411 | * XDR encode functions |
| 412 | */ |
| 413 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 414 | nfssvc_encode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 415 | { |
| 416 | return xdr_ressize_check(rqstp, p); |
| 417 | } |
| 418 | |
| 419 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 420 | nfssvc_encode_attrstat(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 421 | struct nfsd_attrstat *resp) |
| 422 | { |
David Shaw | a334de2 | 2006-01-06 00:19:58 -0800 | [diff] [blame] | 423 | p = encode_fattr(rqstp, p, &resp->fh, &resp->stat); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 424 | return xdr_ressize_check(rqstp, p); |
| 425 | } |
| 426 | |
| 427 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 428 | nfssvc_encode_diropres(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 429 | struct nfsd_diropres *resp) |
| 430 | { |
| 431 | p = encode_fh(p, &resp->fh); |
David Shaw | a334de2 | 2006-01-06 00:19:58 -0800 | [diff] [blame] | 432 | p = encode_fattr(rqstp, p, &resp->fh, &resp->stat); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 433 | return xdr_ressize_check(rqstp, p); |
| 434 | } |
| 435 | |
| 436 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 437 | nfssvc_encode_readlinkres(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 438 | struct nfsd_readlinkres *resp) |
| 439 | { |
| 440 | *p++ = htonl(resp->len); |
| 441 | xdr_ressize_check(rqstp, p); |
| 442 | rqstp->rq_res.page_len = resp->len; |
| 443 | if (resp->len & 3) { |
| 444 | /* need to pad the tail */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 445 | rqstp->rq_res.tail[0].iov_base = p; |
| 446 | *p = 0; |
| 447 | rqstp->rq_res.tail[0].iov_len = 4 - (resp->len&3); |
| 448 | } |
| 449 | return 1; |
| 450 | } |
| 451 | |
| 452 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 453 | nfssvc_encode_readres(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 454 | struct nfsd_readres *resp) |
| 455 | { |
David Shaw | a334de2 | 2006-01-06 00:19:58 -0800 | [diff] [blame] | 456 | p = encode_fattr(rqstp, p, &resp->fh, &resp->stat); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 457 | *p++ = htonl(resp->count); |
| 458 | xdr_ressize_check(rqstp, p); |
| 459 | |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 460 | /* now update rqstp->rq_res to reflect data as well */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 461 | rqstp->rq_res.page_len = resp->count; |
| 462 | if (resp->count & 3) { |
| 463 | /* need to pad the tail */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 464 | rqstp->rq_res.tail[0].iov_base = p; |
| 465 | *p = 0; |
| 466 | rqstp->rq_res.tail[0].iov_len = 4 - (resp->count&3); |
| 467 | } |
| 468 | return 1; |
| 469 | } |
| 470 | |
| 471 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 472 | nfssvc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 473 | struct nfsd_readdirres *resp) |
| 474 | { |
| 475 | xdr_ressize_check(rqstp, p); |
| 476 | p = resp->buffer; |
| 477 | *p++ = 0; /* no more entries */ |
| 478 | *p++ = htonl((resp->common.err == nfserr_eof)); |
| 479 | rqstp->rq_res.page_len = (((unsigned long)p-1) & ~PAGE_MASK)+1; |
| 480 | |
| 481 | return 1; |
| 482 | } |
| 483 | |
| 484 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 485 | nfssvc_encode_statfsres(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 486 | struct nfsd_statfsres *resp) |
| 487 | { |
| 488 | struct kstatfs *stat = &resp->stats; |
| 489 | |
Greg Banks | 7adae48 | 2006-10-04 02:15:47 -0700 | [diff] [blame] | 490 | *p++ = htonl(NFSSVC_MAXBLKSIZE_V2); /* max transfer size */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 491 | *p++ = htonl(stat->f_bsize); |
| 492 | *p++ = htonl(stat->f_blocks); |
| 493 | *p++ = htonl(stat->f_bfree); |
| 494 | *p++ = htonl(stat->f_bavail); |
| 495 | return xdr_ressize_check(rqstp, p); |
| 496 | } |
| 497 | |
| 498 | int |
NeilBrown | a0ad13e | 2007-01-26 00:57:10 -0800 | [diff] [blame] | 499 | nfssvc_encode_entry(void *ccdv, const char *name, |
| 500 | int namlen, loff_t offset, u64 ino, unsigned int d_type) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 501 | { |
NeilBrown | a0ad13e | 2007-01-26 00:57:10 -0800 | [diff] [blame] | 502 | struct readdir_cd *ccd = ccdv; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 503 | struct nfsd_readdirres *cd = container_of(ccd, struct nfsd_readdirres, common); |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 504 | __be32 *p = cd->buffer; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 505 | int buflen, slen; |
| 506 | |
| 507 | /* |
| 508 | dprintk("nfsd: entry(%.*s off %ld ino %ld)\n", |
| 509 | namlen, name, offset, ino); |
| 510 | */ |
| 511 | |
| 512 | if (offset > ~((u32) 0)) { |
| 513 | cd->common.err = nfserr_fbig; |
| 514 | return -EINVAL; |
| 515 | } |
| 516 | if (cd->offset) |
| 517 | *cd->offset = htonl(offset); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 518 | |
Kinglong Mee | 3c7aa15 | 2014-06-10 18:08:19 +0800 | [diff] [blame] | 519 | /* truncate filename */ |
| 520 | namlen = min(namlen, NFS2_MAXNAMLEN); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 521 | slen = XDR_QUADLEN(namlen); |
Kinglong Mee | 3c7aa15 | 2014-06-10 18:08:19 +0800 | [diff] [blame] | 522 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 523 | if ((buflen = cd->buflen - slen - 4) < 0) { |
| 524 | cd->common.err = nfserr_toosmall; |
| 525 | return -EINVAL; |
| 526 | } |
Peter Staubach | 40ee5dc | 2007-08-16 12:10:07 -0400 | [diff] [blame] | 527 | if (ino > ~((u32) 0)) { |
| 528 | cd->common.err = nfserr_fbig; |
| 529 | return -EINVAL; |
| 530 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 531 | *p++ = xdr_one; /* mark entry present */ |
| 532 | *p++ = htonl((u32) ino); /* file id */ |
| 533 | p = xdr_encode_array(p, name, namlen);/* name length & name */ |
| 534 | cd->offset = p; /* remember pointer */ |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 535 | *p++ = htonl(~0U); /* offset of next entry */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 536 | |
| 537 | cd->buflen = buflen; |
| 538 | cd->buffer = p; |
| 539 | cd->common.err = nfs_ok; |
| 540 | return 0; |
| 541 | } |
| 542 | |
| 543 | /* |
| 544 | * XDR release functions |
| 545 | */ |
| 546 | int |
Al Viro | 131a21c | 2006-10-19 23:28:56 -0700 | [diff] [blame] | 547 | nfssvc_release_fhandle(struct svc_rqst *rqstp, __be32 *p, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 548 | struct nfsd_fhandle *resp) |
| 549 | { |
| 550 | fh_put(&resp->fh); |
| 551 | return 1; |
| 552 | } |