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 /* 237f667e74Sjose borrego * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24da6c28aaSamw * Use is subject to license terms. 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> 44da6c28aaSamw #include <smbsrv/lmerr.h> 45*bbf6f00cSJordan Brown #include <smbsrv/smb.h> 46da6c28aaSamw 478d96b23eSAlan Wright #define SMB_SHARE_DOOR_CALL_RETRIES 3 488d96b23eSAlan Wright 493db3f65cSamw static int smb_share_dfd = -1; 503db3f65cSamw static uint64_t smb_share_dncall = 0; 513db3f65cSamw static mutex_t smb_share_dmtx; 523db3f65cSamw static cond_t smb_share_dcv; 53da6c28aaSamw 548d96b23eSAlan Wright static int smb_share_door_clnt_open(void); 558d96b23eSAlan Wright static void smb_share_door_clnt_close(void); 568d96b23eSAlan Wright 578d96b23eSAlan Wright void 588d96b23eSAlan Wright smb_share_door_clnt_init(void) 598d96b23eSAlan Wright { 608d96b23eSAlan Wright (void) mutex_lock(&smb_share_dmtx); 618d96b23eSAlan Wright (void) smb_share_door_clnt_open(); 628d96b23eSAlan Wright (void) mutex_unlock(&smb_share_dmtx); 638d96b23eSAlan Wright } 648d96b23eSAlan Wright 658d96b23eSAlan Wright void 668d96b23eSAlan Wright smb_share_door_clnt_fini(void) 678d96b23eSAlan Wright { 688d96b23eSAlan Wright (void) mutex_lock(&smb_share_dmtx); 698d96b23eSAlan Wright smb_share_door_clnt_close(); 708d96b23eSAlan Wright (void) mutex_unlock(&smb_share_dmtx); 718d96b23eSAlan Wright } 728d96b23eSAlan Wright 73da6c28aaSamw /* 748d96b23eSAlan Wright * Open smb_share_door. This is a private call for use by 758d96b23eSAlan Wright * smb_share_door_clnt_enter() and must be called with smb_share_dmtx held. 76dc20a302Sas200622 * 77dc20a302Sas200622 * Returns the door fd on success. Otherwise, -1. 78da6c28aaSamw */ 79da6c28aaSamw static int 808d96b23eSAlan Wright smb_share_door_clnt_open(void) 81da6c28aaSamw { 823db3f65cSamw if (smb_share_dfd == -1) { 833db3f65cSamw if ((smb_share_dfd = open(SMB_SHARE_DNAME, O_RDONLY)) < 0) 843db3f65cSamw smb_share_dfd = -1; 85dc20a302Sas200622 else 863db3f65cSamw smb_share_dncall = 0; 87da6c28aaSamw } 88dc20a302Sas200622 893db3f65cSamw return (smb_share_dfd); 90dc20a302Sas200622 } 91dc20a302Sas200622 92dc20a302Sas200622 /* 938d96b23eSAlan Wright * Close smb_share_door. 948d96b23eSAlan Wright * Private call that must be called with smb_share_dmtx held. 95dc20a302Sas200622 */ 968d96b23eSAlan Wright static void 978d96b23eSAlan Wright smb_share_door_clnt_close(void) 98dc20a302Sas200622 { 993db3f65cSamw if (smb_share_dfd != -1) { 1003db3f65cSamw while (smb_share_dncall > 0) 1013db3f65cSamw (void) cond_wait(&smb_share_dcv, &smb_share_dmtx); 102dc20a302Sas200622 1033db3f65cSamw if (smb_share_dfd != -1) { 1043db3f65cSamw (void) close(smb_share_dfd); 1053db3f65cSamw smb_share_dfd = -1; 106dc20a302Sas200622 } 107dc20a302Sas200622 } 108dc20a302Sas200622 } 109dc20a302Sas200622 110dc20a302Sas200622 /* 1118d96b23eSAlan Wright * Entry handler for smb_share_door calls. 112dc20a302Sas200622 */ 113dc20a302Sas200622 static door_arg_t * 1148d96b23eSAlan Wright smb_share_door_clnt_enter(void) 115dc20a302Sas200622 { 116dc20a302Sas200622 door_arg_t *arg; 117dc20a302Sas200622 char *buf; 118dc20a302Sas200622 1193db3f65cSamw (void) mutex_lock(&smb_share_dmtx); 120dc20a302Sas200622 1218d96b23eSAlan Wright if (smb_share_door_clnt_open() == -1) { 1223db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 123dc20a302Sas200622 return (NULL); 124dc20a302Sas200622 } 125dc20a302Sas200622 1263db3f65cSamw if ((arg = malloc(sizeof (door_arg_t) + SMB_SHARE_DSIZE)) != NULL) { 127dc20a302Sas200622 buf = ((char *)arg) + sizeof (door_arg_t); 128dc20a302Sas200622 bzero(arg, sizeof (door_arg_t)); 129dc20a302Sas200622 arg->data_ptr = buf; 130dc20a302Sas200622 arg->rbuf = buf; 1313db3f65cSamw arg->rsize = SMB_SHARE_DSIZE; 132dc20a302Sas200622 1333db3f65cSamw ++smb_share_dncall; 134dc20a302Sas200622 } 135dc20a302Sas200622 1363db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 137dc20a302Sas200622 return (arg); 138dc20a302Sas200622 } 139dc20a302Sas200622 140dc20a302Sas200622 /* 1418d96b23eSAlan Wright * Exit handler for smb_share_door calls. 142dc20a302Sas200622 */ 143dc20a302Sas200622 static void 1448d96b23eSAlan Wright smb_share_door_clnt_exit(door_arg_t *arg, boolean_t must_close, char *errmsg) 145dc20a302Sas200622 { 146dc20a302Sas200622 if (errmsg) 1478d96b23eSAlan Wright syslog(LOG_DEBUG, "smb_share_door: %s failed", errmsg); 148dc20a302Sas200622 1493db3f65cSamw (void) mutex_lock(&smb_share_dmtx); 150dc20a302Sas200622 free(arg); 1513db3f65cSamw --smb_share_dncall; 1523db3f65cSamw (void) cond_signal(&smb_share_dcv); 1538d96b23eSAlan Wright 1548d96b23eSAlan Wright if (must_close) 1558d96b23eSAlan Wright smb_share_door_clnt_close(); 1568d96b23eSAlan Wright 1573db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 158da6c28aaSamw } 159da6c28aaSamw 1608d96b23eSAlan Wright static int 1618d96b23eSAlan Wright smb_share_door_call(int fd, door_arg_t *arg) 1628d96b23eSAlan Wright { 1638d96b23eSAlan Wright int rc; 1648d96b23eSAlan Wright int i; 1658d96b23eSAlan Wright 1668d96b23eSAlan Wright for (i = 0; i < SMB_SHARE_DOOR_CALL_RETRIES; ++i) { 1678d96b23eSAlan Wright errno = 0; 1688d96b23eSAlan Wright 1698d96b23eSAlan Wright if ((rc = door_call(fd, arg)) == 0) 1708d96b23eSAlan Wright break; 1718d96b23eSAlan Wright 1728d96b23eSAlan Wright if (errno != EAGAIN && errno != EINTR) 1738d96b23eSAlan Wright break; 1748d96b23eSAlan Wright } 1758d96b23eSAlan Wright 1768d96b23eSAlan Wright return (rc); 1778d96b23eSAlan Wright } 1788d96b23eSAlan Wright 179da6c28aaSamw static int 1803db3f65cSamw smb_share_dchk(smb_dr_ctx_t *dec_ctx) 181da6c28aaSamw { 182da6c28aaSamw int status = smb_dr_get_int32(dec_ctx); 183da6c28aaSamw 1843db3f65cSamw if (status != SMB_SHARE_DSUCCESS) { 1853db3f65cSamw if (status == SMB_SHARE_DERROR) 186dc20a302Sas200622 (void) smb_dr_get_uint32(dec_ctx); 187dc20a302Sas200622 return (-1); 188da6c28aaSamw } 189da6c28aaSamw 190dc20a302Sas200622 return (0); 191da6c28aaSamw } 192da6c28aaSamw 1933db3f65cSamw uint32_t 1943db3f65cSamw smb_share_list(int offset, smb_shrlist_t *list) 195da6c28aaSamw { 196dc20a302Sas200622 door_arg_t *arg; 197da6c28aaSamw smb_dr_ctx_t *dec_ctx; 198da6c28aaSamw smb_dr_ctx_t *enc_ctx; 1993db3f65cSamw uint32_t rc; 200da6c28aaSamw 201c8ec8eeaSjose borrego bzero(list, sizeof (smb_shrlist_t)); 202c8ec8eeaSjose borrego 2038d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 204da6c28aaSamw return (NERR_InternalError); 205da6c28aaSamw 2063db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 2073db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_LIST); 208da6c28aaSamw smb_dr_put_int32(enc_ctx, offset); 209da6c28aaSamw 210dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 211dc20a302Sas200622 if (rc != 0) { 2128d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 213da6c28aaSamw return (NERR_InternalError); 214da6c28aaSamw } 215da6c28aaSamw 2168d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 2178d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 218da6c28aaSamw return (NERR_InternalError); 219da6c28aaSamw } 220da6c28aaSamw 221dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 2223db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 223dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 2248d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 225da6c28aaSamw return (NERR_InternalError); 226da6c28aaSamw } 227da6c28aaSamw 228c8ec8eeaSjose borrego (void) smb_dr_get_buf(dec_ctx, (unsigned char *)list, 229c8ec8eeaSjose borrego sizeof (smb_shrlist_t)); 230dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 2318d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 232da6c28aaSamw return (NERR_InternalError); 233da6c28aaSamw } 234da6c28aaSamw 2358d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 2363ad684d6Sjb150015 return (NERR_Success); 237da6c28aaSamw } 238da6c28aaSamw 239da6c28aaSamw int 2403db3f65cSamw smb_share_count(void) 241da6c28aaSamw { 242dc20a302Sas200622 door_arg_t *arg; 243da6c28aaSamw smb_dr_ctx_t *dec_ctx; 244da6c28aaSamw smb_dr_ctx_t *enc_ctx; 2453db3f65cSamw uint32_t num_shares; 246dc20a302Sas200622 int rc; 247da6c28aaSamw 2488d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 249da6c28aaSamw return (-1); 250da6c28aaSamw 2513db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 2523db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_NUM_SHARES); 253dc20a302Sas200622 254dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 255dc20a302Sas200622 if (rc != 0) { 2568d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 257da6c28aaSamw return (-1); 258da6c28aaSamw } 259da6c28aaSamw 2608d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 2618d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 262da6c28aaSamw return (-1); 263da6c28aaSamw } 264da6c28aaSamw 265dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 2663db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 267dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 2688d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 269da6c28aaSamw return (-1); 270da6c28aaSamw } 271da6c28aaSamw 272da6c28aaSamw num_shares = smb_dr_get_uint32(dec_ctx); 273dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 2748d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 275da6c28aaSamw return (-1); 276da6c28aaSamw } 277da6c28aaSamw 2788d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 279da6c28aaSamw return (num_shares); 280da6c28aaSamw } 281da6c28aaSamw 2823db3f65cSamw uint32_t 283c8ec8eeaSjose borrego smb_share_delete(char *share_name) 284da6c28aaSamw { 285dc20a302Sas200622 door_arg_t *arg; 286da6c28aaSamw smb_dr_ctx_t *dec_ctx; 287da6c28aaSamw smb_dr_ctx_t *enc_ctx; 2883db3f65cSamw uint32_t rc; 289da6c28aaSamw 2908d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 291da6c28aaSamw return (NERR_InternalError); 292da6c28aaSamw 2933db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 2943db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_DELETE); 295da6c28aaSamw smb_dr_put_string(enc_ctx, share_name); 296da6c28aaSamw 297dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 298dc20a302Sas200622 if (rc != 0) { 2998d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 300da6c28aaSamw return (NERR_InternalError); 301da6c28aaSamw } 302da6c28aaSamw 3038d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 3048d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 305da6c28aaSamw return (NERR_InternalError); 306da6c28aaSamw } 307da6c28aaSamw 308dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 3093db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 310dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 3118d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 312da6c28aaSamw return (NERR_InternalError); 313da6c28aaSamw } 314da6c28aaSamw 315da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 316dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 3178d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 318da6c28aaSamw return (NERR_InternalError); 319da6c28aaSamw } 320da6c28aaSamw 3218d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 322da6c28aaSamw return (rc); 323da6c28aaSamw 324da6c28aaSamw } 325da6c28aaSamw 3263db3f65cSamw uint32_t 327c8ec8eeaSjose borrego smb_share_rename(char *from, char *to) 328da6c28aaSamw { 329dc20a302Sas200622 door_arg_t *arg; 330da6c28aaSamw smb_dr_ctx_t *dec_ctx; 331da6c28aaSamw smb_dr_ctx_t *enc_ctx; 3323db3f65cSamw uint32_t rc; 333da6c28aaSamw 3348d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 335da6c28aaSamw return (NERR_InternalError); 336da6c28aaSamw 3373db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 3383db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_RENAME); 339da6c28aaSamw smb_dr_put_string(enc_ctx, from); 340da6c28aaSamw smb_dr_put_string(enc_ctx, to); 341da6c28aaSamw 342dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 343dc20a302Sas200622 if (rc != 0) { 3448d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 345da6c28aaSamw return (NERR_InternalError); 346da6c28aaSamw } 347da6c28aaSamw 3488d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 3498d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 350da6c28aaSamw return (NERR_InternalError); 351da6c28aaSamw } 352da6c28aaSamw 353dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 3543db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 355dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 3568d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 357da6c28aaSamw return (NERR_InternalError); 358da6c28aaSamw } 359da6c28aaSamw 360da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 361dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 3628d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 363da6c28aaSamw return (NERR_InternalError); 364da6c28aaSamw } 365da6c28aaSamw 3668d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 367da6c28aaSamw return (rc); 368da6c28aaSamw } 369da6c28aaSamw 3703db3f65cSamw uint32_t 371c8ec8eeaSjose borrego smb_share_create(smb_share_t *si) 372da6c28aaSamw { 373dc20a302Sas200622 door_arg_t *arg; 374da6c28aaSamw smb_dr_ctx_t *dec_ctx; 375da6c28aaSamw smb_dr_ctx_t *enc_ctx; 3763db3f65cSamw uint32_t rc; 377da6c28aaSamw 3788d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 379da6c28aaSamw return (NERR_InternalError); 380da6c28aaSamw 3813db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 3823db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_ADD); 3833db3f65cSamw smb_dr_put_share(enc_ctx, si); 384da6c28aaSamw 385dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 386dc20a302Sas200622 if (rc != 0) { 3878d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 388da6c28aaSamw return (NERR_InternalError); 389da6c28aaSamw } 390da6c28aaSamw 3918d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 3928d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 393da6c28aaSamw return (NERR_InternalError); 394da6c28aaSamw } 395da6c28aaSamw 396dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 3973db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 398dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 3998d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 400da6c28aaSamw return (NERR_InternalError); 401da6c28aaSamw } 402da6c28aaSamw 403da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 4043db3f65cSamw smb_dr_get_share(dec_ctx, si); 405dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 4068d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 407da6c28aaSamw return (NERR_InternalError); 408da6c28aaSamw } 409da6c28aaSamw 4108d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 411da6c28aaSamw return (rc); 412da6c28aaSamw } 413da6c28aaSamw 4143db3f65cSamw uint32_t 415b89a8333Snatalie li - Sun Microsystems - Irvine United States smb_share_modify(smb_share_t *si) 416da6c28aaSamw { 417dc20a302Sas200622 door_arg_t *arg; 418da6c28aaSamw smb_dr_ctx_t *dec_ctx; 419da6c28aaSamw smb_dr_ctx_t *enc_ctx; 4203db3f65cSamw uint32_t rc; 421da6c28aaSamw 4228d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 423da6c28aaSamw return (NERR_InternalError); 424da6c28aaSamw 4253db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 426c8ec8eeaSjose borrego smb_dr_put_uint32(enc_ctx, SMB_SHROP_MODIFY); 427b89a8333Snatalie li - Sun Microsystems - Irvine United States smb_dr_put_share(enc_ctx, si); 428da6c28aaSamw 429dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 430dc20a302Sas200622 if (rc != 0) { 4318d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 432da6c28aaSamw return (NERR_InternalError); 433da6c28aaSamw } 434da6c28aaSamw 4358d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 4368d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 437da6c28aaSamw return (NERR_InternalError); 438da6c28aaSamw } 439da6c28aaSamw 440dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 4413db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 442dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 4438d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 444da6c28aaSamw return (NERR_InternalError); 445da6c28aaSamw } 446da6c28aaSamw 447da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 448dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 4498d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 450da6c28aaSamw return (NERR_InternalError); 451da6c28aaSamw } 452da6c28aaSamw 4538d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 454da6c28aaSamw return (rc); 455da6c28aaSamw } 456