1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * XDR support for nfsd |
4 | * |
5 | * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de> |
6 | */ |
7 | |
8 | #include "vfs.h" |
9 | #include "xdr.h" |
10 | #include "auth.h" |
11 | |
12 | /* |
13 | * Mapping of S_IF* types to NFS file types |
14 | */ |
15 | static const u32 nfs_ftypes[] = { |
16 | NFNON, NFCHR, NFCHR, NFBAD, |
17 | NFDIR, NFBAD, NFBLK, NFBAD, |
18 | NFREG, NFBAD, NFLNK, NFBAD, |
19 | NFSOCK, NFBAD, NFLNK, NFBAD, |
20 | }; |
21 | |
22 | |
23 | /* |
24 | * Basic NFSv2 data types (RFC 1094 Section 2.3) |
25 | */ |
26 | |
27 | /** |
28 | * svcxdr_encode_stat - Encode an NFSv2 status code |
29 | * @xdr: XDR stream |
30 | * @status: status value to encode |
31 | * |
32 | * Return values: |
33 | * %false: Send buffer space was exhausted |
34 | * %true: Success |
35 | */ |
36 | bool |
37 | svcxdr_encode_stat(struct xdr_stream *xdr, __be32 status) |
38 | { |
39 | __be32 *p; |
40 | |
41 | p = xdr_reserve_space(xdr, nbytes: sizeof(status)); |
42 | if (!p) |
43 | return false; |
44 | *p = status; |
45 | |
46 | return true; |
47 | } |
48 | |
49 | /** |
50 | * svcxdr_decode_fhandle - Decode an NFSv2 file handle |
51 | * @xdr: XDR stream positioned at an encoded NFSv2 FH |
52 | * @fhp: OUT: filled-in server file handle |
53 | * |
54 | * Return values: |
55 | * %false: The encoded file handle was not valid |
56 | * %true: @fhp has been initialized |
57 | */ |
58 | bool |
59 | svcxdr_decode_fhandle(struct xdr_stream *xdr, struct svc_fh *fhp) |
60 | { |
61 | __be32 *p; |
62 | |
63 | p = xdr_inline_decode(xdr, NFS_FHSIZE); |
64 | if (!p) |
65 | return false; |
66 | fh_init(fhp, NFS_FHSIZE); |
67 | memcpy(&fhp->fh_handle.fh_raw, p, NFS_FHSIZE); |
68 | fhp->fh_handle.fh_size = NFS_FHSIZE; |
69 | |
70 | return true; |
71 | } |
72 | |
73 | static bool |
74 | svcxdr_encode_fhandle(struct xdr_stream *xdr, const struct svc_fh *fhp) |
75 | { |
76 | __be32 *p; |
77 | |
78 | p = xdr_reserve_space(xdr, NFS_FHSIZE); |
79 | if (!p) |
80 | return false; |
81 | memcpy(p, &fhp->fh_handle.fh_raw, NFS_FHSIZE); |
82 | |
83 | return true; |
84 | } |
85 | |
86 | static __be32 * |
87 | encode_timeval(__be32 *p, const struct timespec64 *time) |
88 | { |
89 | *p++ = cpu_to_be32((u32)time->tv_sec); |
90 | if (time->tv_nsec) |
91 | *p++ = cpu_to_be32(time->tv_nsec / NSEC_PER_USEC); |
92 | else |
93 | *p++ = xdr_zero; |
94 | return p; |
95 | } |
96 | |
97 | static bool |
98 | svcxdr_decode_filename(struct xdr_stream *xdr, char **name, unsigned int *len) |
99 | { |
100 | u32 size, i; |
101 | __be32 *p; |
102 | char *c; |
103 | |
104 | if (xdr_stream_decode_u32(xdr, ptr: &size) < 0) |
105 | return false; |
106 | if (size == 0 || size > NFS_MAXNAMLEN) |
107 | return false; |
108 | p = xdr_inline_decode(xdr, nbytes: size); |
109 | if (!p) |
110 | return false; |
111 | |
112 | *len = size; |
113 | *name = (char *)p; |
114 | for (i = 0, c = *name; i < size; i++, c++) |
115 | if (*c == '\0' || *c == '/') |
116 | return false; |
117 | |
118 | return true; |
119 | } |
120 | |
121 | static bool |
122 | svcxdr_decode_diropargs(struct xdr_stream *xdr, struct svc_fh *fhp, |
123 | char **name, unsigned int *len) |
124 | { |
125 | return svcxdr_decode_fhandle(xdr, fhp) && |
126 | svcxdr_decode_filename(xdr, name, len); |
127 | } |
128 | |
129 | static bool |
130 | svcxdr_decode_sattr(struct svc_rqst *rqstp, struct xdr_stream *xdr, |
131 | struct iattr *iap) |
132 | { |
133 | u32 tmp1, tmp2; |
134 | __be32 *p; |
135 | |
136 | p = xdr_inline_decode(xdr, XDR_UNIT * 8); |
137 | if (!p) |
138 | return false; |
139 | |
140 | iap->ia_valid = 0; |
141 | |
142 | /* |
143 | * Some Sun clients put 0xffff in the mode field when they |
144 | * mean 0xffffffff. |
145 | */ |
146 | tmp1 = be32_to_cpup(p: p++); |
147 | if (tmp1 != (u32)-1 && tmp1 != 0xffff) { |
148 | iap->ia_valid |= ATTR_MODE; |
149 | iap->ia_mode = tmp1; |
150 | } |
151 | |
152 | tmp1 = be32_to_cpup(p: p++); |
153 | if (tmp1 != (u32)-1) { |
154 | iap->ia_uid = make_kuid(from: nfsd_user_namespace(rqstp), uid: tmp1); |
155 | if (uid_valid(uid: iap->ia_uid)) |
156 | iap->ia_valid |= ATTR_UID; |
157 | } |
158 | |
159 | tmp1 = be32_to_cpup(p: p++); |
160 | if (tmp1 != (u32)-1) { |
161 | iap->ia_gid = make_kgid(from: nfsd_user_namespace(rqstp), gid: tmp1); |
162 | if (gid_valid(gid: iap->ia_gid)) |
163 | iap->ia_valid |= ATTR_GID; |
164 | } |
165 | |
166 | tmp1 = be32_to_cpup(p: p++); |
167 | if (tmp1 != (u32)-1) { |
168 | iap->ia_valid |= ATTR_SIZE; |
169 | iap->ia_size = tmp1; |
170 | } |
171 | |
172 | tmp1 = be32_to_cpup(p: p++); |
173 | tmp2 = be32_to_cpup(p: p++); |
174 | if (tmp1 != (u32)-1 && tmp2 != (u32)-1) { |
175 | iap->ia_valid |= ATTR_ATIME | ATTR_ATIME_SET; |
176 | iap->ia_atime.tv_sec = tmp1; |
177 | iap->ia_atime.tv_nsec = tmp2 * NSEC_PER_USEC; |
178 | } |
179 | |
180 | tmp1 = be32_to_cpup(p: p++); |
181 | tmp2 = be32_to_cpup(p: p++); |
182 | if (tmp1 != (u32)-1 && tmp2 != (u32)-1) { |
183 | iap->ia_valid |= ATTR_MTIME | ATTR_MTIME_SET; |
184 | iap->ia_mtime.tv_sec = tmp1; |
185 | iap->ia_mtime.tv_nsec = tmp2 * NSEC_PER_USEC; |
186 | /* |
187 | * Passing the invalid value useconds=1000000 for mtime |
188 | * is a Sun convention for "set both mtime and atime to |
189 | * current server time". It's needed to make permissions |
190 | * checks for the "touch" program across v2 mounts to |
191 | * Solaris and Irix boxes work correctly. See description of |
192 | * sattr in section 6.1 of "NFS Illustrated" by |
193 | * Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5 |
194 | */ |
195 | if (tmp2 == 1000000) |
196 | iap->ia_valid &= ~(ATTR_ATIME_SET|ATTR_MTIME_SET); |
197 | } |
198 | |
199 | return true; |
200 | } |
201 | |
202 | /** |
203 | * svcxdr_encode_fattr - Encode NFSv2 file attributes |
204 | * @rqstp: Context of a completed RPC transaction |
205 | * @xdr: XDR stream |
206 | * @fhp: File handle to encode |
207 | * @stat: Attributes to encode |
208 | * |
209 | * Return values: |
210 | * %false: Send buffer space was exhausted |
211 | * %true: Success |
212 | */ |
213 | bool |
214 | svcxdr_encode_fattr(struct svc_rqst *rqstp, struct xdr_stream *xdr, |
215 | const struct svc_fh *fhp, const struct kstat *stat) |
216 | { |
217 | struct user_namespace *userns = nfsd_user_namespace(rqstp); |
218 | struct dentry *dentry = fhp->fh_dentry; |
219 | int type = stat->mode & S_IFMT; |
220 | struct timespec64 time; |
221 | __be32 *p; |
222 | u32 fsid; |
223 | |
224 | p = xdr_reserve_space(xdr, XDR_UNIT * 17); |
225 | if (!p) |
226 | return false; |
227 | |
228 | *p++ = cpu_to_be32(nfs_ftypes[type >> 12]); |
229 | *p++ = cpu_to_be32((u32)stat->mode); |
230 | *p++ = cpu_to_be32((u32)stat->nlink); |
231 | *p++ = cpu_to_be32((u32)from_kuid_munged(userns, stat->uid)); |
232 | *p++ = cpu_to_be32((u32)from_kgid_munged(userns, stat->gid)); |
233 | |
234 | if (S_ISLNK(type) && stat->size > NFS_MAXPATHLEN) |
235 | *p++ = cpu_to_be32(NFS_MAXPATHLEN); |
236 | else |
237 | *p++ = cpu_to_be32((u32) stat->size); |
238 | *p++ = cpu_to_be32((u32) stat->blksize); |
239 | if (S_ISCHR(type) || S_ISBLK(type)) |
240 | *p++ = cpu_to_be32(new_encode_dev(stat->rdev)); |
241 | else |
242 | *p++ = cpu_to_be32(0xffffffff); |
243 | *p++ = cpu_to_be32((u32)stat->blocks); |
244 | |
245 | switch (fsid_source(fhp)) { |
246 | case FSIDSOURCE_FSID: |
247 | fsid = (u32)fhp->fh_export->ex_fsid; |
248 | break; |
249 | case FSIDSOURCE_UUID: |
250 | fsid = ((u32 *)fhp->fh_export->ex_uuid)[0]; |
251 | fsid ^= ((u32 *)fhp->fh_export->ex_uuid)[1]; |
252 | fsid ^= ((u32 *)fhp->fh_export->ex_uuid)[2]; |
253 | fsid ^= ((u32 *)fhp->fh_export->ex_uuid)[3]; |
254 | break; |
255 | default: |
256 | fsid = new_encode_dev(dev: stat->dev); |
257 | break; |
258 | } |
259 | *p++ = cpu_to_be32(fsid); |
260 | |
261 | *p++ = cpu_to_be32((u32)stat->ino); |
262 | p = encode_timeval(p, time: &stat->atime); |
263 | time = stat->mtime; |
264 | lease_get_mtime(d_inode(dentry), time: &time); |
265 | p = encode_timeval(p, time: &time); |
266 | encode_timeval(p, time: &stat->ctime); |
267 | |
268 | return true; |
269 | } |
270 | |
271 | /* |
272 | * XDR decode functions |
273 | */ |
274 | |
275 | bool |
276 | nfssvc_decode_fhandleargs(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
277 | { |
278 | struct nfsd_fhandle *args = rqstp->rq_argp; |
279 | |
280 | return svcxdr_decode_fhandle(xdr, fhp: &args->fh); |
281 | } |
282 | |
283 | bool |
284 | nfssvc_decode_sattrargs(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
285 | { |
286 | struct nfsd_sattrargs *args = rqstp->rq_argp; |
287 | |
288 | return svcxdr_decode_fhandle(xdr, fhp: &args->fh) && |
289 | svcxdr_decode_sattr(rqstp, xdr, iap: &args->attrs); |
290 | } |
291 | |
292 | bool |
293 | nfssvc_decode_diropargs(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
294 | { |
295 | struct nfsd_diropargs *args = rqstp->rq_argp; |
296 | |
297 | return svcxdr_decode_diropargs(xdr, fhp: &args->fh, name: &args->name, len: &args->len); |
298 | } |
299 | |
300 | bool |
301 | nfssvc_decode_readargs(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
302 | { |
303 | struct nfsd_readargs *args = rqstp->rq_argp; |
304 | u32 totalcount; |
305 | |
306 | if (!svcxdr_decode_fhandle(xdr, fhp: &args->fh)) |
307 | return false; |
308 | if (xdr_stream_decode_u32(xdr, ptr: &args->offset) < 0) |
309 | return false; |
310 | if (xdr_stream_decode_u32(xdr, ptr: &args->count) < 0) |
311 | return false; |
312 | /* totalcount is ignored */ |
313 | if (xdr_stream_decode_u32(xdr, ptr: &totalcount) < 0) |
314 | return false; |
315 | |
316 | return true; |
317 | } |
318 | |
319 | bool |
320 | nfssvc_decode_writeargs(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
321 | { |
322 | struct nfsd_writeargs *args = rqstp->rq_argp; |
323 | u32 beginoffset, totalcount; |
324 | |
325 | if (!svcxdr_decode_fhandle(xdr, fhp: &args->fh)) |
326 | return false; |
327 | /* beginoffset is ignored */ |
328 | if (xdr_stream_decode_u32(xdr, ptr: &beginoffset) < 0) |
329 | return false; |
330 | if (xdr_stream_decode_u32(xdr, ptr: &args->offset) < 0) |
331 | return false; |
332 | /* totalcount is ignored */ |
333 | if (xdr_stream_decode_u32(xdr, ptr: &totalcount) < 0) |
334 | return false; |
335 | |
336 | /* opaque data */ |
337 | if (xdr_stream_decode_u32(xdr, ptr: &args->len) < 0) |
338 | return false; |
339 | if (args->len > NFSSVC_MAXBLKSIZE_V2) |
340 | return false; |
341 | |
342 | return xdr_stream_subsegment(xdr, subbuf: &args->payload, len: args->len); |
343 | } |
344 | |
345 | bool |
346 | nfssvc_decode_createargs(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
347 | { |
348 | struct nfsd_createargs *args = rqstp->rq_argp; |
349 | |
350 | return svcxdr_decode_diropargs(xdr, fhp: &args->fh, |
351 | name: &args->name, len: &args->len) && |
352 | svcxdr_decode_sattr(rqstp, xdr, iap: &args->attrs); |
353 | } |
354 | |
355 | bool |
356 | nfssvc_decode_renameargs(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
357 | { |
358 | struct nfsd_renameargs *args = rqstp->rq_argp; |
359 | |
360 | return svcxdr_decode_diropargs(xdr, fhp: &args->ffh, |
361 | name: &args->fname, len: &args->flen) && |
362 | svcxdr_decode_diropargs(xdr, fhp: &args->tfh, |
363 | name: &args->tname, len: &args->tlen); |
364 | } |
365 | |
366 | bool |
367 | nfssvc_decode_linkargs(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
368 | { |
369 | struct nfsd_linkargs *args = rqstp->rq_argp; |
370 | |
371 | return svcxdr_decode_fhandle(xdr, fhp: &args->ffh) && |
372 | svcxdr_decode_diropargs(xdr, fhp: &args->tfh, |
373 | name: &args->tname, len: &args->tlen); |
374 | } |
375 | |
376 | bool |
377 | nfssvc_decode_symlinkargs(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
378 | { |
379 | struct nfsd_symlinkargs *args = rqstp->rq_argp; |
380 | struct kvec *head = rqstp->rq_arg.head; |
381 | |
382 | if (!svcxdr_decode_diropargs(xdr, fhp: &args->ffh, name: &args->fname, len: &args->flen)) |
383 | return false; |
384 | if (xdr_stream_decode_u32(xdr, ptr: &args->tlen) < 0) |
385 | return false; |
386 | if (args->tlen == 0) |
387 | return false; |
388 | |
389 | args->first.iov_len = head->iov_len - xdr_stream_pos(xdr); |
390 | args->first.iov_base = xdr_inline_decode(xdr, nbytes: args->tlen); |
391 | if (!args->first.iov_base) |
392 | return false; |
393 | return svcxdr_decode_sattr(rqstp, xdr, iap: &args->attrs); |
394 | } |
395 | |
396 | bool |
397 | nfssvc_decode_readdirargs(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
398 | { |
399 | struct nfsd_readdirargs *args = rqstp->rq_argp; |
400 | |
401 | if (!svcxdr_decode_fhandle(xdr, fhp: &args->fh)) |
402 | return false; |
403 | if (xdr_stream_decode_u32(xdr, ptr: &args->cookie) < 0) |
404 | return false; |
405 | if (xdr_stream_decode_u32(xdr, ptr: &args->count) < 0) |
406 | return false; |
407 | |
408 | return true; |
409 | } |
410 | |
411 | /* |
412 | * XDR encode functions |
413 | */ |
414 | |
415 | bool |
416 | nfssvc_encode_statres(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
417 | { |
418 | struct nfsd_stat *resp = rqstp->rq_resp; |
419 | |
420 | return svcxdr_encode_stat(xdr, status: resp->status); |
421 | } |
422 | |
423 | bool |
424 | nfssvc_encode_attrstatres(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
425 | { |
426 | struct nfsd_attrstat *resp = rqstp->rq_resp; |
427 | |
428 | if (!svcxdr_encode_stat(xdr, status: resp->status)) |
429 | return false; |
430 | switch (resp->status) { |
431 | case nfs_ok: |
432 | if (!svcxdr_encode_fattr(rqstp, xdr, fhp: &resp->fh, stat: &resp->stat)) |
433 | return false; |
434 | break; |
435 | } |
436 | |
437 | return true; |
438 | } |
439 | |
440 | bool |
441 | nfssvc_encode_diropres(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
442 | { |
443 | struct nfsd_diropres *resp = rqstp->rq_resp; |
444 | |
445 | if (!svcxdr_encode_stat(xdr, status: resp->status)) |
446 | return false; |
447 | switch (resp->status) { |
448 | case nfs_ok: |
449 | if (!svcxdr_encode_fhandle(xdr, fhp: &resp->fh)) |
450 | return false; |
451 | if (!svcxdr_encode_fattr(rqstp, xdr, fhp: &resp->fh, stat: &resp->stat)) |
452 | return false; |
453 | break; |
454 | } |
455 | |
456 | return true; |
457 | } |
458 | |
459 | bool |
460 | nfssvc_encode_readlinkres(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
461 | { |
462 | struct nfsd_readlinkres *resp = rqstp->rq_resp; |
463 | struct kvec *head = rqstp->rq_res.head; |
464 | |
465 | if (!svcxdr_encode_stat(xdr, status: resp->status)) |
466 | return false; |
467 | switch (resp->status) { |
468 | case nfs_ok: |
469 | if (xdr_stream_encode_u32(xdr, n: resp->len) < 0) |
470 | return false; |
471 | svcxdr_encode_opaque_pages(rqstp, xdr, pages: &resp->page, base: 0, |
472 | len: resp->len); |
473 | if (svc_encode_result_payload(rqstp, offset: head->iov_len, length: resp->len) < 0) |
474 | return false; |
475 | break; |
476 | } |
477 | |
478 | return true; |
479 | } |
480 | |
481 | bool |
482 | nfssvc_encode_readres(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
483 | { |
484 | struct nfsd_readres *resp = rqstp->rq_resp; |
485 | struct kvec *head = rqstp->rq_res.head; |
486 | |
487 | if (!svcxdr_encode_stat(xdr, status: resp->status)) |
488 | return false; |
489 | switch (resp->status) { |
490 | case nfs_ok: |
491 | if (!svcxdr_encode_fattr(rqstp, xdr, fhp: &resp->fh, stat: &resp->stat)) |
492 | return false; |
493 | if (xdr_stream_encode_u32(xdr, n: resp->count) < 0) |
494 | return false; |
495 | svcxdr_encode_opaque_pages(rqstp, xdr, pages: resp->pages, |
496 | base: rqstp->rq_res.page_base, |
497 | len: resp->count); |
498 | if (svc_encode_result_payload(rqstp, offset: head->iov_len, length: resp->count) < 0) |
499 | return false; |
500 | break; |
501 | } |
502 | |
503 | return true; |
504 | } |
505 | |
506 | bool |
507 | nfssvc_encode_readdirres(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
508 | { |
509 | struct nfsd_readdirres *resp = rqstp->rq_resp; |
510 | struct xdr_buf *dirlist = &resp->dirlist; |
511 | |
512 | if (!svcxdr_encode_stat(xdr, status: resp->status)) |
513 | return false; |
514 | switch (resp->status) { |
515 | case nfs_ok: |
516 | svcxdr_encode_opaque_pages(rqstp, xdr, pages: dirlist->pages, base: 0, |
517 | len: dirlist->len); |
518 | /* no more entries */ |
519 | if (xdr_stream_encode_item_absent(xdr) < 0) |
520 | return false; |
521 | if (xdr_stream_encode_bool(xdr, n: resp->common.err == nfserr_eof) < 0) |
522 | return false; |
523 | break; |
524 | } |
525 | |
526 | return true; |
527 | } |
528 | |
529 | bool |
530 | nfssvc_encode_statfsres(struct svc_rqst *rqstp, struct xdr_stream *xdr) |
531 | { |
532 | struct nfsd_statfsres *resp = rqstp->rq_resp; |
533 | struct kstatfs *stat = &resp->stats; |
534 | __be32 *p; |
535 | |
536 | if (!svcxdr_encode_stat(xdr, status: resp->status)) |
537 | return false; |
538 | switch (resp->status) { |
539 | case nfs_ok: |
540 | p = xdr_reserve_space(xdr, XDR_UNIT * 5); |
541 | if (!p) |
542 | return false; |
543 | *p++ = cpu_to_be32(NFSSVC_MAXBLKSIZE_V2); |
544 | *p++ = cpu_to_be32(stat->f_bsize); |
545 | *p++ = cpu_to_be32(stat->f_blocks); |
546 | *p++ = cpu_to_be32(stat->f_bfree); |
547 | *p = cpu_to_be32(stat->f_bavail); |
548 | break; |
549 | } |
550 | |
551 | return true; |
552 | } |
553 | |
554 | /** |
555 | * nfssvc_encode_nfscookie - Encode a directory offset cookie |
556 | * @resp: readdir result context |
557 | * @offset: offset cookie to encode |
558 | * |
559 | * The buffer space for the offset cookie has already been reserved |
560 | * by svcxdr_encode_entry_common(). |
561 | */ |
562 | void nfssvc_encode_nfscookie(struct nfsd_readdirres *resp, u32 offset) |
563 | { |
564 | __be32 cookie = cpu_to_be32(offset); |
565 | |
566 | if (!resp->cookie_offset) |
567 | return; |
568 | |
569 | write_bytes_to_xdr_buf(&resp->dirlist, resp->cookie_offset, &cookie, |
570 | sizeof(cookie)); |
571 | resp->cookie_offset = 0; |
572 | } |
573 | |
574 | static bool |
575 | svcxdr_encode_entry_common(struct nfsd_readdirres *resp, const char *name, |
576 | int namlen, loff_t offset, u64 ino) |
577 | { |
578 | struct xdr_buf *dirlist = &resp->dirlist; |
579 | struct xdr_stream *xdr = &resp->xdr; |
580 | |
581 | if (xdr_stream_encode_item_present(xdr) < 0) |
582 | return false; |
583 | /* fileid */ |
584 | if (xdr_stream_encode_u32(xdr, n: (u32)ino) < 0) |
585 | return false; |
586 | /* name */ |
587 | if (xdr_stream_encode_opaque(xdr, ptr: name, min(namlen, NFS2_MAXNAMLEN)) < 0) |
588 | return false; |
589 | /* cookie */ |
590 | resp->cookie_offset = dirlist->len; |
591 | if (xdr_stream_encode_u32(xdr, n: ~0U) < 0) |
592 | return false; |
593 | |
594 | return true; |
595 | } |
596 | |
597 | /** |
598 | * nfssvc_encode_entry - encode one NFSv2 READDIR entry |
599 | * @data: directory context |
600 | * @name: name of the object to be encoded |
601 | * @namlen: length of that name, in bytes |
602 | * @offset: the offset of the previous entry |
603 | * @ino: the fileid of this entry |
604 | * @d_type: unused |
605 | * |
606 | * Return values: |
607 | * %0: Entry was successfully encoded. |
608 | * %-EINVAL: An encoding problem occured, secondary status code in resp->common.err |
609 | * |
610 | * On exit, the following fields are updated: |
611 | * - resp->xdr |
612 | * - resp->common.err |
613 | * - resp->cookie_offset |
614 | */ |
615 | int nfssvc_encode_entry(void *data, const char *name, int namlen, |
616 | loff_t offset, u64 ino, unsigned int d_type) |
617 | { |
618 | struct readdir_cd *ccd = data; |
619 | struct nfsd_readdirres *resp = container_of(ccd, |
620 | struct nfsd_readdirres, |
621 | common); |
622 | unsigned int starting_length = resp->dirlist.len; |
623 | |
624 | /* The offset cookie for the previous entry */ |
625 | nfssvc_encode_nfscookie(resp, offset); |
626 | |
627 | if (!svcxdr_encode_entry_common(resp, name, namlen, offset, ino)) |
628 | goto out_toosmall; |
629 | |
630 | xdr_commit_encode(xdr: &resp->xdr); |
631 | resp->common.err = nfs_ok; |
632 | return 0; |
633 | |
634 | out_toosmall: |
635 | resp->cookie_offset = 0; |
636 | resp->common.err = nfserr_toosmall; |
637 | resp->dirlist.len = starting_length; |
638 | return -EINVAL; |
639 | } |
640 | |
641 | /* |
642 | * XDR release functions |
643 | */ |
644 | void nfssvc_release_attrstat(struct svc_rqst *rqstp) |
645 | { |
646 | struct nfsd_attrstat *resp = rqstp->rq_resp; |
647 | |
648 | fh_put(&resp->fh); |
649 | } |
650 | |
651 | void nfssvc_release_diropres(struct svc_rqst *rqstp) |
652 | { |
653 | struct nfsd_diropres *resp = rqstp->rq_resp; |
654 | |
655 | fh_put(&resp->fh); |
656 | } |
657 | |
658 | void nfssvc_release_readres(struct svc_rqst *rqstp) |
659 | { |
660 | struct nfsd_readres *resp = rqstp->rq_resp; |
661 | |
662 | fh_put(&resp->fh); |
663 | } |
664 | |