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 /* 23*148c5f43SAlan Wright * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 24da6c28aaSamw */ 25da6c28aaSamw 26da6c28aaSamw /* 27da6c28aaSamw * User-space door client for LanMan share management. 28da6c28aaSamw */ 29da6c28aaSamw 30da6c28aaSamw #include <syslog.h> 31da6c28aaSamw #include <door.h> 32da6c28aaSamw #include <fcntl.h> 33da6c28aaSamw #include <stdarg.h> 34da6c28aaSamw #include <errno.h> 35da6c28aaSamw #include <string.h> 36da6c28aaSamw #include <strings.h> 37dc20a302Sas200622 #include <unistd.h> 38dc20a302Sas200622 #include <thread.h> 39dc20a302Sas200622 #include <synch.h> 40da6c28aaSamw 41da6c28aaSamw #include <smbsrv/libsmb.h> 423db3f65cSamw #include <smbsrv/smb_share.h> 43bbf6f00cSJordan Brown #include <smbsrv/smb.h> 44da6c28aaSamw 458d96b23eSAlan Wright #define SMB_SHARE_DOOR_CALL_RETRIES 3 468d96b23eSAlan Wright 473db3f65cSamw static int smb_share_dfd = -1; 483db3f65cSamw static uint64_t smb_share_dncall = 0; 493db3f65cSamw static mutex_t smb_share_dmtx; 503db3f65cSamw static cond_t smb_share_dcv; 51da6c28aaSamw 528d96b23eSAlan Wright static int smb_share_door_clnt_open(void); 538d96b23eSAlan Wright static void smb_share_door_clnt_close(void); 548d96b23eSAlan Wright 558d96b23eSAlan Wright void 568d96b23eSAlan Wright smb_share_door_clnt_init(void) 578d96b23eSAlan Wright { 588d96b23eSAlan Wright (void) mutex_lock(&smb_share_dmtx); 598d96b23eSAlan Wright (void) smb_share_door_clnt_open(); 608d96b23eSAlan Wright (void) mutex_unlock(&smb_share_dmtx); 618d96b23eSAlan Wright } 628d96b23eSAlan Wright 638d96b23eSAlan Wright void 648d96b23eSAlan Wright smb_share_door_clnt_fini(void) 658d96b23eSAlan Wright { 668d96b23eSAlan Wright (void) mutex_lock(&smb_share_dmtx); 678d96b23eSAlan Wright smb_share_door_clnt_close(); 688d96b23eSAlan Wright (void) mutex_unlock(&smb_share_dmtx); 698d96b23eSAlan Wright } 708d96b23eSAlan Wright 71da6c28aaSamw /* 728d96b23eSAlan Wright * Open smb_share_door. This is a private call for use by 738d96b23eSAlan Wright * smb_share_door_clnt_enter() and must be called with smb_share_dmtx held. 74dc20a302Sas200622 * 75dc20a302Sas200622 * Returns the door fd on success. Otherwise, -1. 76da6c28aaSamw */ 77da6c28aaSamw static int 788d96b23eSAlan Wright smb_share_door_clnt_open(void) 79da6c28aaSamw { 803db3f65cSamw if (smb_share_dfd == -1) { 813db3f65cSamw if ((smb_share_dfd = open(SMB_SHARE_DNAME, O_RDONLY)) < 0) 823db3f65cSamw smb_share_dfd = -1; 83dc20a302Sas200622 else 843db3f65cSamw smb_share_dncall = 0; 85da6c28aaSamw } 86dc20a302Sas200622 873db3f65cSamw return (smb_share_dfd); 88dc20a302Sas200622 } 89dc20a302Sas200622 90dc20a302Sas200622 /* 918d96b23eSAlan Wright * Close smb_share_door. 928d96b23eSAlan Wright * Private call that must be called with smb_share_dmtx held. 93dc20a302Sas200622 */ 948d96b23eSAlan Wright static void 958d96b23eSAlan Wright smb_share_door_clnt_close(void) 96dc20a302Sas200622 { 973db3f65cSamw if (smb_share_dfd != -1) { 983db3f65cSamw while (smb_share_dncall > 0) 993db3f65cSamw (void) cond_wait(&smb_share_dcv, &smb_share_dmtx); 100dc20a302Sas200622 1013db3f65cSamw if (smb_share_dfd != -1) { 1023db3f65cSamw (void) close(smb_share_dfd); 1033db3f65cSamw smb_share_dfd = -1; 104dc20a302Sas200622 } 105dc20a302Sas200622 } 106dc20a302Sas200622 } 107dc20a302Sas200622 108dc20a302Sas200622 /* 1098d96b23eSAlan Wright * Entry handler for smb_share_door calls. 110dc20a302Sas200622 */ 111dc20a302Sas200622 static door_arg_t * 1128d96b23eSAlan Wright smb_share_door_clnt_enter(void) 113dc20a302Sas200622 { 114dc20a302Sas200622 door_arg_t *arg; 115dc20a302Sas200622 char *buf; 116dc20a302Sas200622 1173db3f65cSamw (void) mutex_lock(&smb_share_dmtx); 118dc20a302Sas200622 1198d96b23eSAlan Wright if (smb_share_door_clnt_open() == -1) { 1203db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 121dc20a302Sas200622 return (NULL); 122dc20a302Sas200622 } 123dc20a302Sas200622 1243db3f65cSamw if ((arg = malloc(sizeof (door_arg_t) + SMB_SHARE_DSIZE)) != NULL) { 125dc20a302Sas200622 buf = ((char *)arg) + sizeof (door_arg_t); 126dc20a302Sas200622 bzero(arg, sizeof (door_arg_t)); 127dc20a302Sas200622 arg->data_ptr = buf; 128dc20a302Sas200622 arg->rbuf = buf; 1293db3f65cSamw arg->rsize = SMB_SHARE_DSIZE; 130dc20a302Sas200622 1313db3f65cSamw ++smb_share_dncall; 132dc20a302Sas200622 } 133dc20a302Sas200622 1343db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 135dc20a302Sas200622 return (arg); 136dc20a302Sas200622 } 137dc20a302Sas200622 138dc20a302Sas200622 /* 1398d96b23eSAlan Wright * Exit handler for smb_share_door calls. 140dc20a302Sas200622 */ 141dc20a302Sas200622 static void 1428d96b23eSAlan Wright smb_share_door_clnt_exit(door_arg_t *arg, boolean_t must_close, char *errmsg) 143dc20a302Sas200622 { 144dc20a302Sas200622 if (errmsg) 1458d96b23eSAlan Wright syslog(LOG_DEBUG, "smb_share_door: %s failed", errmsg); 146dc20a302Sas200622 1473db3f65cSamw (void) mutex_lock(&smb_share_dmtx); 148dc20a302Sas200622 free(arg); 1493db3f65cSamw --smb_share_dncall; 1503db3f65cSamw (void) cond_signal(&smb_share_dcv); 1518d96b23eSAlan Wright 1528d96b23eSAlan Wright if (must_close) 1538d96b23eSAlan Wright smb_share_door_clnt_close(); 1548d96b23eSAlan Wright 1553db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 156da6c28aaSamw } 157da6c28aaSamw 1588d96b23eSAlan Wright static int 1598d96b23eSAlan Wright smb_share_door_call(int fd, door_arg_t *arg) 1608d96b23eSAlan Wright { 1618d96b23eSAlan Wright int rc; 1628d96b23eSAlan Wright int i; 1638d96b23eSAlan Wright 1648d96b23eSAlan Wright for (i = 0; i < SMB_SHARE_DOOR_CALL_RETRIES; ++i) { 1658d96b23eSAlan Wright errno = 0; 1668d96b23eSAlan Wright 1678d96b23eSAlan Wright if ((rc = door_call(fd, arg)) == 0) 1688d96b23eSAlan Wright break; 1698d96b23eSAlan Wright 1708d96b23eSAlan Wright if (errno != EAGAIN && errno != EINTR) 1718d96b23eSAlan Wright break; 1728d96b23eSAlan Wright } 1738d96b23eSAlan Wright 1748d96b23eSAlan Wright return (rc); 1758d96b23eSAlan Wright } 1768d96b23eSAlan Wright 177da6c28aaSamw static int 1783db3f65cSamw smb_share_dchk(smb_dr_ctx_t *dec_ctx) 179da6c28aaSamw { 180da6c28aaSamw int status = smb_dr_get_int32(dec_ctx); 181da6c28aaSamw 1823db3f65cSamw if (status != SMB_SHARE_DSUCCESS) { 1833db3f65cSamw if (status == SMB_SHARE_DERROR) 184dc20a302Sas200622 (void) smb_dr_get_uint32(dec_ctx); 185dc20a302Sas200622 return (-1); 186da6c28aaSamw } 187da6c28aaSamw 188dc20a302Sas200622 return (0); 189da6c28aaSamw } 190da6c28aaSamw 1913db3f65cSamw uint32_t 1923db3f65cSamw smb_share_list(int offset, smb_shrlist_t *list) 193da6c28aaSamw { 194dc20a302Sas200622 door_arg_t *arg; 195da6c28aaSamw smb_dr_ctx_t *dec_ctx; 196da6c28aaSamw smb_dr_ctx_t *enc_ctx; 1973db3f65cSamw uint32_t rc; 198da6c28aaSamw 199c8ec8eeaSjose borrego bzero(list, sizeof (smb_shrlist_t)); 200c8ec8eeaSjose borrego 2018d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 202da6c28aaSamw return (NERR_InternalError); 203da6c28aaSamw 2043db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 2053db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_LIST); 206da6c28aaSamw smb_dr_put_int32(enc_ctx, offset); 207da6c28aaSamw 208dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 209dc20a302Sas200622 if (rc != 0) { 2108d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 211da6c28aaSamw return (NERR_InternalError); 212da6c28aaSamw } 213da6c28aaSamw 2148d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 2158d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 216da6c28aaSamw return (NERR_InternalError); 217da6c28aaSamw } 218da6c28aaSamw 219dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 2203db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 221dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 2228d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 223da6c28aaSamw return (NERR_InternalError); 224da6c28aaSamw } 225da6c28aaSamw 226c8ec8eeaSjose borrego (void) smb_dr_get_buf(dec_ctx, (unsigned char *)list, 227c8ec8eeaSjose borrego sizeof (smb_shrlist_t)); 228dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 2298d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 230da6c28aaSamw return (NERR_InternalError); 231da6c28aaSamw } 232da6c28aaSamw 2338d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 2343ad684d6Sjb150015 return (NERR_Success); 235da6c28aaSamw } 236da6c28aaSamw 237da6c28aaSamw int 2383db3f65cSamw smb_share_count(void) 239da6c28aaSamw { 240dc20a302Sas200622 door_arg_t *arg; 241da6c28aaSamw smb_dr_ctx_t *dec_ctx; 242da6c28aaSamw smb_dr_ctx_t *enc_ctx; 2433db3f65cSamw uint32_t num_shares; 244dc20a302Sas200622 int rc; 245da6c28aaSamw 2468d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 247da6c28aaSamw return (-1); 248da6c28aaSamw 2493db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 2503db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_NUM_SHARES); 251dc20a302Sas200622 252dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 253dc20a302Sas200622 if (rc != 0) { 2548d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 255da6c28aaSamw return (-1); 256da6c28aaSamw } 257da6c28aaSamw 2588d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 2598d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 260da6c28aaSamw return (-1); 261da6c28aaSamw } 262da6c28aaSamw 263dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 2643db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 265dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 2668d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 267da6c28aaSamw return (-1); 268da6c28aaSamw } 269da6c28aaSamw 270da6c28aaSamw num_shares = smb_dr_get_uint32(dec_ctx); 271dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 2728d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 273da6c28aaSamw return (-1); 274da6c28aaSamw } 275da6c28aaSamw 2768d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 277da6c28aaSamw return (num_shares); 278da6c28aaSamw } 279da6c28aaSamw 2803db3f65cSamw uint32_t 281c8ec8eeaSjose borrego smb_share_delete(char *share_name) 282da6c28aaSamw { 283dc20a302Sas200622 door_arg_t *arg; 284da6c28aaSamw smb_dr_ctx_t *dec_ctx; 285da6c28aaSamw smb_dr_ctx_t *enc_ctx; 2863db3f65cSamw uint32_t rc; 287da6c28aaSamw 2888d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 289da6c28aaSamw return (NERR_InternalError); 290da6c28aaSamw 2913db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 2923db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_DELETE); 293da6c28aaSamw smb_dr_put_string(enc_ctx, share_name); 294da6c28aaSamw 295dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 296dc20a302Sas200622 if (rc != 0) { 2978d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 298da6c28aaSamw return (NERR_InternalError); 299da6c28aaSamw } 300da6c28aaSamw 3018d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 3028d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 303da6c28aaSamw return (NERR_InternalError); 304da6c28aaSamw } 305da6c28aaSamw 306dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 3073db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 308dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 3098d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 310da6c28aaSamw return (NERR_InternalError); 311da6c28aaSamw } 312da6c28aaSamw 313da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 314dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 3158d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 316da6c28aaSamw return (NERR_InternalError); 317da6c28aaSamw } 318da6c28aaSamw 3198d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 320da6c28aaSamw return (rc); 321da6c28aaSamw 322da6c28aaSamw } 323da6c28aaSamw 3243db3f65cSamw uint32_t 325c8ec8eeaSjose borrego smb_share_rename(char *from, char *to) 326da6c28aaSamw { 327dc20a302Sas200622 door_arg_t *arg; 328da6c28aaSamw smb_dr_ctx_t *dec_ctx; 329da6c28aaSamw smb_dr_ctx_t *enc_ctx; 3303db3f65cSamw uint32_t rc; 331da6c28aaSamw 3328d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 333da6c28aaSamw return (NERR_InternalError); 334da6c28aaSamw 3353db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 3363db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_RENAME); 337da6c28aaSamw smb_dr_put_string(enc_ctx, from); 338da6c28aaSamw smb_dr_put_string(enc_ctx, to); 339da6c28aaSamw 340dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 341dc20a302Sas200622 if (rc != 0) { 3428d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 343da6c28aaSamw return (NERR_InternalError); 344da6c28aaSamw } 345da6c28aaSamw 3468d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 3478d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 348da6c28aaSamw return (NERR_InternalError); 349da6c28aaSamw } 350da6c28aaSamw 351dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 3523db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 353dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 3548d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 355da6c28aaSamw return (NERR_InternalError); 356da6c28aaSamw } 357da6c28aaSamw 358da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 359dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 3608d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 361da6c28aaSamw return (NERR_InternalError); 362da6c28aaSamw } 363da6c28aaSamw 3648d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 365da6c28aaSamw return (rc); 366da6c28aaSamw } 367da6c28aaSamw 3683db3f65cSamw uint32_t 369c8ec8eeaSjose borrego smb_share_create(smb_share_t *si) 370da6c28aaSamw { 371dc20a302Sas200622 door_arg_t *arg; 372da6c28aaSamw smb_dr_ctx_t *dec_ctx; 373da6c28aaSamw smb_dr_ctx_t *enc_ctx; 3743db3f65cSamw uint32_t rc; 375da6c28aaSamw 3768d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 377da6c28aaSamw return (NERR_InternalError); 378da6c28aaSamw 3793db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 3803db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_ADD); 3813db3f65cSamw smb_dr_put_share(enc_ctx, si); 382da6c28aaSamw 383dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 384dc20a302Sas200622 if (rc != 0) { 3858d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 386da6c28aaSamw return (NERR_InternalError); 387da6c28aaSamw } 388da6c28aaSamw 3898d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 3908d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 391da6c28aaSamw return (NERR_InternalError); 392da6c28aaSamw } 393da6c28aaSamw 394dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 3953db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 396dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 3978d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 398da6c28aaSamw return (NERR_InternalError); 399da6c28aaSamw } 400da6c28aaSamw 401da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 4023db3f65cSamw smb_dr_get_share(dec_ctx, si); 403dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 4048d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 405da6c28aaSamw return (NERR_InternalError); 406da6c28aaSamw } 407da6c28aaSamw 4088d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 409da6c28aaSamw return (rc); 410da6c28aaSamw } 411da6c28aaSamw 4123db3f65cSamw uint32_t 413b89a8333Snatalie li - Sun Microsystems - Irvine United States smb_share_modify(smb_share_t *si) 414da6c28aaSamw { 415dc20a302Sas200622 door_arg_t *arg; 416da6c28aaSamw smb_dr_ctx_t *dec_ctx; 417da6c28aaSamw smb_dr_ctx_t *enc_ctx; 4183db3f65cSamw uint32_t rc; 419da6c28aaSamw 4208d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 421da6c28aaSamw return (NERR_InternalError); 422da6c28aaSamw 4233db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 424c8ec8eeaSjose borrego smb_dr_put_uint32(enc_ctx, SMB_SHROP_MODIFY); 425b89a8333Snatalie li - Sun Microsystems - Irvine United States smb_dr_put_share(enc_ctx, si); 426da6c28aaSamw 427dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 428dc20a302Sas200622 if (rc != 0) { 4298d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 430da6c28aaSamw return (NERR_InternalError); 431da6c28aaSamw } 432da6c28aaSamw 4338d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 4348d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 435da6c28aaSamw return (NERR_InternalError); 436da6c28aaSamw } 437da6c28aaSamw 438dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 4393db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 440dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 4418d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 442da6c28aaSamw return (NERR_InternalError); 443da6c28aaSamw } 444da6c28aaSamw 445da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 446dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 4478d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 448da6c28aaSamw return (NERR_InternalError); 449da6c28aaSamw } 450da6c28aaSamw 4518d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 452da6c28aaSamw return (rc); 453da6c28aaSamw } 454