Print this page
NEX-14051 Be careful with RPC groups
Reviewed by: Rick McNeal <rick.mcneal@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
8085 Handle RPC groups better
Reviewed by: "Joshua M. Clulow" <josh@sysmgr.org>
Reviewed by: Paul Dagnelie <pcd@delphix.com>
Reviewed by: Jerry Jelinek <jerry.jelinek@joyent.com>
Approved by: Dan McDonald <danmcd@omniti.com>
OS-20 share_nfs(1m) charset handling is unreliable
OS-22 Page fault at nfscmd_dropped_entrysize+0x1e()
OS-23 NFSv2/3/4: READDIR responses are inconsistent when charset conversion fails
OS-24 rfs3_readdir(): Issues related to nfscmd_convdirent()
Reviewed by: Jan Kryl <jan.kryl@nexenta.com>
Reviewed by: Gordon Ross <gordon.ross@nexenta.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/fs/nfs/nfs_log_xdr.c
+++ new/usr/src/uts/common/fs/nfs/nfs_log_xdr.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
|
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright 2017 Joyent Inc
23 23 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
24 24 * Use is subject to license terms.
25 25 */
26 26
27 +/*
28 + * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
29 + */
30 +
27 31 #include <sys/types.h>
28 32 #include <sys/systm.h>
29 33 #include <sys/cmn_err.h>
30 34 #include <sys/kmem.h>
31 35 #include <sys/cred.h>
32 36 #include <sys/dirent.h>
33 37 #include <sys/debug.h>
34 38 #include <rpc/types.h>
35 39 #include <nfs/nfs.h>
36 40 #include <nfs/export.h>
37 41 #include <rpc/svc.h>
38 42 #include <rpc/xdr.h>
39 43 #include <rpc/rpcb_prot.h>
40 44 #include <rpc/clnt.h>
41 45 #include <nfs/nfs_log.h>
42 46
43 47 /*
44 48 * nfsl_principal_name_get - extracts principal from transport struct.
45 49 * Based on "uts/common/rpc/sec/sec_svc.c" function sec_svc_getcred.
46 50 */
47 51 static char *
48 52 nfsl_principal_name_get(struct svc_req *req)
49 53 {
50 54 char *principal_name = NULL;
51 55 struct authdes_cred *adc;
52 56 rpc_gss_rawcred_t *rcred;
53 57 rpc_gss_ucred_t *ucred;
54 58 void *cookie;
55 59
56 60 switch (req->rq_cred.oa_flavor) {
57 61 case AUTH_UNIX:
58 62 case AUTH_NONE:
59 63 /* no principal name provided */
60 64 break;
61 65
62 66 case AUTH_DES:
63 67 adc = (struct authdes_cred *)req->rq_clntcred;
64 68 CTASSERT(sizeof (struct authdes_cred) <= RQCRED_SIZE);
65 69 principal_name = adc->adc_fullname.name;
66 70 break;
67 71
68 72 case RPCSEC_GSS:
69 73 (void) rpc_gss_getcred(req, &rcred, &ucred, &cookie);
70 74 principal_name = (caddr_t)rcred->client_principal;
71 75 break;
72 76
73 77 default:
74 78 break;
75 79 }
76 80 return (principal_name);
77 81 }
78 82
79 83 bool_t
80 84 xdr_timestruc32_t(XDR *xdrs, timestruc32_t *objp)
81 85 {
82 86 if (!xdr_int(xdrs, &objp->tv_sec))
83 87 return (FALSE);
84 88 return (xdr_int(xdrs, &objp->tv_nsec));
85 89 }
86 90
87 91 bool_t
88 92 xdr_nfsstat(XDR *xdrs, nfsstat *objp)
89 93 {
90 94 return (xdr_enum(xdrs, (enum_t *)objp));
91 95 }
92 96
93 97 bool_t
94 98 xdr_nfslog_sharefsres(XDR *xdrs, nfslog_sharefsres *objp)
95 99 {
96 100 return (xdr_nfsstat(xdrs, objp));
97 101 }
98 102
99 103 bool_t
100 104 xdr_nfsreadargs(XDR *xdrs, struct nfsreadargs *ra)
101 105 {
102 106 if (xdr_fhandle(xdrs, &ra->ra_fhandle) &&
103 107 xdr_u_int(xdrs, &ra->ra_offset) &&
104 108 xdr_u_int(xdrs, &ra->ra_count) &&
105 109 xdr_u_int(xdrs, &ra->ra_totcount)) {
106 110 return (TRUE);
107 111 }
108 112 return (FALSE);
109 113 }
110 114
111 115 bool_t
112 116 xdr_nfslog_nfsreadargs(xdrs, objp)
113 117 register XDR *xdrs;
114 118 nfslog_nfsreadargs *objp;
115 119 {
116 120 return (xdr_nfsreadargs(xdrs, objp));
117 121 }
118 122
119 123 /*
120 124 * Current version (2 and up) xdr function for buffer header
121 125 * uses 64-bit offset (relocated to an 8 byte boundary), version 1 uses 32.
122 126 */
123 127 bool_t
124 128 xdr_nfslog_buffer_header(xdrs, objp)
125 129 register XDR *xdrs;
126 130 nfslog_buffer_header *objp;
127 131 {
128 132 if (!xdr_u_int(xdrs, &objp->bh_length))
129 133 return (FALSE);
130 134 if (!xdr_rpcvers(xdrs, &objp->bh_version))
131 135 return (FALSE);
132 136 ASSERT(objp->bh_version > 1);
133 137 if (!xdr_u_longlong_t(xdrs, &objp->bh_offset))
134 138 return (FALSE);
135 139 if (!xdr_u_int(xdrs, &objp->bh_flags))
136 140 return (FALSE);
137 141 return (xdr_timestruc32_t(xdrs, &objp->bh_timestamp));
138 142 }
139 143
140 144 /*
141 145 * Hand coded xdr functions for the kernel ENCODE path
142 146 */
143 147
144 148 bool_t
145 149 xdr_nfslog_request_record(
146 150 XDR *xdrs,
147 151 struct exportinfo *exi,
148 152 struct svc_req *req,
149 153 cred_t *cr,
150 154 struct netbuf *pnb,
151 155 unsigned int reclen,
152 156 unsigned int record_id)
153 157 {
154 158 char *netid = NULL;
155 159 char *prin = NULL;
156 160 unsigned int flavor;
157 161 timestruc32_t ts;
158 162 timestruc_t now;
159 163 uid_t ruid;
160 164 gid_t rgid;
161 165
162 166 if (xdrs->x_op != XDR_ENCODE)
163 167 return (FALSE);
164 168
165 169 /*
166 170 * First we do the encoding of the record header
167 171 */
168 172 if (!xdr_u_int(xdrs, &reclen))
169 173 return (FALSE);
170 174 if (!xdr_u_int(xdrs, &record_id))
171 175 return (FALSE);
172 176 if (!xdr_rpcprog(xdrs, &req->rq_prog))
173 177 return (FALSE);
174 178 if (!xdr_rpcproc(xdrs, &req->rq_proc))
175 179 return (FALSE);
176 180 if (!xdr_rpcvers(xdrs, &req->rq_vers))
177 181 return (FALSE);
178 182 flavor = req->rq_cred.oa_flavor;
179 183 if (!xdr_u_int(xdrs, &flavor))
180 184 return (FALSE);
181 185
182 186 gethrestime(&now);
183 187 TIMESPEC_TO_TIMESPEC32(&ts, &now);
184 188 if (!xdr_timestruc32_t(xdrs, &ts))
185 189 return (FALSE);
186 190
187 191 /* This code depends on us doing XDR_ENCODE ops only */
188 192 ruid = crgetruid(cr);
189 193 if (!xdr_uid_t(xdrs, &ruid))
190 194 return (FALSE);
191 195 rgid = crgetrgid(cr);
192 196 if (!xdr_gid_t(xdrs, &rgid))
193 197 return (FALSE);
194 198
195 199 /*
196 200 * Now encode the rest of the request record (but not args/res)
197 201 */
198 202 prin = nfsl_principal_name_get(req);
199 203 if (!xdr_string(xdrs, &prin, ~0))
200 204 return (FALSE);
201 205 if (req->rq_xprt)
202 206 netid = svc_getnetid(req->rq_xprt);
203 207 if (!xdr_string(xdrs, &netid, ~0))
204 208 return (FALSE);
205 209 if (!xdr_string(xdrs, &exi->exi_export.ex_tag, ~0))
206 210 return (FALSE);
207 211 return (xdr_netbuf(xdrs, pnb));
208 212 }
209 213
210 214 bool_t
211 215 xdr_nfslog_sharefsargs(XDR *xdrs, struct exportinfo *objp)
212 216 {
213 217
214 218 if (xdrs->x_op != XDR_ENCODE)
215 219 return (FALSE);
216 220
217 221 if (!xdr_int(xdrs, &objp->exi_export.ex_flags))
218 222 return (FALSE);
219 223 if (!xdr_u_int(xdrs, &objp->exi_export.ex_anon))
220 224 return (FALSE);
221 225 if (!xdr_string(xdrs, &objp->exi_export.ex_path, ~0))
222 226 return (FALSE);
223 227 return (xdr_fhandle(xdrs, &objp->exi_fh));
224 228 }
225 229
226 230 bool_t
227 231 xdr_nfslog_getfhargs(XDR *xdrs, nfslog_getfhargs *objp)
228 232 {
229 233 if (!xdr_fhandle(xdrs, &objp->gfh_fh_buf))
230 234 return (FALSE);
231 235 return (xdr_string(xdrs, &objp->gfh_path, ~0));
232 236 }
233 237
234 238 bool_t
235 239 xdr_nfslog_drok(XDR *xdrs, struct nfsdrok *objp)
236 240 {
237 241 return (xdr_fhandle(xdrs, &objp->drok_fhandle));
238 242 }
239 243
240 244 bool_t
241 245 xdr_nfslog_diropres(XDR *xdrs, struct nfsdiropres *objp)
242 246 {
243 247 if (!xdr_nfsstat(xdrs, &objp->dr_status))
244 248 return (FALSE);
245 249 switch (objp->dr_status) {
246 250 case NFS_OK:
247 251 if (!xdr_nfslog_drok(xdrs, &objp->dr_drok))
248 252 return (FALSE);
249 253 break;
250 254 }
251 255 return (TRUE);
252 256 }
253 257
254 258 bool_t
255 259 xdr_nfslog_getattrres(XDR *xdrs, struct nfsattrstat *objp)
256 260 {
257 261 return (xdr_nfsstat(xdrs, &objp->ns_status));
258 262 }
259 263
260 264 bool_t
261 265 xdr_nfslog_rrok(XDR *xdrs, struct nfsrrok *objp)
262 266 {
263 267 if (!xdr_u_int(xdrs, &objp->rrok_attr.na_size))
264 268 return (FALSE);
265 269 return (xdr_u_int(xdrs, &objp->rrok_count));
266 270 }
267 271
268 272 bool_t
269 273 xdr_nfslog_rdresult(XDR *xdrs, struct nfsrdresult *objp)
270 274 {
271 275 if (!xdr_nfsstat(xdrs, &objp->rr_status))
272 276 return (FALSE);
273 277 switch (objp->rr_status) {
274 278 case NFS_OK:
275 279 if (!xdr_nfslog_rrok(xdrs, &objp->rr_u.rr_ok_u))
276 280 return (FALSE);
277 281 break;
278 282 }
279 283 return (TRUE);
280 284 }
281 285
282 286 bool_t
283 287 xdr_nfslog_writeargs(XDR *xdrs, struct nfswriteargs *objp)
284 288 {
285 289 if (!xdr_fhandle(xdrs, &objp->wa_args->otw_wa_fhandle))
286 290 return (FALSE);
287 291 if (!xdr_u_int(xdrs, &objp->wa_args->otw_wa_begoff))
288 292 return (FALSE);
289 293 if (!xdr_u_int(xdrs, &objp->wa_args->otw_wa_offset))
290 294 return (FALSE);
291 295 if (!xdr_u_int(xdrs, &objp->wa_args->otw_wa_totcount))
292 296 return (FALSE);
293 297 return (xdr_u_int(xdrs, &objp->wa_count));
294 298 }
295 299
296 300 bool_t
297 301 xdr_nfslog_writeresult(XDR *xdrs, struct nfsattrstat *objp)
298 302 {
299 303 if (!xdr_nfsstat(xdrs, &objp->ns_status))
300 304 return (FALSE);
301 305 switch (objp->ns_status) {
302 306 case NFS_OK:
303 307 if (!xdr_u_int(xdrs, &objp->ns_u.ns_attr_u.na_size))
304 308 return (FALSE);
305 309 break;
306 310 }
307 311 return (TRUE);
308 312 }
309 313
310 314 bool_t
311 315 xdr_nfslog_diropargs(XDR *xdrs, struct nfsdiropargs *objp)
312 316 {
313 317 if (!xdr_fhandle(xdrs, objp->da_fhandle))
314 318 return (FALSE);
315 319 return (xdr_string(xdrs, &objp->da_name, ~0));
316 320 }
317 321
318 322 bool_t
319 323 xdr_nfslog_sattr(XDR *xdrs, struct nfssattr *objp)
320 324 {
321 325 if (!xdr_u_int(xdrs, &objp->sa_mode))
322 326 return (FALSE);
323 327 if (!xdr_u_int(xdrs, &objp->sa_uid))
324 328 return (FALSE);
325 329 if (!xdr_u_int(xdrs, &objp->sa_gid))
326 330 return (FALSE);
327 331 if (!xdr_u_int(xdrs, &objp->sa_size))
328 332 return (FALSE);
329 333 if (!xdr_nfs2_timeval(xdrs, (nfs2_timeval *)&objp->sa_atime))
330 334 return (FALSE);
331 335 return (xdr_nfs2_timeval(xdrs, (nfs2_timeval *)&objp->sa_mtime));
332 336 }
333 337
334 338 bool_t
335 339 xdr_nfslog_createargs(XDR *xdrs, struct nfscreatargs *objp)
336 340 {
337 341 if (!xdr_nfslog_sattr(xdrs, objp->ca_sa))
338 342 return (FALSE);
339 343 return (xdr_nfslog_diropargs(xdrs, &objp->ca_da));
340 344 }
341 345
342 346 bool_t
343 347 xdr_nfslog_setattrargs(XDR *xdrs, struct nfssaargs *objp)
344 348 {
345 349 if (!xdr_fhandle(xdrs, &objp->saa_fh))
346 350 return (FALSE);
347 351 return (xdr_nfslog_sattr(xdrs, &objp->saa_sa));
348 352 }
349 353
350 354 bool_t
351 355 xdr_nfslog_rdlnres(XDR *xdrs, struct nfsrdlnres *objp)
352 356 {
353 357 caddr_t lnres = NULL;
354 358 int count;
355 359
356 360 if (!xdr_nfsstat(xdrs, &objp->rl_status))
357 361 return (FALSE);
358 362 switch (objp->rl_status) {
359 363 case NFS_OK:
360 364 if ((count = objp->rl_u.rl_srok_u.srok_count) != 0) {
361 365 /*
362 366 * allocate extra element for terminating NULL
363 367 */
364 368 lnres = kmem_alloc(count + 1, KM_SLEEP);
365 369 bcopy(objp->rl_u.rl_srok_u.srok_data, lnres, count);
366 370 lnres[count] = '\0';
367 371 }
368 372 if (!xdr_string(xdrs, &lnres, ~0)) {
369 373 if (lnres != NULL)
370 374 kmem_free(lnres, count + 1);
371 375 return (FALSE);
372 376 }
373 377 if (lnres != NULL)
374 378 kmem_free(lnres, count + 1);
375 379 break;
376 380 }
377 381 return (TRUE);
378 382 }
379 383
380 384 bool_t
381 385 xdr_nfslog_rnmargs(XDR *xdrs, struct nfsrnmargs *objp)
382 386 {
383 387 if (!xdr_nfslog_diropargs(xdrs, &objp->rna_from))
384 388 return (FALSE);
385 389 return (xdr_nfslog_diropargs(xdrs, &objp->rna_to));
386 390 }
387 391
388 392 bool_t
389 393 xdr_nfslog_linkargs(XDR *xdrs, struct nfslinkargs *objp)
390 394 {
391 395 if (!xdr_fhandle(xdrs, objp->la_from))
392 396 return (FALSE);
393 397 return (xdr_nfslog_diropargs(xdrs, &objp->la_to));
394 398 }
395 399
396 400 bool_t
397 401 xdr_nfslog_symlinkargs(XDR *xdrs, struct nfsslargs *objp)
398 402 {
399 403 if (!xdr_nfslog_diropargs(xdrs, &objp->sla_from))
400 404 return (FALSE);
401 405 if (!xdr_string(xdrs, &objp->sla_tnm, ~0))
402 406 return (FALSE);
403 407 return (xdr_nfslog_sattr(xdrs, objp->sla_sa));
404 408 }
405 409
406 410 bool_t
407 411 xdr_nfslog_statfs(XDR *xdrs, struct nfsstatfs *objp)
408 412 {
409 413 return (xdr_nfsstat(xdrs, &objp->fs_status));
410 414 }
411 415
412 416 bool_t
413 417 xdr_nfslog_rddirargs(XDR *xdrs, struct nfsrddirargs *objp)
414 418 {
415 419 if (!xdr_fhandle(xdrs, &objp->rda_fh))
416 420 return (FALSE);
417 421 if (!xdr_u_int(xdrs, &objp->rda_offset))
418 422 return (FALSE);
419 423 return (xdr_u_int(xdrs, &objp->rda_count));
420 424 }
421 425
422 426 bool_t
423 427 xdr_nfslog_rdok(XDR *xdrs, struct nfsrdok *objp)
424 428 {
425 429 if (!xdr_u_int(xdrs, &objp->rdok_offset))
426 430 return (FALSE);
427 431 if (!xdr_u_int(xdrs, &objp->rdok_size))
428 432 return (FALSE);
429 433 return (xdr_bool(xdrs, &objp->rdok_eof));
430 434 }
431 435
432 436 bool_t
433 437 xdr_nfslog_rddirres(XDR *xdrs, struct nfsrddirres *objp)
434 438 {
435 439 if (!xdr_nfsstat(xdrs, &objp->rd_status))
436 440 return (FALSE);
437 441 switch (objp->rd_status) {
438 442 case NFS_OK:
439 443 if (!xdr_nfslog_rdok(xdrs, &objp->rd_u.rd_rdok_u))
440 444 return (FALSE);
441 445 break;
442 446 }
443 447 return (TRUE);
444 448 }
445 449
446 450 bool_t
447 451 xdr_nfslog_diropargs3(XDR *xdrs, diropargs3 *objp)
448 452 {
449 453 char *name;
450 454
451 455 if (!xdr_nfslog_nfs_fh3(xdrs, &objp->dir))
452 456 return (FALSE);
453 457 if (objp->name != nfs3nametoolong)
454 458 name = objp->name;
455 459 else {
456 460 /*
457 461 * The name is not defined, set it to the
458 462 * zero length string.
459 463 */
460 464 name = NULL;
461 465 }
462 466 return (xdr_string(xdrs, &name, ~0));
463 467 }
464 468
465 469 bool_t
466 470 xdr_nfslog_LOOKUP3res(XDR *xdrs, LOOKUP3res *objp)
467 471 {
468 472 if (!xdr_enum(xdrs, (enum_t *)&objp->status))
469 473 return (FALSE);
470 474 switch (objp->status) {
471 475 case NFS3_OK:
472 476 if (!xdr_nfslog_nfs_fh3(xdrs, &objp->res_u.ok.object))
473 477 return (FALSE);
474 478 break;
475 479 }
476 480 return (TRUE);
477 481 }
478 482
479 483 bool_t
480 484 xdr_set_size3(XDR *xdrs, set_size3 *objp)
481 485 {
482 486 if (!xdr_bool(xdrs, &objp->set_it))
483 487 return (FALSE);
484 488 switch (objp->set_it) {
485 489 case TRUE:
486 490 if (!xdr_uint64(xdrs, &objp->size))
487 491 return (FALSE);
488 492 break;
489 493 }
490 494 return (TRUE);
491 495 }
|
↓ open down ↓ |
455 lines elided |
↑ open up ↑ |
492 496
493 497 bool_t
494 498 xdr_nfslog_createhow3(XDR *xdrs, createhow3 *objp)
495 499 {
496 500 if (!xdr_enum(xdrs, (enum_t *)&objp->mode))
497 501 return (FALSE);
498 502 switch (objp->mode) {
499 503 case UNCHECKED:
500 504 case GUARDED:
501 505 if (!xdr_set_size3(xdrs,
502 - &objp->createhow3_u.obj_attributes.size))
506 + &objp->createhow3_u.obj_attributes.size))
503 507 return (FALSE);
504 508 break;
505 509 case EXCLUSIVE:
506 510 break;
507 511 default:
508 512 return (FALSE);
509 513 }
510 514 return (TRUE);
511 515 }
512 516
513 517 bool_t
514 518 xdr_nfslog_CREATE3args(XDR *xdrs, CREATE3args *objp)
515 519 {
516 520 if (!xdr_nfslog_diropargs3(xdrs, &objp->where))
517 521 return (FALSE);
518 522 return (xdr_nfslog_createhow3(xdrs, &objp->how));
519 523 }
520 524
521 525 bool_t
522 526 xdr_nfslog_CREATE3resok(XDR *xdrs, CREATE3resok *objp)
523 527 {
524 528 return (xdr_post_op_fh3(xdrs, &objp->obj));
525 529 }
526 530
527 531 bool_t
528 532 xdr_nfslog_CREATE3res(XDR *xdrs, CREATE3res *objp)
529 533 {
530 534 if (!xdr_enum(xdrs, (enum_t *)&objp->status))
531 535 return (FALSE);
532 536 switch (objp->status) {
533 537 case NFS3_OK:
534 538 if (!xdr_nfslog_CREATE3resok(xdrs, &objp->res_u.ok))
535 539 return (FALSE);
536 540 break;
537 541 }
538 542 return (TRUE);
539 543 }
540 544
541 545 bool_t
542 546 xdr_nfslog_GETATTR3res(XDR *xdrs, GETATTR3res *objp)
543 547 {
544 548 return (xdr_enum(xdrs, (enum_t *)&objp->status));
545 549 }
546 550
547 551 bool_t
548 552 xdr_nfslog_ACCESS3args(XDR *xdrs, ACCESS3args *objp)
549 553 {
550 554 return (xdr_nfslog_nfs_fh3(xdrs, &objp->object));
551 555 }
552 556
553 557 bool_t
554 558 xdr_nfslog_ACCESS3res(XDR *xdrs, ACCESS3res *objp)
555 559 {
556 560 return (xdr_enum(xdrs, (enum_t *)&objp->status));
557 561 }
558 562
559 563 bool_t
560 564 xdr_nfslog_SETATTR3args(XDR *xdrs, SETATTR3args *objp)
561 565 {
562 566 if (!xdr_nfslog_nfs_fh3(xdrs, &objp->object))
563 567 return (FALSE);
564 568 return (xdr_set_size3(xdrs, &objp->new_attributes.size));
565 569 }
566 570
567 571 bool_t
568 572 xdr_nfslog_SETATTR3res(XDR *xdrs, SETATTR3res *objp)
569 573 {
570 574 return (xdr_enum(xdrs, (enum_t *)&objp->status));
571 575 }
572 576
573 577 bool_t
574 578 xdr_nfslog_READLINK3res(XDR *xdrs, READLINK3res *objp)
575 579 {
576 580 if (!xdr_enum(xdrs, (enum_t *)&objp->status))
577 581 return (FALSE);
578 582 switch (objp->status) {
579 583 case NFS3_OK:
580 584 if (!xdr_string(xdrs, &objp->res_u.ok.data, ~0))
581 585 return (FALSE);
582 586 break;
583 587 }
584 588 return (TRUE);
585 589 }
586 590
587 591 bool_t
588 592 xdr_nfslog_READ3args(XDR *xdrs, READ3args *objp)
589 593 {
590 594 if (!xdr_nfslog_nfs_fh3(xdrs, &objp->file))
591 595 return (FALSE);
592 596 if (!xdr_uint64(xdrs, &objp->offset))
593 597 return (FALSE);
594 598 return (xdr_uint32(xdrs, &objp->count));
595 599 }
596 600
597 601 bool_t
598 602 xdr_nfslog_READ3resok(XDR *xdrs, READ3resok *objp)
599 603 {
600 604 if (!xdr_uint64(xdrs, &objp->file_attributes.attr.size))
601 605 return (FALSE);
602 606 if (!xdr_uint32(xdrs, &objp->count))
603 607 return (FALSE);
604 608 if (!xdr_bool(xdrs, &objp->eof))
605 609 return (FALSE);
606 610 return (xdr_u_int(xdrs, &objp->size));
607 611 }
608 612
609 613 bool_t
610 614 xdr_nfslog_READ3res(XDR *xdrs, READ3res *objp)
611 615 {
612 616 if (!xdr_enum(xdrs, (enum_t *)&objp->status))
613 617 return (FALSE);
614 618 switch (objp->status) {
615 619 case NFS3_OK:
616 620 if (!xdr_nfslog_READ3resok(xdrs, &objp->res_u.ok))
617 621 return (FALSE);
618 622 break;
619 623 }
620 624 return (TRUE);
621 625 }
622 626
623 627 bool_t
624 628 xdr_nfslog_WRITE3args(XDR *xdrs, WRITE3args *objp)
625 629 {
626 630 if (!xdr_nfslog_nfs_fh3(xdrs, &objp->file))
627 631 return (FALSE);
628 632 if (!xdr_uint64(xdrs, &objp->offset))
629 633 return (FALSE);
630 634 if (!xdr_uint32(xdrs, &objp->count))
631 635 return (FALSE);
632 636 return (xdr_enum(xdrs, (enum_t *)&objp->stable));
633 637 }
634 638
635 639 bool_t
636 640 xdr_nfslog_WRITE3resok(XDR *xdrs, WRITE3resok *objp)
637 641 {
638 642 if (!xdr_uint64(xdrs, &objp->file_wcc.after.attr.size))
639 643 return (FALSE);
640 644 if (!xdr_uint32(xdrs, &objp->count))
641 645 return (FALSE);
642 646 return (xdr_enum(xdrs, (enum_t *)&objp->committed));
643 647 }
644 648
645 649 bool_t
646 650 xdr_nfslog_WRITE3res(XDR *xdrs, WRITE3res *objp)
647 651 {
648 652 if (!xdr_enum(xdrs, (enum_t *)&objp->status))
649 653 return (FALSE);
650 654 switch (objp->status) {
651 655 case NFS3_OK:
652 656 if (!xdr_nfslog_WRITE3resok(xdrs, &objp->res_u.ok))
653 657 return (FALSE);
654 658 break;
655 659 }
656 660 return (TRUE);
657 661 }
658 662
659 663 bool_t
660 664 xdr_nfslog_MKDIR3args(XDR *xdrs, MKDIR3args *objp)
661 665 {
662 666 return (xdr_nfslog_diropargs3(xdrs, &objp->where));
663 667 }
664 668
665 669 bool_t
666 670 xdr_nfslog_MKDIR3res(XDR *xdrs, MKDIR3res *objp)
667 671 {
668 672 if (!xdr_enum(xdrs, (enum_t *)&objp->status))
669 673 return (FALSE);
670 674 switch (objp->status) {
671 675 case NFS3_OK:
672 676 if (!xdr_post_op_fh3(xdrs, &objp->res_u.ok.obj))
673 677 return (FALSE);
674 678 break;
675 679 }
676 680 return (TRUE);
677 681 }
678 682
679 683 bool_t
680 684 xdr_nfslog_SYMLINK3args(XDR *xdrs, SYMLINK3args *objp)
681 685 {
682 686 if (!xdr_nfslog_diropargs3(xdrs, &objp->where))
683 687 return (FALSE);
684 688 return (xdr_string(xdrs, &objp->symlink.symlink_data, ~0));
685 689 }
686 690
687 691 bool_t
688 692 xdr_nfslog_SYMLINK3res(XDR *xdrs, SYMLINK3res *objp)
689 693 {
690 694 if (!xdr_enum(xdrs, (enum_t *)&objp->status))
691 695 return (FALSE);
692 696 switch (objp->status) {
693 697 case NFS3_OK:
694 698 if (!xdr_post_op_fh3(xdrs, &objp->res_u.ok.obj))
695 699 return (FALSE);
696 700 break;
697 701 }
698 702 return (TRUE);
699 703 }
700 704
701 705 bool_t
702 706 xdr_nfslog_MKNOD3args(XDR *xdrs, MKNOD3args *objp)
703 707 {
704 708 if (!xdr_nfslog_diropargs3(xdrs, &objp->where))
705 709 return (FALSE);
706 710 return (xdr_enum(xdrs, (enum_t *)&objp->what.type));
707 711 }
708 712
709 713 bool_t
710 714 xdr_nfslog_MKNOD3res(XDR *xdrs, MKNOD3res *objp)
711 715 {
712 716 if (!xdr_enum(xdrs, (enum_t *)&objp->status))
713 717 return (FALSE);
714 718 switch (objp->status) {
715 719 case NFS3_OK:
716 720 if (!xdr_post_op_fh3(xdrs, &objp->res_u.ok.obj))
717 721 return (FALSE);
718 722 break;
719 723 }
720 724 return (TRUE);
721 725 }
722 726
723 727 bool_t
724 728 xdr_nfslog_REMOVE3args(XDR *xdrs, REMOVE3args *objp)
725 729 {
726 730 return (xdr_nfslog_diropargs3(xdrs, &objp->object));
727 731 }
728 732
729 733 bool_t
730 734 xdr_nfslog_REMOVE3res(XDR *xdrs, REMOVE3res *objp)
731 735 {
732 736 return (xdr_enum(xdrs, (enum_t *)&objp->status));
733 737 }
734 738
735 739 bool_t
736 740 xdr_nfslog_RMDIR3args(XDR *xdrs, RMDIR3args *objp)
737 741 {
738 742 return (xdr_nfslog_diropargs3(xdrs, &objp->object));
739 743 }
740 744
741 745 bool_t
742 746 xdr_nfslog_RMDIR3res(XDR *xdrs, RMDIR3res *objp)
743 747 {
744 748 return (xdr_enum(xdrs, (enum_t *)&objp->status));
745 749 }
746 750
747 751 bool_t
748 752 xdr_nfslog_RENAME3args(XDR *xdrs, RENAME3args *objp)
749 753 {
750 754 if (!xdr_nfslog_diropargs3(xdrs, &objp->from))
751 755 return (FALSE);
752 756 return (xdr_nfslog_diropargs3(xdrs, &objp->to));
753 757 }
754 758
755 759 bool_t
756 760 xdr_nfslog_RENAME3res(XDR *xdrs, RENAME3res *objp)
757 761 {
758 762 return (xdr_enum(xdrs, (enum_t *)&objp->status));
759 763 }
760 764
761 765 bool_t
762 766 xdr_nfslog_LINK3args(XDR *xdrs, LINK3args *objp)
763 767 {
764 768 if (!xdr_nfslog_nfs_fh3(xdrs, &objp->file))
765 769 return (FALSE);
766 770 return (xdr_nfslog_diropargs3(xdrs, &objp->link));
767 771 }
768 772
769 773 bool_t
770 774 xdr_nfslog_LINK3res(XDR *xdrs, LINK3res *objp)
771 775 {
772 776 return (xdr_enum(xdrs, (enum_t *)&objp->status));
773 777 }
774 778
775 779 bool_t
776 780 xdr_nfslog_READDIR3args(XDR *xdrs, READDIR3args *objp)
777 781 {
778 782 return (xdr_nfslog_nfs_fh3(xdrs, &objp->dir));
779 783 }
780 784
781 785 bool_t
782 786 xdr_nfslog_READDIR3res(XDR *xdrs, READDIR3res *objp)
783 787 {
784 788 return (xdr_enum(xdrs, (enum_t *)&objp->status));
785 789 }
786 790
|
↓ open down ↓ |
274 lines elided |
↑ open up ↑ |
787 791 bool_t
788 792 xdr_nfslog_READDIRPLUS3args(XDR *xdrs, READDIRPLUS3args *objp)
789 793 {
790 794 if (!xdr_nfslog_nfs_fh3(xdrs, &objp->dir))
791 795 return (FALSE);
792 796 if (!xdr_uint32(xdrs, &objp->dircount))
793 797 return (FALSE);
794 798 return (xdr_uint32(xdrs, &objp->maxcount));
795 799 }
796 800
797 -#ifdef nextdp
798 -#undef nextdp
799 -#endif
800 -#define nextdp(dp) ((struct dirent64 *)((char *)(dp) + (dp)->d_reclen))
801 -
802 801 bool_t
803 802 xdr_nfslog_READDIRPLUS3resok(XDR *xdrs, READDIRPLUS3resok *objp)
804 803 {
805 - struct dirent64 *dp;
804 + entryplus3 *entry;
806 805 bool_t true = TRUE;
807 806 bool_t false = FALSE;
808 - int nents;
809 - char *name;
810 - entryplus3_info *infop;
811 807
812 - dp = (struct dirent64 *)objp->reply.entries;
813 - nents = objp->size;
814 - infop = objp->infop;
815 - while (nents > 0) {
816 - if (dp->d_reclen == 0)
817 - return (FALSE);
818 - if (dp->d_ino == 0) {
819 - dp = nextdp(dp);
820 - infop++;
821 - nents--;
822 - continue;
823 - }
824 - name = dp->d_name;
825 -
808 + for (entry = objp->reply.entries; entry != NULL;
809 + entry = entry->nextentry) {
826 810 if (!xdr_bool(xdrs, &true) ||
827 - !xdr_post_op_fh3(xdrs, &infop->fh) ||
828 - !xdr_string(xdrs, &name, ~0)) {
811 + !xdr_post_op_fh3(xdrs, &entry->name_handle) ||
812 + !xdr_string(xdrs, &entry->name, MAXPATHLEN)) {
829 813 return (FALSE);
830 814 }
831 - dp = nextdp(dp);
832 - infop++;
833 - nents--;
834 815 }
816 +
835 817 if (!xdr_bool(xdrs, &false))
836 818 return (FALSE);
837 819
838 820 return (xdr_bool(xdrs, &objp->reply.eof));
839 821 }
840 822
841 823 bool_t
842 824 xdr_nfslog_READDIRPLUS3res(XDR *xdrs, READDIRPLUS3res *objp)
843 825 {
844 826 if (!xdr_enum(xdrs, (enum_t *)&objp->status))
845 827 return (FALSE);
846 828 switch (objp->status) {
847 829 case NFS3_OK:
848 830 if (!xdr_nfslog_READDIRPLUS3resok(xdrs, &objp->res_u.ok))
849 831 return (FALSE);
850 832 break;
851 833 }
852 834 return (TRUE);
853 835 }
854 836
855 837 bool_t
856 838 xdr_nfslog_FSSTAT3args(XDR *xdrs, FSSTAT3args *objp)
857 839 {
858 840 return (xdr_nfslog_nfs_fh3(xdrs, &objp->fsroot));
859 841 }
860 842
861 843 bool_t
862 844 xdr_nfslog_FSSTAT3res(XDR *xdrs, FSSTAT3res *objp)
863 845 {
864 846 return (xdr_enum(xdrs, (enum_t *)&objp->status));
865 847 }
866 848
867 849 bool_t
868 850 xdr_nfslog_FSINFO3args(XDR *xdrs, FSINFO3args *objp)
869 851 {
870 852 return (xdr_nfslog_nfs_fh3(xdrs, &objp->fsroot));
871 853 }
872 854
873 855 bool_t
874 856 xdr_nfslog_FSINFO3res(XDR *xdrs, FSINFO3res *objp)
875 857 {
876 858 return (xdr_enum(xdrs, (enum_t *)&objp->status));
877 859 }
878 860
879 861 bool_t
880 862 xdr_nfslog_PATHCONF3args(XDR *xdrs, PATHCONF3args *objp)
881 863 {
882 864 return (xdr_nfslog_nfs_fh3(xdrs, &objp->object));
883 865 }
884 866
885 867 bool_t
886 868 xdr_nfslog_PATHCONF3res(XDR *xdrs, PATHCONF3res *objp)
887 869 {
888 870 return (xdr_enum(xdrs, (enum_t *)&objp->status));
889 871 }
890 872
891 873 bool_t
892 874 xdr_nfslog_COMMIT3args(XDR *xdrs, COMMIT3args *objp)
893 875 {
894 876 if (!xdr_nfslog_nfs_fh3(xdrs, &objp->file))
895 877 return (FALSE);
896 878 if (!xdr_uint64(xdrs, &objp->offset))
897 879 return (FALSE);
898 880 return (xdr_uint32(xdrs, &objp->count));
899 881 }
900 882
901 883 bool_t
902 884 xdr_nfslog_COMMIT3res(XDR *xdrs, COMMIT3res *objp)
903 885 {
904 886 return (xdr_enum(xdrs, (enum_t *)&objp->status));
905 887 }
906 888
907 889 bool_t
908 890 xdr_nfslog_nfs_fh3(XDR *xdrs, nfs_fh3 *objp)
909 891 {
910 892 nfs_fh3 fh;
911 893
912 894 if (objp->fh3_len > NFS_FHMAXDATA || objp->fh3_xlen > NFS_FHMAXDATA) {
913 895 fh = *objp;
914 896 fh.fh3_len = NFS_FHMAXDATA;
915 897 fh.fh3_xlen = NFS_FHMAXDATA;
916 898 fh.fh3_length = NFS3_OLDFHSIZE;
917 899 return (xdr_nfs_fh3_server(xdrs, &fh));
918 900 }
919 901 return (xdr_nfs_fh3_server(xdrs, objp));
920 902 }
|
↓ open down ↓ |
76 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX