1 /* $NetBSD: xdr_func.c,v 1.1.1.2 2009/03/20 20:26:56 christos Exp $ */ 2 3 /* 4 * Copyright (c) 1997-2009 Erez Zadok 5 * Copyright (c) 1990 Jan-Simon Pendry 6 * Copyright (c) 1990 Imperial College of Science, Technology & Medicine 7 * Copyright (c) 1990 The Regents of the University of California. 8 * All rights reserved. 9 * 10 * This code is derived from software contributed to Berkeley by 11 * Jan-Simon Pendry at Imperial College, London. 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. All advertising materials mentioning features or use of this software 22 * must display the following acknowledgment: 23 * This product includes software developed by the University of 24 * California, Berkeley and its contributors. 25 * 4. Neither the name of the University nor the names of its contributors 26 * may be used to endorse or promote products derived from this software 27 * without specific prior written permission. 28 * 29 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 30 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 31 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 32 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 33 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 34 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 35 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 36 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 37 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 38 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 39 * SUCH DAMAGE. 40 * 41 * 42 * File: am-utils/libamu/xdr_func.c 43 * 44 */ 45 46 /* 47 * Complete list of all possible xdr functions which may be needed. 48 */ 49 #ifdef HAVE_CONFIG_H 50 # include <config.h> 51 #endif /* HAVE_CONFIG_H */ 52 #include <am_defs.h> 53 #include <amu.h> 54 55 #ifdef __RPCSVC_MOUNT_H__ 56 # error IRIX6 should not include rpcsvc/mount.h 57 #endif /* __RPCSVC_MOUNT_H__ */ 58 59 /* 60 * MACROS: 61 */ 62 #ifdef HAVE_FS_AUTOFS 63 # ifndef AUTOFS_MAXCOMPONENTLEN 64 # define AUTOFS_MAXCOMPONENTLEN 255 65 # endif /* not AUTOFS_MAXCOMPONENTLEN */ 66 # ifndef AUTOFS_MAXOPTSLEN 67 # define AUTOFS_MAXOPTSLEN 255 68 # endif /* not AUTOFS_MAXOPTSLEN */ 69 # ifndef AUTOFS_MAXPATHLEN 70 # define AUTOFS_MAXPATHLEN 1024 71 # endif /* not AUTOFS_MAXPATHLEN */ 72 #endif /* HAVE_FS_AUTOFS */ 73 74 /* forward definitions, are they needed? */ 75 extern bool_t xdr_exportnode(XDR *xdrs, exportnode *objp); 76 extern bool_t xdr_groupnode(XDR *xdrs, groupnode *objp); 77 extern bool_t xdr_name(XDR *xdrs, name *objp); 78 79 80 #ifndef HAVE_XDR_ATTRSTAT 81 bool_t 82 xdr_attrstat(XDR *xdrs, nfsattrstat *objp) 83 { 84 if (amuDebug(D_XDRTRACE)) 85 plog(XLOG_DEBUG, "xdr_attrstat:"); 86 87 if (!xdr_nfsstat(xdrs, &objp->ns_status)) { 88 return (FALSE); 89 } 90 switch (objp->ns_status) { 91 case NFS_OK: 92 if (!xdr_fattr(xdrs, &objp->ns_u.ns_attr_u)) { 93 return (FALSE); 94 } 95 break; 96 default: 97 break; 98 } 99 return (TRUE); 100 } 101 #endif /* not HAVE_XDR_ATTRSTAT */ 102 103 104 #ifndef HAVE_XDR_CREATEARGS 105 bool_t 106 xdr_createargs(XDR *xdrs, nfscreateargs *objp) 107 { 108 if (amuDebug(D_XDRTRACE)) 109 plog(XLOG_DEBUG, "xdr_createargs:"); 110 111 if (!xdr_diropargs(xdrs, &objp->ca_where)) { 112 return (FALSE); 113 } 114 if (!xdr_sattr(xdrs, &objp->ca_attributes)) { 115 return (FALSE); 116 } 117 return (TRUE); 118 } 119 #endif /* not HAVE_XDR_CREATEARGS */ 120 121 122 #ifndef HAVE_XDR_DIRLIST 123 bool_t 124 xdr_dirlist(XDR *xdrs, nfsdirlist *objp) 125 { 126 if (amuDebug(D_XDRTRACE)) 127 plog(XLOG_DEBUG, "xdr_dirlist:"); 128 129 if (!xdr_pointer(xdrs, (char **) &objp->dl_entries, sizeof(nfsentry), (XDRPROC_T_TYPE) xdr_entry)) { 130 return (FALSE); 131 } 132 if (!xdr_bool(xdrs, &objp->dl_eof)) { 133 return (FALSE); 134 } 135 return (TRUE); 136 } 137 #endif /* not HAVE_XDR_DIRLIST */ 138 139 140 #ifndef HAVE_XDR_DIROPARGS 141 bool_t 142 xdr_diropargs(XDR *xdrs, nfsdiropargs *objp) 143 { 144 if (amuDebug(D_XDRTRACE)) 145 plog(XLOG_DEBUG, "xdr_diropargs:"); 146 147 if (!xdr_nfs_fh(xdrs, &objp->da_fhandle)) { 148 return (FALSE); 149 } 150 if (!xdr_filename(xdrs, &objp->da_name)) { 151 return (FALSE); 152 } 153 return (TRUE); 154 } 155 #endif /* not HAVE_XDR_DIROPARGS */ 156 157 158 #ifndef HAVE_XDR_DIROPOKRES 159 bool_t 160 xdr_diropokres(XDR *xdrs, nfsdiropokres *objp) 161 { 162 if (amuDebug(D_XDRTRACE)) 163 plog(XLOG_DEBUG, "xdr_diropokres:"); 164 165 if (!xdr_nfs_fh(xdrs, &objp->drok_fhandle)) { 166 return (FALSE); 167 } 168 if (!xdr_fattr(xdrs, &objp->drok_attributes)) { 169 return (FALSE); 170 } 171 return (TRUE); 172 } 173 #endif /* not HAVE_XDR_DIROPOKRES */ 174 175 176 #ifndef HAVE_XDR_DIROPRES 177 bool_t 178 xdr_diropres(XDR *xdrs, nfsdiropres *objp) 179 { 180 if (amuDebug(D_XDRTRACE)) 181 plog(XLOG_DEBUG, "xdr_diropres:"); 182 183 if (!xdr_nfsstat(xdrs, &objp->dr_status)) { 184 return (FALSE); 185 } 186 switch (objp->dr_status) { 187 case NFS_OK: 188 if (!xdr_diropokres(xdrs, &objp->dr_u.dr_drok_u)) { 189 return (FALSE); 190 } 191 break; 192 default: 193 break; 194 } 195 return (TRUE); 196 } 197 #endif /* not HAVE_XDR_DIROPRES */ 198 199 200 #ifndef HAVE_XDR_DIRPATH 201 bool_t 202 xdr_dirpath(XDR *xdrs, dirpath *objp) 203 { 204 if (amuDebug(D_XDRTRACE)) 205 plog(XLOG_DEBUG, "xdr_dirpath:"); 206 207 if (!xdr_string(xdrs, objp, MNTPATHLEN)) { 208 return (FALSE); 209 } 210 return (TRUE); 211 } 212 #endif /* not HAVE_XDR_DIRPATH */ 213 214 215 #ifndef HAVE_XDR_ENTRY 216 bool_t 217 xdr_entry(XDR *xdrs, nfsentry *objp) 218 { 219 if (amuDebug(D_XDRTRACE)) 220 plog(XLOG_DEBUG, "xdr_entry:"); 221 222 if (!xdr_u_int(xdrs, &objp->ne_fileid)) { 223 return (FALSE); 224 } 225 if (!xdr_filename(xdrs, &objp->ne_name)) { 226 return (FALSE); 227 } 228 if (!xdr_nfscookie(xdrs, objp->ne_cookie)) { 229 return (FALSE); 230 } 231 if (!xdr_pointer(xdrs, (char **) &objp->ne_nextentry, sizeof(nfsentry), (XDRPROC_T_TYPE) xdr_entry)) { 232 return (FALSE); 233 } 234 return (TRUE); 235 } 236 #endif /* not HAVE_XDR_ENTRY */ 237 238 239 #ifndef HAVE_XDR_EXPORTNODE 240 bool_t 241 xdr_exportnode(XDR *xdrs, exportnode *objp) 242 { 243 if (amuDebug(D_XDRTRACE)) 244 plog(XLOG_DEBUG, "xdr_exportnode:"); 245 246 if (!xdr_dirpath(xdrs, &objp->ex_dir)) { 247 return (FALSE); 248 } 249 if (!xdr_groups(xdrs, &objp->ex_groups)) { 250 return (FALSE); 251 } 252 if (!xdr_exports(xdrs, &objp->ex_next)) { 253 return (FALSE); 254 } 255 return (TRUE); 256 } 257 #endif /* not HAVE_XDR_EXPORTNODE */ 258 259 260 #ifndef HAVE_XDR_EXPORTS 261 bool_t 262 xdr_exports(XDR *xdrs, exports *objp) 263 { 264 if (amuDebug(D_XDRTRACE)) 265 plog(XLOG_DEBUG, "xdr_exports:"); 266 267 if (!xdr_pointer(xdrs, (char **) objp, sizeof(exportnode), (XDRPROC_T_TYPE) xdr_exportnode)) { 268 return (FALSE); 269 } 270 return (TRUE); 271 } 272 #endif /* not HAVE_XDR_EXPORTS */ 273 274 275 #ifndef HAVE_XDR_FATTR 276 bool_t 277 xdr_fattr(XDR *xdrs, nfsfattr *objp) 278 { 279 if (amuDebug(D_XDRTRACE)) 280 plog(XLOG_DEBUG, "xdr_fattr:"); 281 282 if (!xdr_ftype(xdrs, &objp->na_type)) { 283 return (FALSE); 284 } 285 if (!xdr_u_int(xdrs, &objp->na_mode)) { 286 return (FALSE); 287 } 288 if (!xdr_u_int(xdrs, &objp->na_nlink)) { 289 return (FALSE); 290 } 291 if (!xdr_u_int(xdrs, &objp->na_uid)) { 292 return (FALSE); 293 } 294 if (!xdr_u_int(xdrs, &objp->na_gid)) { 295 return (FALSE); 296 } 297 if (!xdr_u_int(xdrs, &objp->na_size)) { 298 return (FALSE); 299 } 300 if (!xdr_u_int(xdrs, &objp->na_blocksize)) { 301 return (FALSE); 302 } 303 if (!xdr_u_int(xdrs, &objp->na_rdev)) { 304 return (FALSE); 305 } 306 if (!xdr_u_int(xdrs, &objp->na_blocks)) { 307 return (FALSE); 308 } 309 if (!xdr_u_int(xdrs, &objp->na_fsid)) { 310 return (FALSE); 311 } 312 if (!xdr_u_int(xdrs, &objp->na_fileid)) { 313 return (FALSE); 314 } 315 if (!xdr_nfstime(xdrs, &objp->na_atime)) { 316 return (FALSE); 317 } 318 if (!xdr_nfstime(xdrs, &objp->na_mtime)) { 319 return (FALSE); 320 } 321 if (!xdr_nfstime(xdrs, &objp->na_ctime)) { 322 return (FALSE); 323 } 324 return (TRUE); 325 } 326 #endif /* not HAVE_XDR_FATTR */ 327 328 329 #ifndef HAVE_XDR_FHANDLE 330 bool_t 331 xdr_fhandle(XDR *xdrs, fhandle objp) 332 { 333 if (amuDebug(D_XDRTRACE)) 334 plog(XLOG_DEBUG, "xdr_fhandle:"); 335 336 if (!xdr_opaque(xdrs, objp, NFS_FHSIZE)) { 337 return (FALSE); 338 } 339 return (TRUE); 340 } 341 #endif /* not HAVE_XDR_FHANDLE */ 342 343 344 #ifndef HAVE_XDR_FHSTATUS 345 bool_t 346 xdr_fhstatus(XDR *xdrs, fhstatus *objp) 347 { 348 if (amuDebug(D_XDRTRACE)) 349 plog(XLOG_DEBUG, "xdr_fhstatus:"); 350 351 if (!xdr_u_int(xdrs, &objp->fhs_status)) { 352 return (FALSE); 353 } 354 if (objp->fhs_status == 0 && !xdr_fhandle(xdrs, objp->fhs_fh)) { 355 return (FALSE); 356 } 357 return (TRUE); 358 } 359 #endif /* not HAVE_XDR_FHSTATUS */ 360 361 362 #ifndef HAVE_XDR_FILENAME 363 bool_t 364 xdr_filename(XDR *xdrs, filename *objp) 365 { 366 if (amuDebug(D_XDRTRACE)) 367 plog(XLOG_DEBUG, "xdr_filename:"); 368 369 if (!xdr_string(xdrs, objp, NFS_MAXNAMLEN)) { 370 return (FALSE); 371 } 372 return (TRUE); 373 } 374 #endif /* not HAVE_XDR_FILENAME */ 375 376 377 #ifndef HAVE_XDR_FTYPE 378 bool_t 379 xdr_ftype(XDR *xdrs, nfsftype *objp) 380 { 381 enum_t local_obj = *objp; 382 383 if (amuDebug(D_XDRTRACE)) 384 plog(XLOG_DEBUG, "xdr_ftype:"); 385 386 if (!xdr_enum(xdrs, &local_obj)) { 387 return (FALSE); 388 } 389 return (TRUE); 390 } 391 #endif /* not HAVE_XDR_FTYPE */ 392 393 394 #ifndef HAVE_XDR_GROUPNODE 395 bool_t 396 xdr_groupnode(XDR *xdrs, groupnode *objp) 397 { 398 if (amuDebug(D_XDRTRACE)) 399 plog(XLOG_DEBUG, "xdr_groupnode:"); 400 401 if (!xdr_name(xdrs, &objp->gr_name)) { 402 return (FALSE); 403 } 404 if (!xdr_groups(xdrs, &objp->gr_next)) { 405 return (FALSE); 406 } 407 return (TRUE); 408 } 409 #endif /* not HAVE_XDR_GROUPNODE */ 410 411 412 #ifndef HAVE_XDR_GROUPS 413 bool_t 414 xdr_groups(XDR *xdrs, groups *objp) 415 { 416 if (amuDebug(D_XDRTRACE)) 417 plog(XLOG_DEBUG, "xdr_groups:"); 418 419 if (!xdr_pointer(xdrs, (char **) objp, sizeof(groupnode), (XDRPROC_T_TYPE) xdr_groupnode)) { 420 return (FALSE); 421 } 422 return (TRUE); 423 } 424 #endif /* not HAVE_XDR_GROUPS */ 425 426 427 #ifndef HAVE_XDR_LINKARGS 428 bool_t 429 xdr_linkargs(XDR *xdrs, nfslinkargs *objp) 430 { 431 if (amuDebug(D_XDRTRACE)) 432 plog(XLOG_DEBUG, "xdr_linkargs:"); 433 434 if (!xdr_nfs_fh(xdrs, &objp->la_fhandle)) { 435 return (FALSE); 436 } 437 if (!xdr_diropargs(xdrs, &objp->la_to)) { 438 return (FALSE); 439 } 440 return (TRUE); 441 } 442 #endif /* not HAVE_XDR_LINKARGS */ 443 444 445 #ifndef HAVE_XDR_MOUNTBODY 446 bool_t 447 xdr_mountbody(XDR *xdrs, mountbody *objp) 448 { 449 if (amuDebug(D_XDRTRACE)) 450 plog(XLOG_DEBUG, "xdr_mountbody:"); 451 452 if (!xdr_name(xdrs, &objp->ml_hostname)) { 453 return (FALSE); 454 } 455 if (!xdr_dirpath(xdrs, &objp->ml_directory)) { 456 return (FALSE); 457 } 458 if (!xdr_mountlist(xdrs, &objp->ml_next)) { 459 return (FALSE); 460 } 461 return (TRUE); 462 } 463 #endif /* not HAVE_XDR_MOUNTBODY */ 464 465 466 #ifndef HAVE_XDR_MOUNTLIST 467 bool_t 468 xdr_mountlist(XDR *xdrs, mountlist *objp) 469 { 470 if (amuDebug(D_XDRTRACE)) 471 plog(XLOG_DEBUG, "xdr_mountlist:"); 472 473 if (!xdr_pointer(xdrs, (char **) objp, sizeof(mountbody), (XDRPROC_T_TYPE) xdr_mountbody)) { 474 return (FALSE); 475 } 476 return (TRUE); 477 } 478 #endif /* not HAVE_XDR_MOUNTLIST */ 479 480 481 #ifndef HAVE_XDR_NAME 482 bool_t 483 xdr_name(XDR *xdrs, name *objp) 484 { 485 if (amuDebug(D_XDRTRACE)) 486 plog(XLOG_DEBUG, "xdr_name:"); 487 488 if (!xdr_string(xdrs, objp, MNTNAMLEN)) { 489 return (FALSE); 490 } 491 return (TRUE); 492 } 493 #endif /* not HAVE_XDR_NAME */ 494 495 496 #ifndef HAVE_XDR_NFS_FH 497 bool_t 498 xdr_nfs_fh(XDR *xdrs, am_nfs_fh *objp) 499 { 500 if (amuDebug(D_XDRTRACE)) 501 plog(XLOG_DEBUG, "xdr_nfs_fh:"); 502 503 if (!xdr_opaque(xdrs, (caddr_t) objp->fh_data, NFS_FHSIZE)) { 504 return (FALSE); 505 } 506 return (TRUE); 507 } 508 #endif /* not HAVE_XDR_NFS_FH */ 509 510 511 #ifndef HAVE_XDR_NFSCOOKIE 512 bool_t 513 xdr_nfscookie(XDR *xdrs, nfscookie objp) 514 { 515 if (amuDebug(D_XDRTRACE)) 516 plog(XLOG_DEBUG, "xdr_nfscookie:"); 517 518 if (!xdr_opaque(xdrs, objp, NFS_COOKIESIZE)) { 519 return (FALSE); 520 } 521 return (TRUE); 522 } 523 #endif /* not HAVE_XDR_NFSCOOKIE */ 524 525 526 #ifndef HAVE_XDR_NFSPATH 527 bool_t 528 xdr_nfspath(XDR *xdrs, nfspath *objp) 529 { 530 if (amuDebug(D_XDRTRACE)) 531 plog(XLOG_DEBUG, "xdr_nfspath:"); 532 533 if (!xdr_string(xdrs, objp, NFS_MAXPATHLEN)) { 534 return (FALSE); 535 } 536 return (TRUE); 537 } 538 #endif /* not HAVE_XDR_NFSPATH */ 539 540 541 #ifndef HAVE_XDR_NFSSTAT 542 bool_t 543 xdr_nfsstat(XDR *xdrs, nfsstat *objp) 544 { 545 enum_t local_obj = *objp; 546 547 if (amuDebug(D_XDRTRACE)) 548 plog(XLOG_DEBUG, "xdr_nfsstat:"); 549 550 if (!xdr_enum(xdrs, &local_obj)) { 551 return (FALSE); 552 } 553 return (TRUE); 554 } 555 #endif /* not HAVE_XDR_NFSSTAT */ 556 557 558 #ifndef HAVE_XDR_NFSTIME 559 bool_t 560 xdr_nfstime(XDR *xdrs, nfstime *objp) 561 { 562 if (amuDebug(D_XDRTRACE)) 563 plog(XLOG_DEBUG, "xdr_nfstime:"); 564 565 if (!xdr_u_int(xdrs, (u_int *) &objp->nt_seconds)) { 566 return (FALSE); 567 } 568 if (!xdr_u_int(xdrs, (u_int *) &objp->nt_useconds)) { 569 return (FALSE); 570 } 571 return (TRUE); 572 } 573 #endif /* not HAVE_XDR_NFSTIME */ 574 575 576 #ifndef HAVE_XDR_POINTER 577 bool_t 578 xdr_pointer(register XDR *xdrs, char **objpp, u_int obj_size, XDRPROC_T_TYPE xdr_obj) 579 { 580 if (amuDebug(D_XDRTRACE)) 581 plog(XLOG_DEBUG, "xdr_pointer:"); 582 583 bool_t more_data; 584 585 more_data = (*objpp != NULL); 586 if (!xdr_bool(xdrs, &more_data)) { 587 return (FALSE); 588 } 589 if (!more_data) { 590 *objpp = NULL; 591 return (TRUE); 592 } 593 594 return (xdr_reference(xdrs, objpp, obj_size, xdr_obj)); 595 } 596 #endif /* not HAVE_XDR_POINTER */ 597 598 599 #ifndef HAVE_XDR_READARGS 600 bool_t 601 xdr_readargs(XDR *xdrs, nfsreadargs *objp) 602 { 603 if (amuDebug(D_XDRTRACE)) 604 plog(XLOG_DEBUG, "xdr_readargs:"); 605 606 if (!xdr_nfs_fh(xdrs, &objp->ra_fhandle)) { 607 return (FALSE); 608 } 609 if (!xdr_u_int(xdrs, &objp->ra_offset)) { 610 return (FALSE); 611 } 612 if (!xdr_u_int(xdrs, &objp->ra_count)) { 613 return (FALSE); 614 } 615 if (!xdr_u_int(xdrs, &objp->ra_totalcount)) { 616 return (FALSE); 617 } 618 return (TRUE); 619 } 620 #endif /* not HAVE_XDR_READARGS */ 621 622 623 #ifndef HAVE_XDR_READDIRARGS 624 bool_t 625 xdr_readdirargs(XDR *xdrs, nfsreaddirargs *objp) 626 { 627 if (amuDebug(D_XDRTRACE)) 628 plog(XLOG_DEBUG, "xdr_readdirargs:"); 629 630 if (!xdr_nfs_fh(xdrs, &objp->rda_fhandle)) { 631 return (FALSE); 632 } 633 if (!xdr_nfscookie(xdrs, objp->rda_cookie)) { 634 return (FALSE); 635 } 636 if (!xdr_u_int(xdrs, &objp->rda_count)) { 637 return (FALSE); 638 } 639 return (TRUE); 640 } 641 #endif /* not HAVE_XDR_READDIRARGS */ 642 643 644 #ifndef HAVE_XDR_READDIRRES 645 bool_t 646 xdr_readdirres(XDR *xdrs, nfsreaddirres *objp) 647 { 648 if (amuDebug(D_XDRTRACE)) 649 plog(XLOG_DEBUG, "xdr_readdirres:"); 650 651 if (!xdr_nfsstat(xdrs, &objp->rdr_status)) { 652 return (FALSE); 653 } 654 switch (objp->rdr_status) { 655 case NFS_OK: 656 if (!xdr_dirlist(xdrs, &objp->rdr_u.rdr_reply_u)) { 657 return (FALSE); 658 } 659 break; 660 default: 661 break; 662 } 663 return (TRUE); 664 } 665 #endif /* not HAVE_XDR_READDIRRES */ 666 667 668 #ifndef HAVE_XDR_READLINKRES 669 bool_t 670 xdr_readlinkres(XDR *xdrs, nfsreadlinkres *objp) 671 { 672 if (amuDebug(D_XDRTRACE)) 673 plog(XLOG_DEBUG, "xdr_readlinkres:"); 674 675 if (!xdr_nfsstat(xdrs, &objp->rlr_status)) { 676 return (FALSE); 677 } 678 switch (objp->rlr_status) { 679 case NFS_OK: 680 if (!xdr_nfspath(xdrs, &objp->rlr_u.rlr_data_u)) { 681 return (FALSE); 682 } 683 break; 684 default: 685 break; 686 } 687 return (TRUE); 688 } 689 #endif /* not HAVE_XDR_READLINKRES */ 690 691 692 #ifndef HAVE_XDR_READOKRES 693 bool_t 694 xdr_readokres(XDR *xdrs, nfsreadokres *objp) 695 { 696 if (amuDebug(D_XDRTRACE)) 697 plog(XLOG_DEBUG, "xdr_readokres:"); 698 699 if (!xdr_fattr(xdrs, &objp->raok_attributes)) { 700 return (FALSE); 701 } 702 if (!xdr_bytes(xdrs, 703 (char **) & objp->raok_u.raok_val_u, 704 (u_int *) & objp->raok_u.raok_len_u, 705 NFS_MAXDATA)) { 706 return (FALSE); 707 } 708 return (TRUE); 709 } 710 #endif /* not HAVE_XDR_READOKRES */ 711 712 713 #ifndef HAVE_XDR_READRES 714 bool_t 715 xdr_readres(XDR *xdrs, nfsreadres *objp) 716 { 717 if (amuDebug(D_XDRTRACE)) 718 plog(XLOG_DEBUG, "xdr_readres:"); 719 720 if (!xdr_nfsstat(xdrs, &objp->rr_status)) { 721 return (FALSE); 722 } 723 switch (objp->rr_status) { 724 case NFS_OK: 725 if (!xdr_readokres(xdrs, &objp->rr_u.rr_reply_u)) { 726 return (FALSE); 727 } 728 break; 729 default: 730 break; 731 } 732 return (TRUE); 733 } 734 #endif /* not HAVE_XDR_READRES */ 735 736 737 #ifndef HAVE_XDR_RENAMEARGS 738 bool_t 739 xdr_renameargs(XDR *xdrs, nfsrenameargs *objp) 740 { 741 if (amuDebug(D_XDRTRACE)) 742 plog(XLOG_DEBUG, "xdr_renameargs:"); 743 744 if (!xdr_diropargs(xdrs, &objp->rna_from)) { 745 return (FALSE); 746 } 747 if (!xdr_diropargs(xdrs, &objp->rna_to)) { 748 return (FALSE); 749 } 750 return (TRUE); 751 } 752 #endif /* not HAVE_XDR_RENAMEARGS */ 753 754 755 #ifndef HAVE_XDR_SATTR 756 bool_t 757 xdr_sattr(XDR *xdrs, nfssattr *objp) 758 { 759 if (amuDebug(D_XDRTRACE)) 760 plog(XLOG_DEBUG, "xdr_sattr:"); 761 762 if (!xdr_u_int(xdrs, &objp->sa_mode)) { 763 return (FALSE); 764 } 765 if (!xdr_u_int(xdrs, &objp->sa_uid)) { 766 return (FALSE); 767 } 768 if (!xdr_u_int(xdrs, &objp->sa_gid)) { 769 return (FALSE); 770 } 771 if (!xdr_u_int(xdrs, &objp->sa_size)) { 772 return (FALSE); 773 } 774 if (!xdr_nfstime(xdrs, &objp->sa_atime)) { 775 return (FALSE); 776 } 777 if (!xdr_nfstime(xdrs, &objp->sa_mtime)) { 778 return (FALSE); 779 } 780 return (TRUE); 781 } 782 #endif /* not HAVE_XDR_SATTR */ 783 784 785 #ifndef HAVE_XDR_SATTRARGS 786 bool_t 787 xdr_sattrargs(XDR *xdrs, nfssattrargs *objp) 788 { 789 if (amuDebug(D_XDRTRACE)) 790 plog(XLOG_DEBUG, "xdr_sattrargs:"); 791 792 if (!xdr_nfs_fh(xdrs, &objp->sag_fhandle)) { 793 return (FALSE); 794 } 795 if (!xdr_sattr(xdrs, &objp->sag_attributes)) { 796 return (FALSE); 797 } 798 return (TRUE); 799 } 800 #endif /* not HAVE_XDR_SATTRARGS */ 801 802 803 #ifndef HAVE_XDR_STATFSOKRES 804 bool_t 805 xdr_statfsokres(XDR *xdrs, nfsstatfsokres *objp) 806 { 807 if (amuDebug(D_XDRTRACE)) 808 plog(XLOG_DEBUG, "xdr_statfsokres:"); 809 810 if (!xdr_u_int(xdrs, &objp->sfrok_tsize)) { 811 return (FALSE); 812 } 813 if (!xdr_u_int(xdrs, &objp->sfrok_bsize)) { 814 return (FALSE); 815 } 816 if (!xdr_u_int(xdrs, &objp->sfrok_blocks)) { 817 return (FALSE); 818 } 819 if (!xdr_u_int(xdrs, &objp->sfrok_bfree)) { 820 return (FALSE); 821 } 822 if (!xdr_u_int(xdrs, &objp->sfrok_bavail)) { 823 return (FALSE); 824 } 825 return (TRUE); 826 } 827 #endif /* not HAVE_XDR_STATFSOKRES */ 828 829 830 #ifndef HAVE_XDR_STATFSRES 831 bool_t 832 xdr_statfsres(XDR *xdrs, nfsstatfsres *objp) 833 { 834 if (amuDebug(D_XDRTRACE)) 835 plog(XLOG_DEBUG, "xdr_statfsres:"); 836 837 if (!xdr_nfsstat(xdrs, &objp->sfr_status)) { 838 return (FALSE); 839 } 840 switch (objp->sfr_status) { 841 case NFS_OK: 842 if (!xdr_statfsokres(xdrs, &objp->sfr_u.sfr_reply_u)) { 843 return (FALSE); 844 } 845 break; 846 default: 847 break; 848 } 849 return (TRUE); 850 } 851 #endif /* not HAVE_XDR_STATFSRES */ 852 853 854 #ifndef HAVE_XDR_SYMLINKARGS 855 bool_t 856 xdr_symlinkargs(XDR *xdrs, nfssymlinkargs *objp) 857 { 858 if (amuDebug(D_XDRTRACE)) 859 plog(XLOG_DEBUG, "xdr_symlinkargs:"); 860 861 if (!xdr_diropargs(xdrs, &objp->sla_from)) { 862 return (FALSE); 863 } 864 if (!xdr_nfspath(xdrs, &objp->sla_to)) { 865 return (FALSE); 866 } 867 if (!xdr_sattr(xdrs, &objp->sla_attributes)) { 868 return (FALSE); 869 } 870 return (TRUE); 871 } 872 #endif /* not HAVE_XDR_SYMLINKARGS */ 873 874 875 #ifndef HAVE_XDR_WRITEARGS 876 bool_t 877 xdr_writeargs(XDR *xdrs, nfswriteargs *objp) 878 { 879 if (amuDebug(D_XDRTRACE)) 880 plog(XLOG_DEBUG, "xdr_writeargs:"); 881 882 if (!xdr_nfs_fh(xdrs, &objp->wra_fhandle)) { 883 return (FALSE); 884 } 885 if (!xdr_u_int(xdrs, &objp->wra_beginoffset)) { 886 return (FALSE); 887 } 888 if (!xdr_u_int(xdrs, &objp->wra_offset)) { 889 return (FALSE); 890 } 891 if (!xdr_u_int(xdrs, &objp->wra_totalcount)) { 892 return (FALSE); 893 } 894 if (!xdr_bytes(xdrs, 895 (char **) & objp->wra_u.wra_val_u, 896 (u_int *) & objp->wra_u.wra_len_u, 897 NFS_MAXDATA)) { 898 return (FALSE); 899 } 900 return (TRUE); 901 } 902 #endif /* not HAVE_XDR_WRITEARGS */ 903 904 905 /* 906 * NFS V3 XDR FUNCTIONS: 907 */ 908 #ifdef HAVE_FS_NFS3 909 bool_t 910 xdr_am_fhandle3(XDR *xdrs, am_fhandle3 *objp) 911 { 912 if (amuDebug(D_XDRTRACE)) 913 plog(XLOG_DEBUG, "xdr_am_fhandle3:"); 914 915 if (!xdr_bytes(xdrs, 916 (char **) &objp->fhandle3_val, 917 (u_int *) &objp->fhandle3_len, 918 AM_FHSIZE3)) 919 return (FALSE); 920 return (TRUE); 921 } 922 923 924 bool_t 925 xdr_am_mountstat3(XDR *xdrs, am_mountstat3 *objp) 926 { 927 enum_t local_obj = *objp; 928 929 if (amuDebug(D_XDRTRACE)) 930 plog(XLOG_DEBUG, "xdr_am_mountstat3:"); 931 932 if (!xdr_enum(xdrs, &local_obj)) 933 return (FALSE); 934 return (TRUE); 935 } 936 937 938 bool_t 939 xdr_am_mountres3_ok(XDR *xdrs, am_mountres3_ok *objp) 940 { 941 if (amuDebug(D_XDRTRACE)) 942 plog(XLOG_DEBUG, "xdr_am_mountres3_ok:"); 943 944 if (!xdr_am_fhandle3(xdrs, &objp->fhandle)) 945 return (FALSE); 946 if (!xdr_array(xdrs, 947 (char **) ((voidp) &objp->auth_flavors.auth_flavors_val), 948 (u_int *) &objp->auth_flavors.auth_flavors_len, 949 ~0, 950 sizeof(int), 951 (XDRPROC_T_TYPE) xdr_int)) 952 return (FALSE); 953 return (TRUE); 954 } 955 956 957 bool_t 958 xdr_am_mountres3(XDR *xdrs, am_mountres3 *objp) 959 { 960 if (amuDebug(D_XDRTRACE)) 961 plog(XLOG_DEBUG, "xdr_am_mountres3:"); 962 963 if (!xdr_am_mountstat3(xdrs, &objp->fhs_status)) 964 return (FALSE); 965 966 if (objp->fhs_status == AM_MNT3_OK) { 967 if (!xdr_am_mountres3_ok(xdrs, &objp->mountres3_u.mountinfo)) 968 return (FALSE); 969 } 970 return (TRUE); 971 } 972 973 974 bool_t 975 xdr_am_diropargs3(XDR *xdrs, am_diropargs3 *objp) 976 { 977 if (amuDebug(D_XDRTRACE)) 978 plog(XLOG_DEBUG, "xdr_am_diropargs3:"); 979 980 if (!xdr_am_nfs_fh3(xdrs, &objp->dir)) 981 return (FALSE); 982 if (!xdr_am_filename3(xdrs, &objp->name)) 983 return (FALSE); 984 return (TRUE); 985 } 986 987 988 bool_t 989 xdr_am_filename3(XDR *xdrs, am_filename3 *objp) 990 { 991 if (amuDebug(D_XDRTRACE)) 992 plog(XLOG_DEBUG, "xdr_am_filename3:"); 993 994 if (!xdr_string(xdrs, objp, ~0)) 995 return (FALSE); 996 return (TRUE); 997 } 998 999 1000 bool_t 1001 xdr_am_LOOKUP3args(XDR *xdrs, am_LOOKUP3args *objp) 1002 { 1003 if (amuDebug(D_XDRTRACE)) 1004 plog(XLOG_DEBUG, "xdr_am_LOOKUP3args:"); 1005 1006 if (!xdr_am_diropargs3(xdrs, &objp->what)) 1007 return (FALSE); 1008 return (TRUE); 1009 } 1010 1011 1012 bool_t 1013 xdr_am_LOOKUP3res(XDR *xdrs, am_LOOKUP3res *objp) 1014 { 1015 if (amuDebug(D_XDRTRACE)) 1016 plog(XLOG_DEBUG, "xdr_am_LOOKUP3res:"); 1017 1018 if (!xdr_am_nfsstat3(xdrs, &objp->status)) 1019 return (FALSE); 1020 switch (objp->status) { 1021 case AM_NFS3_OK: 1022 if (!xdr_am_LOOKUP3resok(xdrs, &objp->res_u.ok)) 1023 return (FALSE); 1024 break; 1025 default: 1026 if (!xdr_am_LOOKUP3resfail(xdrs, &objp->res_u.fail)) 1027 return (FALSE); 1028 break; 1029 } 1030 return (TRUE); 1031 } 1032 1033 1034 bool_t 1035 xdr_am_LOOKUP3resfail(XDR *xdrs, am_LOOKUP3resfail *objp) 1036 { 1037 if (amuDebug(D_XDRTRACE)) 1038 plog(XLOG_DEBUG, "xdr_am_LOOKUP3resfail:"); 1039 1040 /* 1041 * Don't xdr post_op_attr: amd doesn't need them, but they require many 1042 * additional xdr functions. 1043 */ 1044 #if 0 1045 if (!xdr_post_op_attr(xdrs, &objp->dir_attributes)) 1046 return (FALSE); 1047 #endif /* 0 */ 1048 return (TRUE); 1049 } 1050 1051 1052 bool_t 1053 xdr_am_LOOKUP3resok(XDR *xdrs, am_LOOKUP3resok *objp) 1054 { 1055 if (amuDebug(D_XDRTRACE)) 1056 plog(XLOG_DEBUG, "xdr_am_LOOKUP3resok:"); 1057 1058 if (!xdr_am_nfs_fh3(xdrs, &objp->object)) 1059 return (FALSE); 1060 /* 1061 * Don't xdr post_op_attr: amd doesn't need them, but they require many 1062 * additional xdr functions. 1063 */ 1064 #if 0 1065 if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) 1066 return (FALSE); 1067 if (!xdr_post_op_attr(xdrs, &objp->dir_attributes)) 1068 return (FALSE); 1069 #endif /* 0 */ 1070 return (TRUE); 1071 } 1072 1073 1074 bool_t 1075 xdr_am_nfs_fh3(XDR *xdrs, am_nfs_fh3 *objp) 1076 { 1077 if (amuDebug(D_XDRTRACE)) 1078 plog(XLOG_DEBUG, "xdr_am_nfs_fh3:"); 1079 1080 if (!xdr_u_int(xdrs, &objp->am_fh3_length)) 1081 return (FALSE); 1082 if (objp->am_fh3_length > AM_FHSIZE3) 1083 return (FALSE); 1084 if (!xdr_opaque(xdrs, objp->am_fh3_data, objp->am_fh3_length)) 1085 return (FALSE); 1086 return (TRUE); 1087 } 1088 1089 1090 bool_t 1091 xdr_am_nfsstat3(XDR *xdrs, am_nfsstat3 *objp) 1092 { 1093 if (amuDebug(D_XDRTRACE)) 1094 plog(XLOG_DEBUG, "xdr_am_nfsstat3:"); 1095 1096 if (!xdr_enum(xdrs, (enum_t *)objp)) 1097 return (FALSE); 1098 return (TRUE); 1099 } 1100 #endif /* not HAVE_FS_NFS3 */ 1101