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 27da6c28aaSamw #pragma ident "%Z%%M% %I% %E% 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> 45*3db3f65cSamw #include <smbsrv/smb_share.h> 46da6c28aaSamw #include <smbsrv/lmerr.h> 47da6c28aaSamw #include <smbsrv/cifs.h> 48da6c28aaSamw 49*3db3f65cSamw static int smb_share_dfd = -1; 50*3db3f65cSamw static uint64_t smb_share_dncall = 0; 51*3db3f65cSamw static mutex_t smb_share_dmtx; 52*3db3f65cSamw static cond_t smb_share_dcv; 53da6c28aaSamw 54da6c28aaSamw /* 55dc20a302Sas200622 * Open the lmshrd door. This is a private call for use by 56*3db3f65cSamw * 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 61*3db3f65cSamw smb_share_dopen(void) 62da6c28aaSamw { 63*3db3f65cSamw if (smb_share_dfd == -1) { 64*3db3f65cSamw if ((smb_share_dfd = open(SMB_SHARE_DNAME, O_RDONLY)) < 0) 65*3db3f65cSamw smb_share_dfd = -1; 66dc20a302Sas200622 else 67*3db3f65cSamw smb_share_dncall = 0; 68da6c28aaSamw } 69dc20a302Sas200622 70*3db3f65cSamw return (smb_share_dfd); 71dc20a302Sas200622 } 72dc20a302Sas200622 73dc20a302Sas200622 /* 74dc20a302Sas200622 * Close the lmshrd door. 75dc20a302Sas200622 */ 76dc20a302Sas200622 void 77*3db3f65cSamw smb_share_dclose(void) 78dc20a302Sas200622 { 79*3db3f65cSamw (void) mutex_lock(&smb_share_dmtx); 80dc20a302Sas200622 81*3db3f65cSamw if (smb_share_dfd != -1) { 82*3db3f65cSamw while (smb_share_dncall > 0) 83*3db3f65cSamw (void) cond_wait(&smb_share_dcv, &smb_share_dmtx); 84dc20a302Sas200622 85*3db3f65cSamw if (smb_share_dfd != -1) { 86*3db3f65cSamw (void) close(smb_share_dfd); 87*3db3f65cSamw smb_share_dfd = -1; 88dc20a302Sas200622 } 89dc20a302Sas200622 } 90dc20a302Sas200622 91*3db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 92dc20a302Sas200622 } 93dc20a302Sas200622 94dc20a302Sas200622 /* 95dc20a302Sas200622 * Entry handler for lmshrd door calls. 96dc20a302Sas200622 */ 97dc20a302Sas200622 static door_arg_t * 98*3db3f65cSamw smb_share_denter(void) 99dc20a302Sas200622 { 100dc20a302Sas200622 door_arg_t *arg; 101dc20a302Sas200622 char *buf; 102dc20a302Sas200622 103*3db3f65cSamw (void) mutex_lock(&smb_share_dmtx); 104dc20a302Sas200622 105*3db3f65cSamw if (smb_share_dopen() == -1) { 106*3db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 107dc20a302Sas200622 return (NULL); 108dc20a302Sas200622 } 109dc20a302Sas200622 110*3db3f65cSamw 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; 115*3db3f65cSamw arg->rsize = SMB_SHARE_DSIZE; 116dc20a302Sas200622 117*3db3f65cSamw ++smb_share_dncall; 118dc20a302Sas200622 } 119dc20a302Sas200622 120*3db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 121dc20a302Sas200622 return (arg); 122dc20a302Sas200622 } 123dc20a302Sas200622 124dc20a302Sas200622 /* 125dc20a302Sas200622 * Exit handler for lmshrd door calls. 126dc20a302Sas200622 */ 127dc20a302Sas200622 static void 128*3db3f65cSamw smb_share_dexit(door_arg_t *arg, char *errmsg) 129dc20a302Sas200622 { 130dc20a302Sas200622 if (errmsg) 131dc20a302Sas200622 syslog(LOG_DEBUG, "lmshrd_door: %s", errmsg); 132dc20a302Sas200622 133*3db3f65cSamw (void) mutex_lock(&smb_share_dmtx); 134dc20a302Sas200622 free(arg); 135*3db3f65cSamw --smb_share_dncall; 136*3db3f65cSamw (void) cond_signal(&smb_share_dcv); 137*3db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 138da6c28aaSamw } 139da6c28aaSamw 140da6c28aaSamw /* 141da6c28aaSamw * Return 0 upon success. Otherwise, -1. 142da6c28aaSamw */ 143da6c28aaSamw static int 144*3db3f65cSamw smb_share_dchk(smb_dr_ctx_t *dec_ctx) 145da6c28aaSamw { 146da6c28aaSamw int status = smb_dr_get_int32(dec_ctx); 147da6c28aaSamw 148*3db3f65cSamw if (status != SMB_SHARE_DSUCCESS) { 149*3db3f65cSamw if (status == SMB_SHARE_DERROR) 150dc20a302Sas200622 (void) smb_dr_get_uint32(dec_ctx); 151dc20a302Sas200622 return (-1); 152da6c28aaSamw } 153da6c28aaSamw 154dc20a302Sas200622 return (0); 155da6c28aaSamw } 156da6c28aaSamw 157*3db3f65cSamw uint32_t 158*3db3f65cSamw 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; 163*3db3f65cSamw uint32_t rc; 164da6c28aaSamw 165*3db3f65cSamw if ((arg = smb_share_denter()) == NULL) 166da6c28aaSamw return (NERR_InternalError); 167da6c28aaSamw 168*3db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 169*3db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_LIST); 170da6c28aaSamw smb_dr_put_int32(enc_ctx, offset); 171da6c28aaSamw 172dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 173dc20a302Sas200622 if (rc != 0) { 174*3db3f65cSamw smb_share_dexit(arg, "encode error"); 175da6c28aaSamw return (NERR_InternalError); 176da6c28aaSamw } 177da6c28aaSamw 178*3db3f65cSamw if (door_call(smb_share_dfd, arg) < 0) { 179*3db3f65cSamw smb_share_dexit(arg, "door call error"); 180*3db3f65cSamw smb_share_dclose(); 181da6c28aaSamw return (NERR_InternalError); 182da6c28aaSamw } 183da6c28aaSamw 184dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 185*3db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 186dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 187*3db3f65cSamw smb_share_dexit(arg, "decode error"); 188da6c28aaSamw return (NERR_InternalError); 189da6c28aaSamw } 190da6c28aaSamw 191*3db3f65cSamw smb_dr_get_shrlist(dec_ctx, list); 192dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 193*3db3f65cSamw smb_share_dexit(arg, "decode error"); 194da6c28aaSamw return (NERR_InternalError); 195da6c28aaSamw } 196da6c28aaSamw 197*3db3f65cSamw smb_share_dexit(arg, NULL); 1983ad684d6Sjb150015 return (NERR_Success); 199da6c28aaSamw } 200da6c28aaSamw 201da6c28aaSamw int 202*3db3f65cSamw smb_share_count(void) 203da6c28aaSamw { 204dc20a302Sas200622 door_arg_t *arg; 205da6c28aaSamw smb_dr_ctx_t *dec_ctx; 206da6c28aaSamw smb_dr_ctx_t *enc_ctx; 207*3db3f65cSamw uint32_t num_shares; 208dc20a302Sas200622 int rc; 209da6c28aaSamw 210*3db3f65cSamw if ((arg = smb_share_denter()) == NULL) 211da6c28aaSamw return (-1); 212da6c28aaSamw 213*3db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 214*3db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_NUM_SHARES); 215dc20a302Sas200622 216dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 217dc20a302Sas200622 if (rc != 0) { 218*3db3f65cSamw smb_share_dexit(arg, "encode error"); 219da6c28aaSamw return (-1); 220da6c28aaSamw } 221da6c28aaSamw 222*3db3f65cSamw if (door_call(smb_share_dfd, arg) < 0) { 223*3db3f65cSamw smb_share_dexit(arg, "door call error"); 224*3db3f65cSamw smb_share_dclose(); 225da6c28aaSamw return (-1); 226da6c28aaSamw } 227da6c28aaSamw 228dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 229*3db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 230dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 231*3db3f65cSamw smb_share_dexit(arg, "decode error"); 232da6c28aaSamw return (-1); 233da6c28aaSamw } 234da6c28aaSamw 235da6c28aaSamw num_shares = smb_dr_get_uint32(dec_ctx); 236dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 237*3db3f65cSamw smb_share_dexit(arg, "decode error"); 238da6c28aaSamw return (-1); 239da6c28aaSamw } 240da6c28aaSamw 241*3db3f65cSamw smb_share_dexit(arg, NULL); 242da6c28aaSamw return (num_shares); 243da6c28aaSamw } 244da6c28aaSamw 245*3db3f65cSamw uint32_t 246*3db3f65cSamw smb_share_del(char *share_name) 247da6c28aaSamw { 248dc20a302Sas200622 door_arg_t *arg; 249da6c28aaSamw smb_dr_ctx_t *dec_ctx; 250da6c28aaSamw smb_dr_ctx_t *enc_ctx; 251*3db3f65cSamw uint32_t rc; 252da6c28aaSamw 253*3db3f65cSamw if ((arg = smb_share_denter()) == NULL) 254da6c28aaSamw return (NERR_InternalError); 255da6c28aaSamw 256*3db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 257*3db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_DELETE); 258da6c28aaSamw smb_dr_put_string(enc_ctx, share_name); 259da6c28aaSamw 260dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 261dc20a302Sas200622 if (rc != 0) { 262*3db3f65cSamw smb_share_dexit(arg, "encode error"); 263da6c28aaSamw return (NERR_InternalError); 264da6c28aaSamw } 265da6c28aaSamw 266*3db3f65cSamw if (door_call(smb_share_dfd, arg) < 0) { 267*3db3f65cSamw smb_share_dexit(arg, "door call error"); 268*3db3f65cSamw smb_share_dclose(); 269da6c28aaSamw return (NERR_InternalError); 270da6c28aaSamw } 271da6c28aaSamw 272dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 273*3db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 274dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 275*3db3f65cSamw smb_share_dexit(arg, "decode error"); 276da6c28aaSamw return (NERR_InternalError); 277da6c28aaSamw } 278da6c28aaSamw 279da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 280dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 281*3db3f65cSamw smb_share_dexit(arg, "decode error"); 282da6c28aaSamw return (NERR_InternalError); 283da6c28aaSamw } 284da6c28aaSamw 285*3db3f65cSamw smb_share_dexit(arg, NULL); 286da6c28aaSamw return (rc); 287da6c28aaSamw 288da6c28aaSamw } 289da6c28aaSamw 290*3db3f65cSamw uint32_t 291*3db3f65cSamw smb_share_ren(char *from, char *to) 292da6c28aaSamw { 293dc20a302Sas200622 door_arg_t *arg; 294da6c28aaSamw smb_dr_ctx_t *dec_ctx; 295da6c28aaSamw smb_dr_ctx_t *enc_ctx; 296*3db3f65cSamw uint32_t rc; 297da6c28aaSamw 298*3db3f65cSamw if ((arg = smb_share_denter()) == NULL) 299da6c28aaSamw return (NERR_InternalError); 300da6c28aaSamw 301*3db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 302*3db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_RENAME); 303da6c28aaSamw smb_dr_put_string(enc_ctx, from); 304da6c28aaSamw smb_dr_put_string(enc_ctx, to); 305da6c28aaSamw 306dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 307dc20a302Sas200622 if (rc != 0) { 308*3db3f65cSamw smb_share_dexit(arg, "encode error"); 309da6c28aaSamw return (NERR_InternalError); 310da6c28aaSamw } 311da6c28aaSamw 312*3db3f65cSamw if (door_call(smb_share_dfd, arg) < 0) { 313*3db3f65cSamw smb_share_dexit(arg, "door call error"); 314*3db3f65cSamw smb_share_dclose(); 315da6c28aaSamw return (NERR_InternalError); 316da6c28aaSamw } 317da6c28aaSamw 318dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 319*3db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 320dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 321*3db3f65cSamw smb_share_dexit(arg, "decode error"); 322da6c28aaSamw return (NERR_InternalError); 323da6c28aaSamw } 324da6c28aaSamw 325da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 326dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 327*3db3f65cSamw smb_share_dexit(arg, "decode error"); 328da6c28aaSamw return (NERR_InternalError); 329da6c28aaSamw } 330da6c28aaSamw 331*3db3f65cSamw smb_share_dexit(arg, NULL); 332da6c28aaSamw return (rc); 333da6c28aaSamw } 334da6c28aaSamw 335*3db3f65cSamw uint32_t 336*3db3f65cSamw smb_share_get(char *share_name, smb_share_t *si) 337da6c28aaSamw { 338dc20a302Sas200622 door_arg_t *arg; 339da6c28aaSamw smb_dr_ctx_t *dec_ctx; 340da6c28aaSamw smb_dr_ctx_t *enc_ctx; 341*3db3f65cSamw uint32_t rc; 342da6c28aaSamw 343*3db3f65cSamw if ((arg = smb_share_denter()) == NULL) 344da6c28aaSamw return (NERR_InternalError); 345da6c28aaSamw 346*3db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 347*3db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_GETINFO); 348da6c28aaSamw smb_dr_put_string(enc_ctx, share_name); 349da6c28aaSamw 350dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 351dc20a302Sas200622 if (rc != 0) { 352*3db3f65cSamw smb_share_dexit(arg, "encode error"); 353da6c28aaSamw return (NERR_InternalError); 354da6c28aaSamw } 355da6c28aaSamw 356*3db3f65cSamw if (door_call(smb_share_dfd, arg) < 0) { 357*3db3f65cSamw smb_share_dexit(arg, "door call error"); 358*3db3f65cSamw smb_share_dclose(); 359da6c28aaSamw return (NERR_InternalError); 360da6c28aaSamw } 361da6c28aaSamw 362dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 363*3db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 364dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 365*3db3f65cSamw smb_share_dexit(arg, "decode error"); 366da6c28aaSamw return (NERR_InternalError); 367da6c28aaSamw } 368da6c28aaSamw 369da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 370*3db3f65cSamw smb_dr_get_share(dec_ctx, si); 371dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 372*3db3f65cSamw smb_share_dexit(arg, "decode error"); 373da6c28aaSamw return (NERR_InternalError); 374da6c28aaSamw } 375da6c28aaSamw 376*3db3f65cSamw smb_share_dexit(arg, NULL); 377da6c28aaSamw return (rc); 378da6c28aaSamw } 379da6c28aaSamw 380*3db3f65cSamw uint32_t 381*3db3f65cSamw smb_share_add(smb_share_t *si) 382da6c28aaSamw { 383dc20a302Sas200622 door_arg_t *arg; 384da6c28aaSamw smb_dr_ctx_t *dec_ctx; 385da6c28aaSamw smb_dr_ctx_t *enc_ctx; 386*3db3f65cSamw uint32_t rc; 387da6c28aaSamw 388*3db3f65cSamw if ((arg = smb_share_denter()) == NULL) 389da6c28aaSamw return (NERR_InternalError); 390da6c28aaSamw 391*3db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 392*3db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_ADD); 393*3db3f65cSamw smb_dr_put_share(enc_ctx, si); 394da6c28aaSamw 395dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 396dc20a302Sas200622 if (rc != 0) { 397*3db3f65cSamw smb_share_dexit(arg, "encode error"); 398da6c28aaSamw return (NERR_InternalError); 399da6c28aaSamw } 400da6c28aaSamw 401*3db3f65cSamw if (door_call(smb_share_dfd, arg) < 0) { 402*3db3f65cSamw smb_share_dexit(arg, "door call error"); 403*3db3f65cSamw smb_share_dclose(); 404da6c28aaSamw return (NERR_InternalError); 405da6c28aaSamw } 406da6c28aaSamw 407dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 408*3db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 409dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 410*3db3f65cSamw smb_share_dexit(arg, "decode error"); 411da6c28aaSamw return (NERR_InternalError); 412da6c28aaSamw } 413da6c28aaSamw 414da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 415*3db3f65cSamw smb_dr_get_share(dec_ctx, si); 416dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 417*3db3f65cSamw smb_share_dexit(arg, "decode error"); 418da6c28aaSamw return (NERR_InternalError); 419da6c28aaSamw } 420da6c28aaSamw 421*3db3f65cSamw smb_share_dexit(arg, NULL); 422da6c28aaSamw return (rc); 423da6c28aaSamw } 424da6c28aaSamw 425*3db3f65cSamw uint32_t 426*3db3f65cSamw smb_share_set(smb_share_t *si) 427da6c28aaSamw { 428dc20a302Sas200622 door_arg_t *arg; 429da6c28aaSamw smb_dr_ctx_t *dec_ctx; 430da6c28aaSamw smb_dr_ctx_t *enc_ctx; 431*3db3f65cSamw uint32_t rc; 432da6c28aaSamw 433*3db3f65cSamw if ((arg = smb_share_denter()) == NULL) 434da6c28aaSamw return (NERR_InternalError); 435da6c28aaSamw 436*3db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 437*3db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_SETINFO); 438*3db3f65cSamw smb_dr_put_share(enc_ctx, si); 439da6c28aaSamw 440dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 441dc20a302Sas200622 if (rc != 0) { 442*3db3f65cSamw smb_share_dexit(arg, "encode error"); 443da6c28aaSamw return (NERR_InternalError); 444da6c28aaSamw } 445da6c28aaSamw 446*3db3f65cSamw if (door_call(smb_share_dfd, arg) < 0) { 447*3db3f65cSamw smb_share_dexit(arg, "door call error"); 448*3db3f65cSamw smb_share_dclose(); 449da6c28aaSamw return (NERR_InternalError); 450da6c28aaSamw } 451da6c28aaSamw 452dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 453*3db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 454dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 455*3db3f65cSamw smb_share_dexit(arg, "decode error"); 456da6c28aaSamw return (NERR_InternalError); 457da6c28aaSamw } 458da6c28aaSamw 459da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 460dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 461*3db3f65cSamw smb_share_dexit(arg, "decode error"); 462da6c28aaSamw return (NERR_InternalError); 463da6c28aaSamw } 464da6c28aaSamw 465*3db3f65cSamw smb_share_dexit(arg, NULL); 466da6c28aaSamw return (rc); 467da6c28aaSamw } 468