kernel/fs/nfs/nfs_log_xdr.c

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