1da6c28aaSamw /* 2da6c28aaSamw * CDDL HEADER START 3da6c28aaSamw * 4da6c28aaSamw * The contents of this file are subject to the terms of the 5da6c28aaSamw * Common Development and Distribution License (the "License"). 6da6c28aaSamw * You may not use this file except in compliance with the License. 7da6c28aaSamw * 8da6c28aaSamw * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9da6c28aaSamw * or http://www.opensolaris.org/os/licensing. 10da6c28aaSamw * See the License for the specific language governing permissions 11da6c28aaSamw * and limitations under the License. 12da6c28aaSamw * 13da6c28aaSamw * When distributing Covered Code, include this CDDL HEADER in each 14da6c28aaSamw * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15da6c28aaSamw * If applicable, add the following below this CDDL HEADER, with the 16da6c28aaSamw * fields enclosed by brackets "[]" replaced with your own identifying 17da6c28aaSamw * information: Portions Copyright [yyyy] [name of copyright owner] 18da6c28aaSamw * 19da6c28aaSamw * CDDL HEADER END 20da6c28aaSamw */ 21da6c28aaSamw 22da6c28aaSamw /* 23148c5f43SAlan Wright * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 24*b819cea2SGordon Ross * Copyright 2013 Nexenta Systems, Inc. All rights reserved. 25da6c28aaSamw */ 26da6c28aaSamw 27da6c28aaSamw /* 28da6c28aaSamw * User-space door client for LanMan share management. 29da6c28aaSamw */ 30da6c28aaSamw 31da6c28aaSamw #include <syslog.h> 32da6c28aaSamw #include <door.h> 33da6c28aaSamw #include <fcntl.h> 34da6c28aaSamw #include <stdarg.h> 35da6c28aaSamw #include <errno.h> 36da6c28aaSamw #include <string.h> 37da6c28aaSamw #include <strings.h> 38dc20a302Sas200622 #include <unistd.h> 39dc20a302Sas200622 #include <thread.h> 40dc20a302Sas200622 #include <synch.h> 41da6c28aaSamw 42da6c28aaSamw #include <smbsrv/libsmb.h> 433db3f65cSamw #include <smbsrv/smb_share.h> 44bbf6f00cSJordan Brown #include <smbsrv/smb.h> 45da6c28aaSamw 468d96b23eSAlan Wright #define SMB_SHARE_DOOR_CALL_RETRIES 3 478d96b23eSAlan Wright 483db3f65cSamw static int smb_share_dfd = -1; 493db3f65cSamw static uint64_t smb_share_dncall = 0; 503db3f65cSamw static mutex_t smb_share_dmtx; 513db3f65cSamw static cond_t smb_share_dcv; 52da6c28aaSamw 538d96b23eSAlan Wright static int smb_share_door_clnt_open(void); 548d96b23eSAlan Wright static void smb_share_door_clnt_close(void); 558d96b23eSAlan Wright 568d96b23eSAlan Wright void 578d96b23eSAlan Wright smb_share_door_clnt_init(void) 588d96b23eSAlan Wright { 598d96b23eSAlan Wright (void) mutex_lock(&smb_share_dmtx); 608d96b23eSAlan Wright (void) smb_share_door_clnt_open(); 618d96b23eSAlan Wright (void) mutex_unlock(&smb_share_dmtx); 628d96b23eSAlan Wright } 638d96b23eSAlan Wright 648d96b23eSAlan Wright void 658d96b23eSAlan Wright smb_share_door_clnt_fini(void) 668d96b23eSAlan Wright { 678d96b23eSAlan Wright (void) mutex_lock(&smb_share_dmtx); 688d96b23eSAlan Wright smb_share_door_clnt_close(); 698d96b23eSAlan Wright (void) mutex_unlock(&smb_share_dmtx); 708d96b23eSAlan Wright } 718d96b23eSAlan Wright 72da6c28aaSamw /* 738d96b23eSAlan Wright * Open smb_share_door. This is a private call for use by 748d96b23eSAlan Wright * smb_share_door_clnt_enter() and must be called with smb_share_dmtx held. 75dc20a302Sas200622 * 76dc20a302Sas200622 * Returns the door fd on success. Otherwise, -1. 77da6c28aaSamw */ 78da6c28aaSamw static int 798d96b23eSAlan Wright smb_share_door_clnt_open(void) 80da6c28aaSamw { 81*b819cea2SGordon Ross const char *door_name; 82*b819cea2SGordon Ross 833db3f65cSamw if (smb_share_dfd == -1) { 84*b819cea2SGordon Ross door_name = getenv("SMB_SHARE_DNAME"); 85*b819cea2SGordon Ross if (door_name == NULL) 86*b819cea2SGordon Ross door_name = SMB_SHARE_DNAME; 87*b819cea2SGordon Ross 88*b819cea2SGordon Ross if ((smb_share_dfd = open(door_name, O_RDONLY)) < 0) 893db3f65cSamw smb_share_dfd = -1; 90dc20a302Sas200622 else 913db3f65cSamw smb_share_dncall = 0; 92da6c28aaSamw } 93dc20a302Sas200622 943db3f65cSamw return (smb_share_dfd); 95dc20a302Sas200622 } 96dc20a302Sas200622 97dc20a302Sas200622 /* 988d96b23eSAlan Wright * Close smb_share_door. 998d96b23eSAlan Wright * Private call that must be called with smb_share_dmtx held. 100dc20a302Sas200622 */ 1018d96b23eSAlan Wright static void 1028d96b23eSAlan Wright smb_share_door_clnt_close(void) 103dc20a302Sas200622 { 1043db3f65cSamw if (smb_share_dfd != -1) { 1053db3f65cSamw while (smb_share_dncall > 0) 1063db3f65cSamw (void) cond_wait(&smb_share_dcv, &smb_share_dmtx); 107dc20a302Sas200622 1083db3f65cSamw if (smb_share_dfd != -1) { 1093db3f65cSamw (void) close(smb_share_dfd); 1103db3f65cSamw smb_share_dfd = -1; 111dc20a302Sas200622 } 112dc20a302Sas200622 } 113dc20a302Sas200622 } 114dc20a302Sas200622 115dc20a302Sas200622 /* 1168d96b23eSAlan Wright * Entry handler for smb_share_door calls. 117dc20a302Sas200622 */ 118dc20a302Sas200622 static door_arg_t * 1198d96b23eSAlan Wright smb_share_door_clnt_enter(void) 120dc20a302Sas200622 { 121dc20a302Sas200622 door_arg_t *arg; 122dc20a302Sas200622 char *buf; 123dc20a302Sas200622 1243db3f65cSamw (void) mutex_lock(&smb_share_dmtx); 125dc20a302Sas200622 1268d96b23eSAlan Wright if (smb_share_door_clnt_open() == -1) { 1273db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 128dc20a302Sas200622 return (NULL); 129dc20a302Sas200622 } 130dc20a302Sas200622 1313db3f65cSamw if ((arg = malloc(sizeof (door_arg_t) + SMB_SHARE_DSIZE)) != NULL) { 132dc20a302Sas200622 buf = ((char *)arg) + sizeof (door_arg_t); 133dc20a302Sas200622 bzero(arg, sizeof (door_arg_t)); 134dc20a302Sas200622 arg->data_ptr = buf; 135dc20a302Sas200622 arg->rbuf = buf; 1363db3f65cSamw arg->rsize = SMB_SHARE_DSIZE; 137dc20a302Sas200622 1383db3f65cSamw ++smb_share_dncall; 139dc20a302Sas200622 } 140dc20a302Sas200622 1413db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 142dc20a302Sas200622 return (arg); 143dc20a302Sas200622 } 144dc20a302Sas200622 145dc20a302Sas200622 /* 1468d96b23eSAlan Wright * Exit handler for smb_share_door calls. 147dc20a302Sas200622 */ 148dc20a302Sas200622 static void 1498d96b23eSAlan Wright smb_share_door_clnt_exit(door_arg_t *arg, boolean_t must_close, char *errmsg) 150dc20a302Sas200622 { 151dc20a302Sas200622 if (errmsg) 1528d96b23eSAlan Wright syslog(LOG_DEBUG, "smb_share_door: %s failed", errmsg); 153dc20a302Sas200622 1543db3f65cSamw (void) mutex_lock(&smb_share_dmtx); 155dc20a302Sas200622 free(arg); 1563db3f65cSamw --smb_share_dncall; 1573db3f65cSamw (void) cond_signal(&smb_share_dcv); 1588d96b23eSAlan Wright 1598d96b23eSAlan Wright if (must_close) 1608d96b23eSAlan Wright smb_share_door_clnt_close(); 1618d96b23eSAlan Wright 1623db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 163da6c28aaSamw } 164da6c28aaSamw 1658d96b23eSAlan Wright static int 1668d96b23eSAlan Wright smb_share_door_call(int fd, door_arg_t *arg) 1678d96b23eSAlan Wright { 1688d96b23eSAlan Wright int rc; 1698d96b23eSAlan Wright int i; 1708d96b23eSAlan Wright 1718d96b23eSAlan Wright for (i = 0; i < SMB_SHARE_DOOR_CALL_RETRIES; ++i) { 1728d96b23eSAlan Wright errno = 0; 1738d96b23eSAlan Wright 1748d96b23eSAlan Wright if ((rc = door_call(fd, arg)) == 0) 1758d96b23eSAlan Wright break; 1768d96b23eSAlan Wright 1778d96b23eSAlan Wright if (errno != EAGAIN && errno != EINTR) 1788d96b23eSAlan Wright break; 1798d96b23eSAlan Wright } 1808d96b23eSAlan Wright 1818d96b23eSAlan Wright return (rc); 1828d96b23eSAlan Wright } 1838d96b23eSAlan Wright 184da6c28aaSamw static int 1853db3f65cSamw smb_share_dchk(smb_dr_ctx_t *dec_ctx) 186da6c28aaSamw { 187da6c28aaSamw int status = smb_dr_get_int32(dec_ctx); 188da6c28aaSamw 1893db3f65cSamw if (status != SMB_SHARE_DSUCCESS) { 1903db3f65cSamw if (status == SMB_SHARE_DERROR) 191dc20a302Sas200622 (void) smb_dr_get_uint32(dec_ctx); 192dc20a302Sas200622 return (-1); 193da6c28aaSamw } 194da6c28aaSamw 195dc20a302Sas200622 return (0); 196da6c28aaSamw } 197da6c28aaSamw 1983db3f65cSamw uint32_t 1993db3f65cSamw smb_share_list(int offset, smb_shrlist_t *list) 200da6c28aaSamw { 201dc20a302Sas200622 door_arg_t *arg; 202da6c28aaSamw smb_dr_ctx_t *dec_ctx; 203da6c28aaSamw smb_dr_ctx_t *enc_ctx; 2043db3f65cSamw uint32_t rc; 205da6c28aaSamw 206c8ec8eeaSjose borrego bzero(list, sizeof (smb_shrlist_t)); 207c8ec8eeaSjose borrego 2088d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 209da6c28aaSamw return (NERR_InternalError); 210da6c28aaSamw 2113db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 2123db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_LIST); 213da6c28aaSamw smb_dr_put_int32(enc_ctx, offset); 214da6c28aaSamw 215dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 216dc20a302Sas200622 if (rc != 0) { 2178d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 218da6c28aaSamw return (NERR_InternalError); 219da6c28aaSamw } 220da6c28aaSamw 2218d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 2228d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 223da6c28aaSamw return (NERR_InternalError); 224da6c28aaSamw } 225da6c28aaSamw 226dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 2273db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 228dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 2298d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 230da6c28aaSamw return (NERR_InternalError); 231da6c28aaSamw } 232da6c28aaSamw 233c8ec8eeaSjose borrego (void) smb_dr_get_buf(dec_ctx, (unsigned char *)list, 234c8ec8eeaSjose borrego sizeof (smb_shrlist_t)); 235dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 2368d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 237da6c28aaSamw return (NERR_InternalError); 238da6c28aaSamw } 239da6c28aaSamw 2408d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 2413ad684d6Sjb150015 return (NERR_Success); 242da6c28aaSamw } 243da6c28aaSamw 244da6c28aaSamw int 2453db3f65cSamw smb_share_count(void) 246da6c28aaSamw { 247dc20a302Sas200622 door_arg_t *arg; 248da6c28aaSamw smb_dr_ctx_t *dec_ctx; 249da6c28aaSamw smb_dr_ctx_t *enc_ctx; 2503db3f65cSamw uint32_t num_shares; 251dc20a302Sas200622 int rc; 252da6c28aaSamw 2538d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 254da6c28aaSamw return (-1); 255da6c28aaSamw 2563db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 2573db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_NUM_SHARES); 258dc20a302Sas200622 259dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 260dc20a302Sas200622 if (rc != 0) { 2618d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 262da6c28aaSamw return (-1); 263da6c28aaSamw } 264da6c28aaSamw 2658d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 2668d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 267da6c28aaSamw return (-1); 268da6c28aaSamw } 269da6c28aaSamw 270dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 2713db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 272dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 2738d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 274da6c28aaSamw return (-1); 275da6c28aaSamw } 276da6c28aaSamw 277da6c28aaSamw num_shares = smb_dr_get_uint32(dec_ctx); 278dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 2798d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 280da6c28aaSamw return (-1); 281da6c28aaSamw } 282da6c28aaSamw 2838d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 284da6c28aaSamw return (num_shares); 285da6c28aaSamw } 286da6c28aaSamw 2873db3f65cSamw uint32_t 288c8ec8eeaSjose borrego smb_share_delete(char *share_name) 289da6c28aaSamw { 290dc20a302Sas200622 door_arg_t *arg; 291da6c28aaSamw smb_dr_ctx_t *dec_ctx; 292da6c28aaSamw smb_dr_ctx_t *enc_ctx; 2933db3f65cSamw uint32_t rc; 294da6c28aaSamw 2958d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 296da6c28aaSamw return (NERR_InternalError); 297da6c28aaSamw 2983db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 2993db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_DELETE); 300da6c28aaSamw smb_dr_put_string(enc_ctx, share_name); 301da6c28aaSamw 302dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 303dc20a302Sas200622 if (rc != 0) { 3048d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 305da6c28aaSamw return (NERR_InternalError); 306da6c28aaSamw } 307da6c28aaSamw 3088d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 3098d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 310da6c28aaSamw return (NERR_InternalError); 311da6c28aaSamw } 312da6c28aaSamw 313dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 3143db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 315dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 3168d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 317da6c28aaSamw return (NERR_InternalError); 318da6c28aaSamw } 319da6c28aaSamw 320da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 321dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 3228d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 323da6c28aaSamw return (NERR_InternalError); 324da6c28aaSamw } 325da6c28aaSamw 3268d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 327da6c28aaSamw return (rc); 328da6c28aaSamw 329da6c28aaSamw } 330da6c28aaSamw 3313db3f65cSamw uint32_t 332c8ec8eeaSjose borrego smb_share_rename(char *from, char *to) 333da6c28aaSamw { 334dc20a302Sas200622 door_arg_t *arg; 335da6c28aaSamw smb_dr_ctx_t *dec_ctx; 336da6c28aaSamw smb_dr_ctx_t *enc_ctx; 3373db3f65cSamw uint32_t rc; 338da6c28aaSamw 3398d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 340da6c28aaSamw return (NERR_InternalError); 341da6c28aaSamw 3423db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 3433db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_RENAME); 344da6c28aaSamw smb_dr_put_string(enc_ctx, from); 345da6c28aaSamw smb_dr_put_string(enc_ctx, to); 346da6c28aaSamw 347dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 348dc20a302Sas200622 if (rc != 0) { 3498d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 350da6c28aaSamw return (NERR_InternalError); 351da6c28aaSamw } 352da6c28aaSamw 3538d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 3548d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 355da6c28aaSamw return (NERR_InternalError); 356da6c28aaSamw } 357da6c28aaSamw 358dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 3593db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 360dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 3618d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 362da6c28aaSamw return (NERR_InternalError); 363da6c28aaSamw } 364da6c28aaSamw 365da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 366dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 3678d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 368da6c28aaSamw return (NERR_InternalError); 369da6c28aaSamw } 370da6c28aaSamw 3718d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 372da6c28aaSamw return (rc); 373da6c28aaSamw } 374da6c28aaSamw 3753db3f65cSamw uint32_t 376c8ec8eeaSjose borrego smb_share_create(smb_share_t *si) 377da6c28aaSamw { 378dc20a302Sas200622 door_arg_t *arg; 379da6c28aaSamw smb_dr_ctx_t *dec_ctx; 380da6c28aaSamw smb_dr_ctx_t *enc_ctx; 3813db3f65cSamw uint32_t rc; 382da6c28aaSamw 3838d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 384da6c28aaSamw return (NERR_InternalError); 385da6c28aaSamw 3863db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 3873db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_ADD); 3883db3f65cSamw smb_dr_put_share(enc_ctx, si); 389da6c28aaSamw 390dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 391dc20a302Sas200622 if (rc != 0) { 3928d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 393da6c28aaSamw return (NERR_InternalError); 394da6c28aaSamw } 395da6c28aaSamw 3968d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 3978d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 398da6c28aaSamw return (NERR_InternalError); 399da6c28aaSamw } 400da6c28aaSamw 401dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 4023db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 403dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 4048d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 405da6c28aaSamw return (NERR_InternalError); 406da6c28aaSamw } 407da6c28aaSamw 408da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 4093db3f65cSamw smb_dr_get_share(dec_ctx, si); 410dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 4118d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 412da6c28aaSamw return (NERR_InternalError); 413da6c28aaSamw } 414da6c28aaSamw 4158d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 416da6c28aaSamw return (rc); 417da6c28aaSamw } 418da6c28aaSamw 4193db3f65cSamw uint32_t 420b89a8333Snatalie li - Sun Microsystems - Irvine United States smb_share_modify(smb_share_t *si) 421da6c28aaSamw { 422dc20a302Sas200622 door_arg_t *arg; 423da6c28aaSamw smb_dr_ctx_t *dec_ctx; 424da6c28aaSamw smb_dr_ctx_t *enc_ctx; 4253db3f65cSamw uint32_t rc; 426da6c28aaSamw 4278d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 428da6c28aaSamw return (NERR_InternalError); 429da6c28aaSamw 4303db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 431c8ec8eeaSjose borrego smb_dr_put_uint32(enc_ctx, SMB_SHROP_MODIFY); 432b89a8333Snatalie li - Sun Microsystems - Irvine United States smb_dr_put_share(enc_ctx, si); 433da6c28aaSamw 434dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 435dc20a302Sas200622 if (rc != 0) { 4368d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 437da6c28aaSamw return (NERR_InternalError); 438da6c28aaSamw } 439da6c28aaSamw 4408d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 4418d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 442da6c28aaSamw return (NERR_InternalError); 443da6c28aaSamw } 444da6c28aaSamw 445dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 4463db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 447dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 4488d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 449da6c28aaSamw return (NERR_InternalError); 450da6c28aaSamw } 451da6c28aaSamw 452da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 453dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 4548d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 455da6c28aaSamw return (NERR_InternalError); 456da6c28aaSamw } 457da6c28aaSamw 4588d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 459da6c28aaSamw return (rc); 460da6c28aaSamw } 461