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 /* 23dc20a302Sas200622 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 24da6c28aaSamw * Use is subject to license terms. 25da6c28aaSamw */ 26da6c28aaSamw 27*c8ec8eeaSjose borrego #pragma ident "@(#)smb_share_doorclnt.c 1.5 08/08/05 SMI" 28da6c28aaSamw 29da6c28aaSamw /* 30da6c28aaSamw * User-space door client for LanMan share management. 31da6c28aaSamw */ 32da6c28aaSamw 33da6c28aaSamw #include <syslog.h> 34da6c28aaSamw #include <door.h> 35da6c28aaSamw #include <fcntl.h> 36da6c28aaSamw #include <stdarg.h> 37da6c28aaSamw #include <errno.h> 38da6c28aaSamw #include <string.h> 39da6c28aaSamw #include <strings.h> 40dc20a302Sas200622 #include <unistd.h> 41dc20a302Sas200622 #include <thread.h> 42dc20a302Sas200622 #include <synch.h> 43da6c28aaSamw 44da6c28aaSamw #include <smbsrv/libsmb.h> 453db3f65cSamw #include <smbsrv/smb_share.h> 46da6c28aaSamw #include <smbsrv/lmerr.h> 47da6c28aaSamw #include <smbsrv/cifs.h> 48da6c28aaSamw 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 54da6c28aaSamw /* 55dc20a302Sas200622 * Open the lmshrd door. This is a private call for use by 563db3f65cSamw * smb_share_denter() and must be called with smb_share_dmtx held. 57dc20a302Sas200622 * 58dc20a302Sas200622 * Returns the door fd on success. Otherwise, -1. 59da6c28aaSamw */ 60da6c28aaSamw static int 613db3f65cSamw smb_share_dopen(void) 62da6c28aaSamw { 633db3f65cSamw if (smb_share_dfd == -1) { 643db3f65cSamw if ((smb_share_dfd = open(SMB_SHARE_DNAME, O_RDONLY)) < 0) 653db3f65cSamw smb_share_dfd = -1; 66dc20a302Sas200622 else 673db3f65cSamw smb_share_dncall = 0; 68da6c28aaSamw } 69dc20a302Sas200622 703db3f65cSamw return (smb_share_dfd); 71dc20a302Sas200622 } 72dc20a302Sas200622 73dc20a302Sas200622 /* 74dc20a302Sas200622 * Close the lmshrd door. 75dc20a302Sas200622 */ 76dc20a302Sas200622 void 773db3f65cSamw smb_share_dclose(void) 78dc20a302Sas200622 { 793db3f65cSamw (void) mutex_lock(&smb_share_dmtx); 80dc20a302Sas200622 813db3f65cSamw if (smb_share_dfd != -1) { 823db3f65cSamw while (smb_share_dncall > 0) 833db3f65cSamw (void) cond_wait(&smb_share_dcv, &smb_share_dmtx); 84dc20a302Sas200622 853db3f65cSamw if (smb_share_dfd != -1) { 863db3f65cSamw (void) close(smb_share_dfd); 873db3f65cSamw smb_share_dfd = -1; 88dc20a302Sas200622 } 89dc20a302Sas200622 } 90dc20a302Sas200622 913db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 92dc20a302Sas200622 } 93dc20a302Sas200622 94dc20a302Sas200622 /* 95dc20a302Sas200622 * Entry handler for lmshrd door calls. 96dc20a302Sas200622 */ 97dc20a302Sas200622 static door_arg_t * 983db3f65cSamw smb_share_denter(void) 99dc20a302Sas200622 { 100dc20a302Sas200622 door_arg_t *arg; 101dc20a302Sas200622 char *buf; 102dc20a302Sas200622 1033db3f65cSamw (void) mutex_lock(&smb_share_dmtx); 104dc20a302Sas200622 1053db3f65cSamw if (smb_share_dopen() == -1) { 1063db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 107dc20a302Sas200622 return (NULL); 108dc20a302Sas200622 } 109dc20a302Sas200622 1103db3f65cSamw if ((arg = malloc(sizeof (door_arg_t) + SMB_SHARE_DSIZE)) != NULL) { 111dc20a302Sas200622 buf = ((char *)arg) + sizeof (door_arg_t); 112dc20a302Sas200622 bzero(arg, sizeof (door_arg_t)); 113dc20a302Sas200622 arg->data_ptr = buf; 114dc20a302Sas200622 arg->rbuf = buf; 1153db3f65cSamw arg->rsize = SMB_SHARE_DSIZE; 116dc20a302Sas200622 1173db3f65cSamw ++smb_share_dncall; 118dc20a302Sas200622 } 119dc20a302Sas200622 1203db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 121dc20a302Sas200622 return (arg); 122dc20a302Sas200622 } 123dc20a302Sas200622 124dc20a302Sas200622 /* 125dc20a302Sas200622 * Exit handler for lmshrd door calls. 126dc20a302Sas200622 */ 127dc20a302Sas200622 static void 1283db3f65cSamw smb_share_dexit(door_arg_t *arg, char *errmsg) 129dc20a302Sas200622 { 130dc20a302Sas200622 if (errmsg) 131dc20a302Sas200622 syslog(LOG_DEBUG, "lmshrd_door: %s", errmsg); 132dc20a302Sas200622 1333db3f65cSamw (void) mutex_lock(&smb_share_dmtx); 134dc20a302Sas200622 free(arg); 1353db3f65cSamw --smb_share_dncall; 1363db3f65cSamw (void) cond_signal(&smb_share_dcv); 1373db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 138da6c28aaSamw } 139da6c28aaSamw 140da6c28aaSamw /* 141da6c28aaSamw * Return 0 upon success. Otherwise, -1. 142da6c28aaSamw */ 143da6c28aaSamw static int 1443db3f65cSamw smb_share_dchk(smb_dr_ctx_t *dec_ctx) 145da6c28aaSamw { 146da6c28aaSamw int status = smb_dr_get_int32(dec_ctx); 147da6c28aaSamw 1483db3f65cSamw if (status != SMB_SHARE_DSUCCESS) { 1493db3f65cSamw if (status == SMB_SHARE_DERROR) 150dc20a302Sas200622 (void) smb_dr_get_uint32(dec_ctx); 151dc20a302Sas200622 return (-1); 152da6c28aaSamw } 153da6c28aaSamw 154dc20a302Sas200622 return (0); 155da6c28aaSamw } 156da6c28aaSamw 1573db3f65cSamw uint32_t 1583db3f65cSamw smb_share_list(int offset, smb_shrlist_t *list) 159da6c28aaSamw { 160dc20a302Sas200622 door_arg_t *arg; 161da6c28aaSamw smb_dr_ctx_t *dec_ctx; 162da6c28aaSamw smb_dr_ctx_t *enc_ctx; 1633db3f65cSamw uint32_t rc; 164da6c28aaSamw 165*c8ec8eeaSjose borrego bzero(list, sizeof (smb_shrlist_t)); 166*c8ec8eeaSjose borrego 1673db3f65cSamw if ((arg = smb_share_denter()) == NULL) 168da6c28aaSamw return (NERR_InternalError); 169da6c28aaSamw 1703db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 1713db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_LIST); 172da6c28aaSamw smb_dr_put_int32(enc_ctx, offset); 173da6c28aaSamw 174dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 175dc20a302Sas200622 if (rc != 0) { 1763db3f65cSamw smb_share_dexit(arg, "encode error"); 177da6c28aaSamw return (NERR_InternalError); 178da6c28aaSamw } 179da6c28aaSamw 1803db3f65cSamw if (door_call(smb_share_dfd, arg) < 0) { 1813db3f65cSamw smb_share_dexit(arg, "door call error"); 1823db3f65cSamw smb_share_dclose(); 183da6c28aaSamw return (NERR_InternalError); 184da6c28aaSamw } 185da6c28aaSamw 186dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 1873db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 188dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 1893db3f65cSamw smb_share_dexit(arg, "decode error"); 190da6c28aaSamw return (NERR_InternalError); 191da6c28aaSamw } 192da6c28aaSamw 193*c8ec8eeaSjose borrego (void) smb_dr_get_buf(dec_ctx, (unsigned char *)list, 194*c8ec8eeaSjose borrego sizeof (smb_shrlist_t)); 195dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 1963db3f65cSamw smb_share_dexit(arg, "decode error"); 197da6c28aaSamw return (NERR_InternalError); 198da6c28aaSamw } 199da6c28aaSamw 2003db3f65cSamw smb_share_dexit(arg, NULL); 2013ad684d6Sjb150015 return (NERR_Success); 202da6c28aaSamw } 203da6c28aaSamw 204da6c28aaSamw int 2053db3f65cSamw smb_share_count(void) 206da6c28aaSamw { 207dc20a302Sas200622 door_arg_t *arg; 208da6c28aaSamw smb_dr_ctx_t *dec_ctx; 209da6c28aaSamw smb_dr_ctx_t *enc_ctx; 2103db3f65cSamw uint32_t num_shares; 211dc20a302Sas200622 int rc; 212da6c28aaSamw 2133db3f65cSamw if ((arg = smb_share_denter()) == NULL) 214da6c28aaSamw return (-1); 215da6c28aaSamw 2163db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 2173db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_NUM_SHARES); 218dc20a302Sas200622 219dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 220dc20a302Sas200622 if (rc != 0) { 2213db3f65cSamw smb_share_dexit(arg, "encode error"); 222da6c28aaSamw return (-1); 223da6c28aaSamw } 224da6c28aaSamw 2253db3f65cSamw if (door_call(smb_share_dfd, arg) < 0) { 2263db3f65cSamw smb_share_dexit(arg, "door call error"); 2273db3f65cSamw smb_share_dclose(); 228da6c28aaSamw return (-1); 229da6c28aaSamw } 230da6c28aaSamw 231dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 2323db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 233dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 2343db3f65cSamw smb_share_dexit(arg, "decode error"); 235da6c28aaSamw return (-1); 236da6c28aaSamw } 237da6c28aaSamw 238da6c28aaSamw num_shares = smb_dr_get_uint32(dec_ctx); 239dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 2403db3f65cSamw smb_share_dexit(arg, "decode error"); 241da6c28aaSamw return (-1); 242da6c28aaSamw } 243da6c28aaSamw 2443db3f65cSamw smb_share_dexit(arg, NULL); 245da6c28aaSamw return (num_shares); 246da6c28aaSamw } 247da6c28aaSamw 2483db3f65cSamw uint32_t 249*c8ec8eeaSjose borrego smb_share_delete(char *share_name) 250da6c28aaSamw { 251dc20a302Sas200622 door_arg_t *arg; 252da6c28aaSamw smb_dr_ctx_t *dec_ctx; 253da6c28aaSamw smb_dr_ctx_t *enc_ctx; 2543db3f65cSamw uint32_t rc; 255da6c28aaSamw 2563db3f65cSamw if ((arg = smb_share_denter()) == NULL) 257da6c28aaSamw return (NERR_InternalError); 258da6c28aaSamw 2593db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 2603db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_DELETE); 261da6c28aaSamw smb_dr_put_string(enc_ctx, share_name); 262da6c28aaSamw 263dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 264dc20a302Sas200622 if (rc != 0) { 2653db3f65cSamw smb_share_dexit(arg, "encode error"); 266da6c28aaSamw return (NERR_InternalError); 267da6c28aaSamw } 268da6c28aaSamw 2693db3f65cSamw if (door_call(smb_share_dfd, arg) < 0) { 2703db3f65cSamw smb_share_dexit(arg, "door call error"); 2713db3f65cSamw smb_share_dclose(); 272da6c28aaSamw return (NERR_InternalError); 273da6c28aaSamw } 274da6c28aaSamw 275dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 2763db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 277dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 2783db3f65cSamw smb_share_dexit(arg, "decode error"); 279da6c28aaSamw return (NERR_InternalError); 280da6c28aaSamw } 281da6c28aaSamw 282da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 283dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 2843db3f65cSamw smb_share_dexit(arg, "decode error"); 285da6c28aaSamw return (NERR_InternalError); 286da6c28aaSamw } 287da6c28aaSamw 2883db3f65cSamw smb_share_dexit(arg, NULL); 289da6c28aaSamw return (rc); 290da6c28aaSamw 291da6c28aaSamw } 292da6c28aaSamw 2933db3f65cSamw uint32_t 294*c8ec8eeaSjose borrego smb_share_rename(char *from, char *to) 295da6c28aaSamw { 296dc20a302Sas200622 door_arg_t *arg; 297da6c28aaSamw smb_dr_ctx_t *dec_ctx; 298da6c28aaSamw smb_dr_ctx_t *enc_ctx; 2993db3f65cSamw uint32_t rc; 300da6c28aaSamw 3013db3f65cSamw if ((arg = smb_share_denter()) == NULL) 302da6c28aaSamw return (NERR_InternalError); 303da6c28aaSamw 3043db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 3053db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_RENAME); 306da6c28aaSamw smb_dr_put_string(enc_ctx, from); 307da6c28aaSamw smb_dr_put_string(enc_ctx, to); 308da6c28aaSamw 309dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 310dc20a302Sas200622 if (rc != 0) { 3113db3f65cSamw smb_share_dexit(arg, "encode error"); 312da6c28aaSamw return (NERR_InternalError); 313da6c28aaSamw } 314da6c28aaSamw 3153db3f65cSamw if (door_call(smb_share_dfd, arg) < 0) { 3163db3f65cSamw smb_share_dexit(arg, "door call error"); 3173db3f65cSamw smb_share_dclose(); 318da6c28aaSamw return (NERR_InternalError); 319da6c28aaSamw } 320da6c28aaSamw 321dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 3223db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 323dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 3243db3f65cSamw smb_share_dexit(arg, "decode error"); 325da6c28aaSamw return (NERR_InternalError); 326da6c28aaSamw } 327da6c28aaSamw 328da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 329dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 3303db3f65cSamw smb_share_dexit(arg, "decode error"); 331da6c28aaSamw return (NERR_InternalError); 332da6c28aaSamw } 333da6c28aaSamw 3343db3f65cSamw smb_share_dexit(arg, NULL); 335da6c28aaSamw return (rc); 336da6c28aaSamw } 337da6c28aaSamw 3383db3f65cSamw uint32_t 3393db3f65cSamw smb_share_get(char *share_name, smb_share_t *si) 340da6c28aaSamw { 341dc20a302Sas200622 door_arg_t *arg; 342da6c28aaSamw smb_dr_ctx_t *dec_ctx; 343da6c28aaSamw smb_dr_ctx_t *enc_ctx; 3443db3f65cSamw uint32_t rc; 345da6c28aaSamw 3463db3f65cSamw if ((arg = smb_share_denter()) == NULL) 347da6c28aaSamw return (NERR_InternalError); 348da6c28aaSamw 3493db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 3503db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_GETINFO); 351da6c28aaSamw smb_dr_put_string(enc_ctx, share_name); 352da6c28aaSamw 353dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 354dc20a302Sas200622 if (rc != 0) { 3553db3f65cSamw smb_share_dexit(arg, "encode error"); 356da6c28aaSamw return (NERR_InternalError); 357da6c28aaSamw } 358da6c28aaSamw 3593db3f65cSamw if (door_call(smb_share_dfd, arg) < 0) { 3603db3f65cSamw smb_share_dexit(arg, "door call error"); 3613db3f65cSamw smb_share_dclose(); 362da6c28aaSamw return (NERR_InternalError); 363da6c28aaSamw } 364da6c28aaSamw 365dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 3663db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 367dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 3683db3f65cSamw smb_share_dexit(arg, "decode error"); 369da6c28aaSamw return (NERR_InternalError); 370da6c28aaSamw } 371da6c28aaSamw 372da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 3733db3f65cSamw smb_dr_get_share(dec_ctx, si); 374dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 3753db3f65cSamw smb_share_dexit(arg, "decode error"); 376da6c28aaSamw return (NERR_InternalError); 377da6c28aaSamw } 378da6c28aaSamw 3793db3f65cSamw smb_share_dexit(arg, NULL); 380da6c28aaSamw return (rc); 381da6c28aaSamw } 382da6c28aaSamw 3833db3f65cSamw uint32_t 384*c8ec8eeaSjose borrego smb_share_create(smb_share_t *si) 385da6c28aaSamw { 386dc20a302Sas200622 door_arg_t *arg; 387da6c28aaSamw smb_dr_ctx_t *dec_ctx; 388da6c28aaSamw smb_dr_ctx_t *enc_ctx; 3893db3f65cSamw uint32_t rc; 390da6c28aaSamw 3913db3f65cSamw if ((arg = smb_share_denter()) == NULL) 392da6c28aaSamw return (NERR_InternalError); 393da6c28aaSamw 3943db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 3953db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_ADD); 3963db3f65cSamw smb_dr_put_share(enc_ctx, si); 397da6c28aaSamw 398dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 399dc20a302Sas200622 if (rc != 0) { 4003db3f65cSamw smb_share_dexit(arg, "encode error"); 401da6c28aaSamw return (NERR_InternalError); 402da6c28aaSamw } 403da6c28aaSamw 4043db3f65cSamw if (door_call(smb_share_dfd, arg) < 0) { 4053db3f65cSamw smb_share_dexit(arg, "door call error"); 4063db3f65cSamw smb_share_dclose(); 407da6c28aaSamw return (NERR_InternalError); 408da6c28aaSamw } 409da6c28aaSamw 410dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 4113db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 412dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 4133db3f65cSamw smb_share_dexit(arg, "decode error"); 414da6c28aaSamw return (NERR_InternalError); 415da6c28aaSamw } 416da6c28aaSamw 417da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 4183db3f65cSamw smb_dr_get_share(dec_ctx, si); 419dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 4203db3f65cSamw smb_share_dexit(arg, "decode error"); 421da6c28aaSamw return (NERR_InternalError); 422da6c28aaSamw } 423da6c28aaSamw 4243db3f65cSamw smb_share_dexit(arg, NULL); 425da6c28aaSamw return (rc); 426da6c28aaSamw } 427da6c28aaSamw 4283db3f65cSamw uint32_t 429*c8ec8eeaSjose borrego smb_share_modify(char *sharename, char *cmnt, char *ad_container) 430da6c28aaSamw { 431dc20a302Sas200622 door_arg_t *arg; 432da6c28aaSamw smb_dr_ctx_t *dec_ctx; 433da6c28aaSamw smb_dr_ctx_t *enc_ctx; 4343db3f65cSamw uint32_t rc; 435da6c28aaSamw 4363db3f65cSamw if ((arg = smb_share_denter()) == NULL) 437da6c28aaSamw return (NERR_InternalError); 438da6c28aaSamw 4393db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 440*c8ec8eeaSjose borrego smb_dr_put_uint32(enc_ctx, SMB_SHROP_MODIFY); 441*c8ec8eeaSjose borrego smb_dr_put_string(enc_ctx, sharename); 442*c8ec8eeaSjose borrego smb_dr_put_string(enc_ctx, cmnt); 443*c8ec8eeaSjose borrego smb_dr_put_string(enc_ctx, ad_container); 444da6c28aaSamw 445dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 446dc20a302Sas200622 if (rc != 0) { 4473db3f65cSamw smb_share_dexit(arg, "encode error"); 448da6c28aaSamw return (NERR_InternalError); 449da6c28aaSamw } 450da6c28aaSamw 4513db3f65cSamw if (door_call(smb_share_dfd, arg) < 0) { 4523db3f65cSamw smb_share_dexit(arg, "door call error"); 4533db3f65cSamw smb_share_dclose(); 454da6c28aaSamw return (NERR_InternalError); 455da6c28aaSamw } 456da6c28aaSamw 457dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 4583db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 459dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 4603db3f65cSamw smb_share_dexit(arg, "decode error"); 461da6c28aaSamw return (NERR_InternalError); 462da6c28aaSamw } 463da6c28aaSamw 464da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 465dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 4663db3f65cSamw smb_share_dexit(arg, "decode error"); 467da6c28aaSamw return (NERR_InternalError); 468da6c28aaSamw } 469da6c28aaSamw 4703db3f65cSamw smb_share_dexit(arg, NULL); 471da6c28aaSamw return (rc); 472da6c28aaSamw } 473