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