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 (c) 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 #include <sys/sunddi.h> 26 #ifndef _KERNEL 27 #include <string.h> 28 #include <strings.h> 29 #include <stddef.h> 30 #endif /* _KERNEL */ 31 #include <smbsrv/smb_door.h> 32 #include <smbsrv/alloc.h> 33 #include <sys/socket.h> 34 #include <sys/sysmacros.h> 35 36 #define SMB_XDRMAX32_SZ 0xFFFFFFFF 37 38 bool_t smb_list_xdr(XDR *, list_t *, const size_t, const size_t, 39 const xdrproc_t); 40 41 bool_t 42 smb_buf32_xdr(XDR *xdrs, smb_buf32_t *objp) 43 { 44 uint_t maxsize = SMB_XDRMAX32_SZ; 45 uint_t size; 46 47 if (xdrs->x_op != XDR_DECODE) 48 maxsize = size = (uint_t)objp->len; 49 50 if (xdr_bytes(xdrs, (char **)&objp->val, &size, maxsize)) { 51 if (xdrs->x_op == XDR_DECODE) 52 objp->len = (uint32_t)size; 53 return (TRUE); 54 } 55 56 return (FALSE); 57 } 58 59 /* 60 * When decoding into a string, ensure that objp->buf is NULL or 61 * is pointing at a buffer large enough to receive the string. 62 * Don't leave it as an uninitialized pointer. 63 * 64 * If objp->buf is NULL, xdr_string will allocate memory for the 65 * string. Otherwise it will copy into the available buffer. 66 */ 67 bool_t 68 smb_string_xdr(XDR *xdrs, smb_string_t *objp) 69 { 70 if (!xdr_string(xdrs, &objp->buf, ~0)) 71 return (FALSE); 72 return (TRUE); 73 } 74 75 const char * 76 smb_doorhdr_opname(uint32_t op) 77 { 78 struct { 79 uint32_t op; 80 const char *name; 81 } ops[] = { 82 { SMB_DR_NULL, "null" }, 83 { SMB_DR_ASYNC_RESPONSE, "async_response" }, 84 { SMB_DR_USER_AUTH_LOGON, "user_auth_logon" }, 85 { SMB_DR_USER_NONAUTH_LOGON, "user_nonauth_logon" }, 86 { SMB_DR_USER_AUTH_LOGOFF, "user_auth_logoff" }, 87 { SMB_DR_LOOKUP_SID, "lookup_sid" }, 88 { SMB_DR_LOOKUP_NAME, "lookup_name" }, 89 { SMB_DR_JOIN, "join" }, 90 { SMB_DR_GET_DCINFO, "get_dcinfo" }, 91 { SMB_DR_VSS_GET_COUNT, "vss_get_count" }, 92 { SMB_DR_VSS_GET_SNAPSHOTS, "vss_get_snapshots" }, 93 { SMB_DR_VSS_MAP_GMTTOKEN, "vss_map_gmttoken" }, 94 { SMB_DR_ADS_FIND_HOST, "ads_find_host" }, 95 { SMB_DR_QUOTA_QUERY, "quota_query" }, 96 { SMB_DR_QUOTA_SET, "quota_set" }, 97 { SMB_DR_DFS_GET_REFERRALS, "dfs_get_referrals" }, 98 { SMB_DR_SHR_HOSTACCESS, "share_hostaccess" }, 99 { SMB_DR_SHR_EXEC, "share_exec" } 100 }; 101 int i; 102 103 for (i = 0; i < (sizeof (ops) / sizeof (ops[0])); ++i) { 104 if (ops[i].op == op) 105 return (ops[i].name); 106 } 107 108 return ("unknown"); 109 } 110 111 /* 112 * Encode a door header structure into an XDR buffer. 113 */ 114 int 115 smb_doorhdr_encode(smb_doorhdr_t *hdr, uint8_t *buf, uint32_t buflen) 116 { 117 XDR xdrs; 118 int rc = 0; 119 120 xdrmem_create(&xdrs, (const caddr_t)buf, buflen, XDR_ENCODE); 121 122 if (!smb_doorhdr_xdr(&xdrs, hdr)) 123 rc = -1; 124 125 xdr_destroy(&xdrs); 126 return (rc); 127 } 128 129 /* 130 * Decode an XDR buffer into a door header structure. 131 */ 132 int 133 smb_doorhdr_decode(smb_doorhdr_t *hdr, uint8_t *buf, uint32_t buflen) 134 { 135 XDR xdrs; 136 int rc = 0; 137 138 bzero(hdr, sizeof (smb_doorhdr_t)); 139 xdrmem_create(&xdrs, (const caddr_t)buf, buflen, XDR_DECODE); 140 141 if (!smb_doorhdr_xdr(&xdrs, hdr)) 142 rc = -1; 143 144 xdr_destroy(&xdrs); 145 return (rc); 146 } 147 148 bool_t 149 smb_doorhdr_xdr(XDR *xdrs, smb_doorhdr_t *objp) 150 { 151 if (!xdr_uint32_t(xdrs, &objp->dh_magic)) 152 return (FALSE); 153 if (!xdr_uint32_t(xdrs, &objp->dh_flags)) 154 return (FALSE); 155 if (!xdr_uint32_t(xdrs, &objp->dh_fid)) 156 return (FALSE); 157 if (!xdr_uint32_t(xdrs, &objp->dh_op)) 158 return (FALSE); 159 if (!xdr_uint32_t(xdrs, &objp->dh_txid)) 160 return (FALSE); 161 if (!xdr_uint32_t(xdrs, &objp->dh_datalen)) 162 return (FALSE); 163 if (!xdr_uint32_t(xdrs, &objp->dh_resid)) 164 return (FALSE); 165 if (!xdr_uint32_t(xdrs, &objp->dh_door_rc)) 166 return (FALSE); 167 if (!xdr_uint32_t(xdrs, &objp->dh_status)) 168 return (FALSE); 169 return (TRUE); 170 } 171 172 /* 173 * Encode an smb_netuserinfo_t into a buffer. 174 */ 175 int 176 smb_netuserinfo_encode(smb_netuserinfo_t *info, uint8_t *buf, 177 uint32_t buflen, uint_t *nbytes) 178 { 179 XDR xdrs; 180 int rc = 0; 181 182 xdrmem_create(&xdrs, (const caddr_t)buf, buflen, XDR_ENCODE); 183 184 if (!smb_netuserinfo_xdr(&xdrs, info)) 185 rc = -1; 186 187 if (nbytes != NULL) 188 *nbytes = xdr_getpos(&xdrs); 189 xdr_destroy(&xdrs); 190 return (rc); 191 } 192 193 /* 194 * Decode an XDR buffer into an smb_netuserinfo_t. 195 */ 196 int 197 smb_netuserinfo_decode(smb_netuserinfo_t *info, uint8_t *buf, 198 uint32_t buflen, uint_t *nbytes) 199 { 200 XDR xdrs; 201 int rc = 0; 202 203 xdrmem_create(&xdrs, (const caddr_t)buf, buflen, XDR_DECODE); 204 205 bzero(info, sizeof (smb_netuserinfo_t)); 206 if (!smb_netuserinfo_xdr(&xdrs, info)) 207 rc = -1; 208 209 if (nbytes != NULL) 210 *nbytes = xdr_getpos(&xdrs); 211 xdr_destroy(&xdrs); 212 return (rc); 213 } 214 215 bool_t 216 smb_inaddr_xdr(XDR *xdrs, smb_inaddr_t *objp) 217 { 218 if (!xdr_int32_t(xdrs, &objp->a_family)) 219 return (FALSE); 220 if (objp->a_family == AF_INET) { 221 if (!xdr_uint32_t(xdrs, (in_addr_t *)&objp->a_ipv4)) 222 return (FALSE); 223 } else { 224 if (!xdr_vector(xdrs, (char *)&objp->a_ipv6, 225 sizeof (objp->a_ipv6), sizeof (char), (xdrproc_t)xdr_char)) 226 return (FALSE); 227 } 228 return (TRUE); 229 } 230 231 /* 232 * XDR encode/decode for smb_netuserinfo_t. 233 */ 234 bool_t 235 smb_netuserinfo_xdr(XDR *xdrs, smb_netuserinfo_t *objp) 236 { 237 if (!xdr_uint64_t(xdrs, &objp->ui_session_id)) 238 return (FALSE); 239 if (!xdr_uint16_t(xdrs, &objp->ui_smb_uid)) 240 return (FALSE); 241 if (!xdr_uint16_t(xdrs, &objp->ui_domain_len)) 242 return (FALSE); 243 if (!xdr_string(xdrs, &objp->ui_domain, ~0)) 244 return (FALSE); 245 if (!xdr_uint16_t(xdrs, &objp->ui_account_len)) 246 return (FALSE); 247 if (!xdr_string(xdrs, &objp->ui_account, ~0)) 248 return (FALSE); 249 if (!xdr_uint32_t(xdrs, &objp->ui_posix_uid)) 250 return (FALSE); 251 if (!xdr_uint16_t(xdrs, &objp->ui_workstation_len)) 252 return (FALSE); 253 if (!xdr_string(xdrs, &objp->ui_workstation, ~0)) 254 return (FALSE); 255 if (!smb_inaddr_xdr(xdrs, &objp->ui_ipaddr)) 256 return (FALSE); 257 if (!xdr_int32_t(xdrs, &objp->ui_native_os)) 258 return (FALSE); 259 if (!xdr_int64_t(xdrs, &objp->ui_logon_time)) 260 return (FALSE); 261 if (!xdr_uint32_t(xdrs, &objp->ui_numopens)) 262 return (FALSE); 263 if (!xdr_uint32_t(xdrs, &objp->ui_flags)) 264 return (FALSE); 265 return (TRUE); 266 } 267 268 /* 269 * Encode an smb_netconnectinfo_t into a buffer. 270 */ 271 int 272 smb_netconnectinfo_encode(smb_netconnectinfo_t *info, uint8_t *buf, 273 uint32_t buflen, uint_t *nbytes) 274 { 275 XDR xdrs; 276 int rc = 0; 277 278 xdrmem_create(&xdrs, (const caddr_t)buf, buflen, XDR_ENCODE); 279 280 if (!smb_netconnectinfo_xdr(&xdrs, info)) 281 rc = -1; 282 283 if (nbytes != NULL) 284 *nbytes = xdr_getpos(&xdrs); 285 xdr_destroy(&xdrs); 286 return (rc); 287 } 288 289 /* 290 * Decode an XDR buffer into an smb_netconnectinfo_t. 291 */ 292 int 293 smb_netconnectinfo_decode(smb_netconnectinfo_t *info, uint8_t *buf, 294 uint32_t buflen, uint_t *nbytes) 295 { 296 XDR xdrs; 297 int rc = 0; 298 299 xdrmem_create(&xdrs, (const caddr_t)buf, buflen, XDR_DECODE); 300 301 bzero(info, sizeof (smb_netconnectinfo_t)); 302 if (!smb_netconnectinfo_xdr(&xdrs, info)) 303 rc = -1; 304 305 if (nbytes != NULL) 306 *nbytes = xdr_getpos(&xdrs); 307 xdr_destroy(&xdrs); 308 return (rc); 309 } 310 311 /* 312 * XDR encode/decode for smb_netconnectinfo_t. 313 */ 314 bool_t 315 smb_netconnectinfo_xdr(XDR *xdrs, smb_netconnectinfo_t *objp) 316 { 317 if (!xdr_uint32_t(xdrs, &objp->ci_id)) 318 return (FALSE); 319 if (!xdr_uint32_t(xdrs, &objp->ci_type)) 320 return (FALSE); 321 if (!xdr_uint32_t(xdrs, &objp->ci_numopens)) 322 return (FALSE); 323 if (!xdr_uint32_t(xdrs, &objp->ci_numusers)) 324 return (FALSE); 325 if (!xdr_uint32_t(xdrs, &objp->ci_time)) 326 return (FALSE); 327 if (!xdr_uint32_t(xdrs, &objp->ci_namelen)) 328 return (FALSE); 329 if (!xdr_uint32_t(xdrs, &objp->ci_sharelen)) 330 return (FALSE); 331 if (!xdr_string(xdrs, &objp->ci_username, MAXNAMELEN)) 332 return (FALSE); 333 if (!xdr_string(xdrs, &objp->ci_share, MAXNAMELEN)) 334 return (FALSE); 335 return (TRUE); 336 } 337 338 /* 339 * Encode an smb_netfileinfo_t into a buffer. 340 */ 341 int 342 smb_netfileinfo_encode(smb_netfileinfo_t *info, uint8_t *buf, 343 uint32_t buflen, uint_t *nbytes) 344 { 345 XDR xdrs; 346 int rc = 0; 347 348 xdrmem_create(&xdrs, (const caddr_t)buf, buflen, XDR_ENCODE); 349 350 if (!smb_netfileinfo_xdr(&xdrs, info)) 351 rc = -1; 352 353 if (nbytes != NULL) 354 *nbytes = xdr_getpos(&xdrs); 355 xdr_destroy(&xdrs); 356 return (rc); 357 } 358 359 /* 360 * Decode an XDR buffer into an smb_netfileinfo_t. 361 */ 362 int 363 smb_netfileinfo_decode(smb_netfileinfo_t *info, uint8_t *buf, 364 uint32_t buflen, uint_t *nbytes) 365 { 366 XDR xdrs; 367 int rc = 0; 368 369 xdrmem_create(&xdrs, (const caddr_t)buf, buflen, XDR_DECODE); 370 371 bzero(info, sizeof (smb_netfileinfo_t)); 372 if (!smb_netfileinfo_xdr(&xdrs, info)) 373 rc = -1; 374 375 if (nbytes != NULL) 376 *nbytes = xdr_getpos(&xdrs); 377 xdr_destroy(&xdrs); 378 return (rc); 379 } 380 381 /* 382 * XDR encode/decode for smb_netfileinfo_t. 383 */ 384 bool_t 385 smb_netfileinfo_xdr(XDR *xdrs, smb_netfileinfo_t *objp) 386 { 387 if (!xdr_uint16_t(xdrs, &objp->fi_fid)) 388 return (FALSE); 389 if (!xdr_uint32_t(xdrs, &objp->fi_uniqid)) 390 return (FALSE); 391 if (!xdr_uint32_t(xdrs, &objp->fi_permissions)) 392 return (FALSE); 393 if (!xdr_uint32_t(xdrs, &objp->fi_numlocks)) 394 return (FALSE); 395 if (!xdr_uint32_t(xdrs, &objp->fi_pathlen)) 396 return (FALSE); 397 if (!xdr_uint32_t(xdrs, &objp->fi_namelen)) 398 return (FALSE); 399 if (!xdr_string(xdrs, &objp->fi_path, MAXPATHLEN)) 400 return (FALSE); 401 if (!xdr_string(xdrs, &objp->fi_username, MAXNAMELEN)) 402 return (FALSE); 403 return (TRUE); 404 } 405 406 bool_t 407 smb_gmttoken_query_xdr(XDR *xdrs, smb_gmttoken_query_t *objp) 408 { 409 if (!xdr_uint32_t(xdrs, &objp->gtq_count)) { 410 return (FALSE); 411 } 412 if (!xdr_string(xdrs, &objp->gtq_path, ~0)) { 413 return (FALSE); 414 } 415 return (TRUE); 416 } 417 418 static bool_t 419 smb_gmttoken_xdr(XDR *xdrs, smb_gmttoken_t *objp) 420 { 421 if (!xdr_string(xdrs, objp, SMB_VSS_GMT_SIZE)) { 422 return (FALSE); 423 } 424 return (TRUE); 425 } 426 427 bool_t 428 smb_gmttoken_response_xdr(XDR *xdrs, smb_gmttoken_response_t *objp) 429 { 430 if (!xdr_uint32_t(xdrs, &objp->gtr_count)) { 431 return (FALSE); 432 } 433 if (!xdr_array(xdrs, (char **)&objp->gtr_gmttokens.gtr_gmttokens_val, 434 (uint_t *)&objp->gtr_gmttokens.gtr_gmttokens_len, ~0, 435 sizeof (smb_gmttoken_t), (xdrproc_t)smb_gmttoken_xdr)) { 436 return (FALSE); 437 } 438 return (TRUE); 439 } 440 441 bool_t 442 smb_gmttoken_snapname_xdr(XDR *xdrs, smb_gmttoken_snapname_t *objp) 443 { 444 if (!xdr_string(xdrs, &objp->gts_path, MAXPATHLEN)) { 445 return (FALSE); 446 } 447 if (!xdr_string(xdrs, &objp->gts_gmttoken, SMB_VSS_GMT_SIZE)) { 448 return (FALSE); 449 } 450 return (TRUE); 451 } 452 453 bool_t 454 smb_quota_xdr(XDR *xdrs, smb_quota_t *objp) 455 { 456 if (!xdr_vector(xdrs, (char *)objp->q_sidstr, SMB_SID_STRSZ, 457 sizeof (char), (xdrproc_t)xdr_char)) 458 return (FALSE); 459 if (!xdr_uint32_t(xdrs, &objp->q_sidtype)) 460 return (FALSE); 461 if (!xdr_uint64_t(xdrs, &objp->q_used)) 462 return (FALSE); 463 if (!xdr_uint64_t(xdrs, &objp->q_thresh)) 464 return (FALSE); 465 if (!xdr_uint64_t(xdrs, &objp->q_limit)) 466 return (FALSE); 467 468 return (TRUE); 469 } 470 471 bool_t 472 smb_quota_sid_xdr(XDR *xdrs, smb_quota_sid_t *objp) 473 { 474 if (!xdr_vector(xdrs, (char *)objp->qs_sidstr, SMB_SID_STRSZ, 475 sizeof (char), (xdrproc_t)xdr_char)) 476 return (FALSE); 477 return (TRUE); 478 } 479 480 bool_t 481 smb_quota_query_xdr(XDR *xdrs, smb_quota_query_t *objp) 482 { 483 if (!xdr_string(xdrs, &objp->qq_root_path, ~0)) 484 return (FALSE); 485 if (!xdr_uint32_t(xdrs, &objp->qq_query_op)) 486 return (FALSE); 487 if (!xdr_bool(xdrs, &objp->qq_single)) 488 return (FALSE); 489 if (!xdr_bool(xdrs, &objp->qq_restart)) 490 return (FALSE); 491 if (!xdr_uint32_t(xdrs, &objp->qq_max_quota)) 492 return (FALSE); 493 if (!smb_list_xdr(xdrs, &objp->qq_sid_list, 494 offsetof(smb_quota_sid_t, qs_list_node), 495 sizeof (smb_quota_sid_t), (xdrproc_t)smb_quota_sid_xdr)) 496 return (FALSE); 497 498 return (TRUE); 499 } 500 501 bool_t 502 smb_quota_response_xdr(XDR *xdrs, smb_quota_response_t *objp) 503 { 504 if (!xdr_uint32_t(xdrs, &objp->qr_status)) 505 return (FALSE); 506 if (!smb_list_xdr(xdrs, &objp->qr_quota_list, 507 offsetof(smb_quota_t, q_list_node), 508 sizeof (smb_quota_t), (xdrproc_t)smb_quota_xdr)) 509 return (FALSE); 510 return (TRUE); 511 } 512 513 bool_t 514 smb_quota_set_xdr(XDR *xdrs, smb_quota_set_t *objp) 515 { 516 if (!xdr_string(xdrs, &objp->qs_root_path, ~0)) 517 return (FALSE); 518 if (!smb_list_xdr(xdrs, &objp->qs_quota_list, 519 offsetof(smb_quota_t, q_list_node), 520 sizeof (smb_quota_t), (xdrproc_t)smb_quota_xdr)) 521 return (FALSE); 522 return (TRUE); 523 } 524 525 /* 526 * XDR a list_t list of elements 527 * offset - offset of list_node_t in list element 528 * elsize - size of list element 529 * elproc - XDR function for the list element 530 */ 531 bool_t 532 smb_list_xdr(XDR *xdrs, list_t *list, const size_t offset, 533 const size_t elsize, const xdrproc_t elproc) 534 { 535 void *node; 536 uint32_t count = 0; 537 538 switch (xdrs->x_op) { 539 case XDR_ENCODE: 540 node = list_head(list); 541 while (node) { 542 ++count; 543 node = list_next(list, node); 544 } 545 if (!xdr_uint32_t(xdrs, &count)) 546 return (FALSE); 547 548 node = list_head(list); 549 while (node) { 550 if (!elproc(xdrs, node)) 551 return (FALSE); 552 node = list_next(list, node); 553 } 554 return (TRUE); 555 556 case XDR_DECODE: 557 if (!xdr_uint32_t(xdrs, &count)) 558 return (FALSE); 559 list_create(list, elsize, offset); 560 while (count) { 561 node = MEM_MALLOC("xdr", elsize); 562 if (node == NULL) 563 return (FALSE); 564 if (!elproc(xdrs, node)) 565 return (FALSE); 566 list_insert_tail(list, node); 567 --count; 568 } 569 return (TRUE); 570 571 case XDR_FREE: 572 while ((node = list_head(list)) != NULL) { 573 list_remove(list, node); 574 (void) elproc(xdrs, node); 575 MEM_FREE("xdr", node); 576 } 577 list_destroy(list); 578 return (TRUE); 579 } 580 581 return (FALSE); 582 } 583 584 bool_t 585 dfs_target_pclass_xdr(XDR *xdrs, dfs_target_pclass_t *objp) 586 { 587 return (xdr_enum(xdrs, (enum_t *)objp)); 588 } 589 590 bool_t 591 dfs_target_priority_xdr(XDR *xdrs, dfs_target_priority_t *objp) 592 { 593 if (!dfs_target_pclass_xdr(xdrs, &objp->p_class)) 594 return (FALSE); 595 596 if (!xdr_uint16_t(xdrs, &objp->p_rank)) 597 return (FALSE); 598 599 return (TRUE); 600 } 601 602 bool_t 603 dfs_target_xdr(XDR *xdrs, dfs_target_t *objp) 604 { 605 if (!xdr_vector(xdrs, (char *)objp->t_server, DFS_SRVNAME_MAX, 606 sizeof (char), (xdrproc_t)xdr_char)) 607 return (FALSE); 608 609 if (!xdr_vector(xdrs, (char *)objp->t_share, DFS_NAME_MAX, 610 sizeof (char), (xdrproc_t)xdr_char)) 611 return (FALSE); 612 613 if (!xdr_uint32_t(xdrs, &objp->t_state)) 614 return (FALSE); 615 616 if (!dfs_target_priority_xdr(xdrs, &objp->t_priority)) 617 return (FALSE); 618 619 return (TRUE); 620 } 621 622 bool_t 623 dfs_reftype_xdr(XDR *xdrs, dfs_reftype_t *objp) 624 { 625 return (xdr_enum(xdrs, (enum_t *)objp)); 626 } 627 628 bool_t 629 dfs_info_xdr(XDR *xdrs, dfs_info_t *objp) 630 { 631 if (!xdr_vector(xdrs, (char *)objp->i_uncpath, DFS_PATH_MAX, 632 sizeof (char), (xdrproc_t)xdr_char)) 633 return (FALSE); 634 635 if (!xdr_vector(xdrs, (char *)objp->i_comment, DFS_COMMENT_MAX, 636 sizeof (char), (xdrproc_t)xdr_char)) 637 return (FALSE); 638 639 if (!xdr_vector(xdrs, (char *)objp->i_guid, 640 UUID_PRINTABLE_STRING_LENGTH, sizeof (char), (xdrproc_t)xdr_char)) 641 return (FALSE); 642 643 if (!xdr_uint32_t(xdrs, &objp->i_state)) 644 return (FALSE); 645 646 if (!xdr_uint32_t(xdrs, &objp->i_timeout)) 647 return (FALSE); 648 649 if (!xdr_uint32_t(xdrs, &objp->i_propflags)) 650 return (FALSE); 651 652 if (!xdr_uint32_t(xdrs, &objp->i_type)) 653 return (FALSE); 654 655 if (!xdr_array(xdrs, (char **)&objp->i_targets, 656 (uint32_t *)&objp->i_ntargets, ~0, sizeof (dfs_target_t), 657 (xdrproc_t)dfs_target_xdr)) 658 return (FALSE); 659 660 return (TRUE); 661 } 662 663 bool_t 664 dfs_referral_query_xdr(XDR *xdrs, dfs_referral_query_t *objp) 665 { 666 if (!dfs_reftype_xdr(xdrs, &objp->rq_type)) 667 return (FALSE); 668 669 if (!xdr_string(xdrs, &objp->rq_path, ~0)) 670 return (FALSE); 671 672 return (TRUE); 673 } 674 675 bool_t 676 dfs_referral_response_xdr(XDR *xdrs, dfs_referral_response_t *objp) 677 { 678 if (!dfs_info_xdr(xdrs, &objp->rp_referrals)) 679 return (FALSE); 680 681 if (!xdr_uint32_t(xdrs, &objp->rp_status)) 682 return (FALSE); 683 684 return (TRUE); 685 } 686 687 bool_t 688 smb_shr_hostaccess_query_xdr(XDR *xdrs, smb_shr_hostaccess_query_t *objp) 689 { 690 if (!xdr_string(xdrs, &objp->shq_none, ~0)) 691 return (FALSE); 692 693 if (!xdr_string(xdrs, &objp->shq_ro, ~0)) 694 return (FALSE); 695 696 if (!xdr_string(xdrs, &objp->shq_rw, ~0)) 697 return (FALSE); 698 699 if (!xdr_uint32_t(xdrs, &objp->shq_flag)) 700 return (FALSE); 701 702 if (!smb_inaddr_xdr(xdrs, &objp->shq_ipaddr)) 703 return (FALSE); 704 705 return (TRUE); 706 } 707 708 bool_t 709 smb_shr_execinfo_xdr(XDR *xdrs, smb_shr_execinfo_t *objp) 710 { 711 if (!xdr_string(xdrs, &objp->e_sharename, ~0)) 712 return (FALSE); 713 714 if (!xdr_string(xdrs, &objp->e_winname, ~0)) 715 return (FALSE); 716 717 if (!xdr_string(xdrs, &objp->e_userdom, ~0)) 718 return (FALSE); 719 720 if (!smb_inaddr_xdr(xdrs, &objp->e_srv_ipaddr)) 721 return (FALSE); 722 723 if (!smb_inaddr_xdr(xdrs, &objp->e_cli_ipaddr)) 724 return (FALSE); 725 726 if (!xdr_string(xdrs, &objp->e_cli_netbiosname, ~0)) 727 return (FALSE); 728 729 if (!xdr_u_int(xdrs, &objp->e_uid)) 730 return (FALSE); 731 732 if (!xdr_int(xdrs, &objp->e_type)) 733 return (FALSE); 734 735 return (TRUE); 736 } 737