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 /* 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> 45da6c28aaSamw #include <smbsrv/cifs.h> 46da6c28aaSamw 47*8d96b23eSAlan Wright #define SMB_SHARE_DOOR_CALL_RETRIES 3 48*8d96b23eSAlan 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 54*8d96b23eSAlan Wright static int smb_share_door_clnt_open(void); 55*8d96b23eSAlan Wright static void smb_share_door_clnt_close(void); 56*8d96b23eSAlan Wright 57*8d96b23eSAlan Wright void 58*8d96b23eSAlan Wright smb_share_door_clnt_init(void) 59*8d96b23eSAlan Wright { 60*8d96b23eSAlan Wright (void) mutex_lock(&smb_share_dmtx); 61*8d96b23eSAlan Wright (void) smb_share_door_clnt_open(); 62*8d96b23eSAlan Wright (void) mutex_unlock(&smb_share_dmtx); 63*8d96b23eSAlan Wright } 64*8d96b23eSAlan Wright 65*8d96b23eSAlan Wright void 66*8d96b23eSAlan Wright smb_share_door_clnt_fini(void) 67*8d96b23eSAlan Wright { 68*8d96b23eSAlan Wright (void) mutex_lock(&smb_share_dmtx); 69*8d96b23eSAlan Wright smb_share_door_clnt_close(); 70*8d96b23eSAlan Wright (void) mutex_unlock(&smb_share_dmtx); 71*8d96b23eSAlan Wright } 72*8d96b23eSAlan Wright 73da6c28aaSamw /* 74*8d96b23eSAlan Wright * Open smb_share_door. This is a private call for use by 75*8d96b23eSAlan 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 80*8d96b23eSAlan 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 /* 93*8d96b23eSAlan Wright * Close smb_share_door. 94*8d96b23eSAlan Wright * Private call that must be called with smb_share_dmtx held. 95dc20a302Sas200622 */ 96*8d96b23eSAlan Wright static void 97*8d96b23eSAlan 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 /* 111*8d96b23eSAlan Wright * Entry handler for smb_share_door calls. 112dc20a302Sas200622 */ 113dc20a302Sas200622 static door_arg_t * 114*8d96b23eSAlan 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 121*8d96b23eSAlan 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 /* 141*8d96b23eSAlan Wright * Exit handler for smb_share_door calls. 142dc20a302Sas200622 */ 143dc20a302Sas200622 static void 144*8d96b23eSAlan Wright smb_share_door_clnt_exit(door_arg_t *arg, boolean_t must_close, char *errmsg) 145dc20a302Sas200622 { 146dc20a302Sas200622 if (errmsg) 147*8d96b23eSAlan 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); 153*8d96b23eSAlan Wright 154*8d96b23eSAlan Wright if (must_close) 155*8d96b23eSAlan Wright smb_share_door_clnt_close(); 156*8d96b23eSAlan Wright 1573db3f65cSamw (void) mutex_unlock(&smb_share_dmtx); 158da6c28aaSamw } 159da6c28aaSamw 160*8d96b23eSAlan Wright static int 161*8d96b23eSAlan Wright smb_share_door_call(int fd, door_arg_t *arg) 162*8d96b23eSAlan Wright { 163*8d96b23eSAlan Wright int rc; 164*8d96b23eSAlan Wright int i; 165*8d96b23eSAlan Wright 166*8d96b23eSAlan Wright for (i = 0; i < SMB_SHARE_DOOR_CALL_RETRIES; ++i) { 167*8d96b23eSAlan Wright errno = 0; 168*8d96b23eSAlan Wright 169*8d96b23eSAlan Wright if ((rc = door_call(fd, arg)) == 0) 170*8d96b23eSAlan Wright break; 171*8d96b23eSAlan Wright 172*8d96b23eSAlan Wright if (errno != EAGAIN && errno != EINTR) 173*8d96b23eSAlan Wright break; 174*8d96b23eSAlan Wright } 175*8d96b23eSAlan Wright 176*8d96b23eSAlan Wright return (rc); 177*8d96b23eSAlan Wright } 178*8d96b23eSAlan 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 203*8d96b23eSAlan 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) { 212*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 213da6c28aaSamw return (NERR_InternalError); 214da6c28aaSamw } 215da6c28aaSamw 216*8d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 217*8d96b23eSAlan 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); 224*8d96b23eSAlan 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) { 231*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 232da6c28aaSamw return (NERR_InternalError); 233da6c28aaSamw } 234da6c28aaSamw 235*8d96b23eSAlan 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 248*8d96b23eSAlan 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) { 256*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 257da6c28aaSamw return (-1); 258da6c28aaSamw } 259da6c28aaSamw 260*8d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 261*8d96b23eSAlan 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); 268*8d96b23eSAlan 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) { 274*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 275da6c28aaSamw return (-1); 276da6c28aaSamw } 277da6c28aaSamw 278*8d96b23eSAlan 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 290*8d96b23eSAlan 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) { 299*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 300da6c28aaSamw return (NERR_InternalError); 301da6c28aaSamw } 302da6c28aaSamw 303*8d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 304*8d96b23eSAlan 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); 311*8d96b23eSAlan 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) { 317*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 318da6c28aaSamw return (NERR_InternalError); 319da6c28aaSamw } 320da6c28aaSamw 321*8d96b23eSAlan 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 334*8d96b23eSAlan 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) { 344*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 345da6c28aaSamw return (NERR_InternalError); 346da6c28aaSamw } 347da6c28aaSamw 348*8d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 349*8d96b23eSAlan 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); 356*8d96b23eSAlan 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) { 362*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 363da6c28aaSamw return (NERR_InternalError); 364da6c28aaSamw } 365da6c28aaSamw 366*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 367da6c28aaSamw return (rc); 368da6c28aaSamw } 369da6c28aaSamw 3703db3f65cSamw uint32_t 3713db3f65cSamw smb_share_get(char *share_name, 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 378*8d96b23eSAlan 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_GETINFO); 383da6c28aaSamw smb_dr_put_string(enc_ctx, share_name); 384da6c28aaSamw 385dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 386dc20a302Sas200622 if (rc != 0) { 387*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 388da6c28aaSamw return (NERR_InternalError); 389da6c28aaSamw } 390da6c28aaSamw 391*8d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 392*8d96b23eSAlan 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); 399*8d96b23eSAlan 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) { 406*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 407da6c28aaSamw return (NERR_InternalError); 408da6c28aaSamw } 409da6c28aaSamw 410*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 411da6c28aaSamw return (rc); 412da6c28aaSamw } 413da6c28aaSamw 4143db3f65cSamw uint32_t 415c8ec8eeaSjose borrego smb_share_create(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 422*8d96b23eSAlan 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); 4263db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_ADD); 4273db3f65cSamw 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) { 431*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 432da6c28aaSamw return (NERR_InternalError); 433da6c28aaSamw } 434da6c28aaSamw 435*8d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 436*8d96b23eSAlan 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); 443*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 444da6c28aaSamw return (NERR_InternalError); 445da6c28aaSamw } 446da6c28aaSamw 447da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 4483db3f65cSamw smb_dr_get_share(dec_ctx, si); 449dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 450*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 451da6c28aaSamw return (NERR_InternalError); 452da6c28aaSamw } 453da6c28aaSamw 454*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 455da6c28aaSamw return (rc); 456da6c28aaSamw } 457da6c28aaSamw 4583db3f65cSamw uint32_t 459c8ec8eeaSjose borrego smb_share_modify(char *sharename, char *cmnt, char *ad_container) 460da6c28aaSamw { 461dc20a302Sas200622 door_arg_t *arg; 462da6c28aaSamw smb_dr_ctx_t *dec_ctx; 463da6c28aaSamw smb_dr_ctx_t *enc_ctx; 4643db3f65cSamw uint32_t rc; 465da6c28aaSamw 466*8d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL) 467da6c28aaSamw return (NERR_InternalError); 468da6c28aaSamw 4693db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE); 470c8ec8eeaSjose borrego smb_dr_put_uint32(enc_ctx, SMB_SHROP_MODIFY); 471c8ec8eeaSjose borrego smb_dr_put_string(enc_ctx, sharename); 472c8ec8eeaSjose borrego smb_dr_put_string(enc_ctx, cmnt); 473c8ec8eeaSjose borrego smb_dr_put_string(enc_ctx, ad_container); 474da6c28aaSamw 475dc20a302Sas200622 rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size); 476dc20a302Sas200622 if (rc != 0) { 477*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode"); 478da6c28aaSamw return (NERR_InternalError); 479da6c28aaSamw } 480da6c28aaSamw 481*8d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) { 482*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call"); 483da6c28aaSamw return (NERR_InternalError); 484da6c28aaSamw } 485da6c28aaSamw 486dc20a302Sas200622 dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size); 4873db3f65cSamw if (smb_share_dchk(dec_ctx) != 0) { 488dc20a302Sas200622 (void) smb_dr_decode_finish(dec_ctx); 489*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 490da6c28aaSamw return (NERR_InternalError); 491da6c28aaSamw } 492da6c28aaSamw 493da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx); 494dc20a302Sas200622 if (smb_dr_decode_finish(dec_ctx) != 0) { 495*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode"); 496da6c28aaSamw return (NERR_InternalError); 497da6c28aaSamw } 498da6c28aaSamw 499*8d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL); 500da6c28aaSamw return (rc); 501da6c28aaSamw } 502