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 /*
23148c5f43SAlan Wright * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24b819cea2SGordon Ross * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
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>
38dc20a302Sas #include <unistd.h>
39dc20a302Sas #include <thread.h>
40dc20a302Sas #include <synch.h>
41da6c28aaSamw
42da6c28aaSamw #include <smbsrv/libsmb.h>
433db3f65cSamw #include <smbsrv/smb_share.h>
44bbf6f00cSJordan Brown #include <smbsrv/smb.h>
45da6c28aaSamw
468d96b23eSAlan Wright #define SMB_SHARE_DOOR_CALL_RETRIES 3
478d96b23eSAlan Wright
483db3f65cSamw static int smb_share_dfd = -1;
493db3f65cSamw static uint64_t smb_share_dncall = 0;
503db3f65cSamw static mutex_t smb_share_dmtx;
513db3f65cSamw static cond_t smb_share_dcv;
52da6c28aaSamw
538d96b23eSAlan Wright static int smb_share_door_clnt_open(void);
548d96b23eSAlan Wright static void smb_share_door_clnt_close(void);
558d96b23eSAlan Wright
568d96b23eSAlan Wright void
smb_share_door_clnt_init(void)578d96b23eSAlan Wright smb_share_door_clnt_init(void)
588d96b23eSAlan Wright {
598d96b23eSAlan Wright (void) mutex_lock(&smb_share_dmtx);
608d96b23eSAlan Wright (void) smb_share_door_clnt_open();
618d96b23eSAlan Wright (void) mutex_unlock(&smb_share_dmtx);
628d96b23eSAlan Wright }
638d96b23eSAlan Wright
648d96b23eSAlan Wright void
smb_share_door_clnt_fini(void)658d96b23eSAlan Wright smb_share_door_clnt_fini(void)
668d96b23eSAlan Wright {
678d96b23eSAlan Wright (void) mutex_lock(&smb_share_dmtx);
688d96b23eSAlan Wright smb_share_door_clnt_close();
698d96b23eSAlan Wright (void) mutex_unlock(&smb_share_dmtx);
708d96b23eSAlan Wright }
718d96b23eSAlan Wright
72da6c28aaSamw /*
738d96b23eSAlan Wright * Open smb_share_door. This is a private call for use by
748d96b23eSAlan Wright * smb_share_door_clnt_enter() and must be called with smb_share_dmtx held.
75dc20a302Sas *
76dc20a302Sas * Returns the door fd on success. Otherwise, -1.
77da6c28aaSamw */
78da6c28aaSamw static int
smb_share_door_clnt_open(void)798d96b23eSAlan Wright smb_share_door_clnt_open(void)
80dc20a302Sas {
81b819cea2SGordon Ross const char *door_name;
82b819cea2SGordon Ross
833db3f65cSamw if (smb_share_dfd == -1) {
84b819cea2SGordon Ross door_name = getenv("SMB_SHARE_DNAME");
85b819cea2SGordon Ross if (door_name == NULL)
86b819cea2SGordon Ross door_name = SMB_SHARE_DNAME;
87b819cea2SGordon Ross
88b819cea2SGordon Ross if ((smb_share_dfd = open(door_name, O_RDONLY)) < 0)
893db3f65cSamw smb_share_dfd = -1;
90dc20a302Sas else
913db3f65cSamw smb_share_dncall = 0;
92dc20a302Sas }
93dc20a302Sas
943db3f65cSamw return (smb_share_dfd);
95dc20a302Sas }
96dc20a302Sas
97dc20a302Sas /*
988d96b23eSAlan Wright * Close smb_share_door.
998d96b23eSAlan Wright * Private call that must be called with smb_share_dmtx held.
100dc20a302Sas */
1018d96b23eSAlan Wright static void
smb_share_door_clnt_close(void)1028d96b23eSAlan Wright smb_share_door_clnt_close(void)
103da6c28aaSamw {
1043db3f65cSamw if (smb_share_dfd != -1) {
1053db3f65cSamw while (smb_share_dncall > 0)
1063db3f65cSamw (void) cond_wait(&smb_share_dcv, &smb_share_dmtx);
107dc20a302Sas
1083db3f65cSamw if (smb_share_dfd != -1) {
1093db3f65cSamw (void) close(smb_share_dfd);
1103db3f65cSamw smb_share_dfd = -1;
111dc20a302Sas }
112da6c28aaSamw }
113da6c28aaSamw }
114da6c28aaSamw
115da6c28aaSamw /*
1168d96b23eSAlan Wright * Entry handler for smb_share_door calls.
117da6c28aaSamw */
118dc20a302Sas static door_arg_t *
smb_share_door_clnt_enter(void)1198d96b23eSAlan Wright smb_share_door_clnt_enter(void)
120da6c28aaSamw {
121dc20a302Sas door_arg_t *arg;
122dc20a302Sas char *buf;
123da6c28aaSamw
1243db3f65cSamw (void) mutex_lock(&smb_share_dmtx);
125da6c28aaSamw
1268d96b23eSAlan Wright if (smb_share_door_clnt_open() == -1) {
1273db3f65cSamw (void) mutex_unlock(&smb_share_dmtx);
128dc20a302Sas return (NULL);
129dc20a302Sas }
130dc20a302Sas
1313db3f65cSamw if ((arg = malloc(sizeof (door_arg_t) + SMB_SHARE_DSIZE)) != NULL) {
132dc20a302Sas buf = ((char *)arg) + sizeof (door_arg_t);
133dc20a302Sas bzero(arg, sizeof (door_arg_t));
134dc20a302Sas arg->data_ptr = buf;
135dc20a302Sas arg->rbuf = buf;
1363db3f65cSamw arg->rsize = SMB_SHARE_DSIZE;
137da6c28aaSamw
1383db3f65cSamw ++smb_share_dncall;
139da6c28aaSamw }
140da6c28aaSamw
1413db3f65cSamw (void) mutex_unlock(&smb_share_dmtx);
142dc20a302Sas return (arg);
143dc20a302Sas }
144dc20a302Sas
145dc20a302Sas /*
1468d96b23eSAlan Wright * Exit handler for smb_share_door calls.
147dc20a302Sas */
148dc20a302Sas static void
smb_share_door_clnt_exit(door_arg_t * arg,boolean_t must_close,char * errmsg)1498d96b23eSAlan Wright smb_share_door_clnt_exit(door_arg_t *arg, boolean_t must_close, char *errmsg)
150dc20a302Sas {
151dc20a302Sas if (errmsg)
1528d96b23eSAlan Wright syslog(LOG_DEBUG, "smb_share_door: %s failed", errmsg);
153dc20a302Sas
1543db3f65cSamw (void) mutex_lock(&smb_share_dmtx);
155dc20a302Sas free(arg);
1563db3f65cSamw --smb_share_dncall;
1573db3f65cSamw (void) cond_signal(&smb_share_dcv);
1588d96b23eSAlan Wright
1598d96b23eSAlan Wright if (must_close)
1608d96b23eSAlan Wright smb_share_door_clnt_close();
1618d96b23eSAlan Wright
1623db3f65cSamw (void) mutex_unlock(&smb_share_dmtx);
163dc20a302Sas }
164dc20a302Sas
1658d96b23eSAlan Wright static int
smb_share_door_call(int fd,door_arg_t * arg)1668d96b23eSAlan Wright smb_share_door_call(int fd, door_arg_t *arg)
1678d96b23eSAlan Wright {
1688d96b23eSAlan Wright int rc;
1698d96b23eSAlan Wright int i;
1708d96b23eSAlan Wright
1718d96b23eSAlan Wright for (i = 0; i < SMB_SHARE_DOOR_CALL_RETRIES; ++i) {
1728d96b23eSAlan Wright errno = 0;
1738d96b23eSAlan Wright
1748d96b23eSAlan Wright if ((rc = door_call(fd, arg)) == 0)
1758d96b23eSAlan Wright break;
1768d96b23eSAlan Wright
1778d96b23eSAlan Wright if (errno != EAGAIN && errno != EINTR)
1788d96b23eSAlan Wright break;
1798d96b23eSAlan Wright }
1808d96b23eSAlan Wright
1818d96b23eSAlan Wright return (rc);
1828d96b23eSAlan Wright }
1838d96b23eSAlan Wright
184dc20a302Sas static int
smb_share_dchk(smb_dr_ctx_t * dec_ctx)1853db3f65cSamw smb_share_dchk(smb_dr_ctx_t *dec_ctx)
186dc20a302Sas {
187dc20a302Sas int status = smb_dr_get_int32(dec_ctx);
188dc20a302Sas
1893db3f65cSamw if (status != SMB_SHARE_DSUCCESS) {
1903db3f65cSamw if (status == SMB_SHARE_DERROR)
191dc20a302Sas (void) smb_dr_get_uint32(dec_ctx);
192dc20a302Sas return (-1);
193da6c28aaSamw }
194da6c28aaSamw
195dc20a302Sas return (0);
196da6c28aaSamw }
197da6c28aaSamw
1983db3f65cSamw uint32_t
smb_share_list(int offset,smb_shrlist_t * list)1993db3f65cSamw smb_share_list(int offset, smb_shrlist_t *list)
200da6c28aaSamw {
201dc20a302Sas door_arg_t *arg;
202da6c28aaSamw smb_dr_ctx_t *dec_ctx;
203da6c28aaSamw smb_dr_ctx_t *enc_ctx;
2043db3f65cSamw uint32_t rc;
205da6c28aaSamw
206c8ec8eeaSjose borrego bzero(list, sizeof (smb_shrlist_t));
207c8ec8eeaSjose borrego
2088d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL)
209da6c28aaSamw return (NERR_InternalError);
210da6c28aaSamw
2113db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE);
2123db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_LIST);
213da6c28aaSamw smb_dr_put_int32(enc_ctx, offset);
214da6c28aaSamw
215dc20a302Sas rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size);
216dc20a302Sas if (rc != 0) {
2178d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode");
218da6c28aaSamw return (NERR_InternalError);
219da6c28aaSamw }
220da6c28aaSamw
2218d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) {
2228d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call");
223da6c28aaSamw return (NERR_InternalError);
224da6c28aaSamw }
225da6c28aaSamw
226dc20a302Sas dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size);
227*2bc647a2SToomas Soome if (dec_ctx == NULL || smb_share_dchk(dec_ctx) != 0) {
228*2bc647a2SToomas Soome if (dec_ctx != NULL)
229*2bc647a2SToomas Soome (void) smb_dr_decode_finish(dec_ctx);
2308d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode");
231da6c28aaSamw return (NERR_InternalError);
232da6c28aaSamw }
233da6c28aaSamw
234c8ec8eeaSjose borrego (void) smb_dr_get_buf(dec_ctx, (unsigned char *)list,
235c8ec8eeaSjose borrego sizeof (smb_shrlist_t));
236dc20a302Sas if (smb_dr_decode_finish(dec_ctx) != 0) {
2378d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode");
238da6c28aaSamw return (NERR_InternalError);
239da6c28aaSamw }
240da6c28aaSamw
2418d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL);
2423ad684d6Sjb return (NERR_Success);
243da6c28aaSamw }
244da6c28aaSamw
245da6c28aaSamw int
smb_share_count(void)2463db3f65cSamw smb_share_count(void)
247da6c28aaSamw {
248dc20a302Sas door_arg_t *arg;
249da6c28aaSamw smb_dr_ctx_t *dec_ctx;
250da6c28aaSamw smb_dr_ctx_t *enc_ctx;
2513db3f65cSamw uint32_t num_shares;
252dc20a302Sas int rc;
253da6c28aaSamw
2548d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL)
255da6c28aaSamw return (-1);
256da6c28aaSamw
2573db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE);
2583db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_NUM_SHARES);
259dc20a302Sas
260dc20a302Sas rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size);
261dc20a302Sas if (rc != 0) {
2628d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode");
263da6c28aaSamw return (-1);
264da6c28aaSamw }
265da6c28aaSamw
2668d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) {
2678d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call");
268da6c28aaSamw return (-1);
269da6c28aaSamw }
270da6c28aaSamw
271dc20a302Sas dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size);
272*2bc647a2SToomas Soome if (dec_ctx == NULL || smb_share_dchk(dec_ctx) != 0) {
273*2bc647a2SToomas Soome if (dec_ctx != NULL)
274*2bc647a2SToomas Soome (void) smb_dr_decode_finish(dec_ctx);
2758d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode");
276da6c28aaSamw return (-1);
277da6c28aaSamw }
278da6c28aaSamw
279da6c28aaSamw num_shares = smb_dr_get_uint32(dec_ctx);
280dc20a302Sas if (smb_dr_decode_finish(dec_ctx) != 0) {
2818d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode");
282da6c28aaSamw return (-1);
283da6c28aaSamw }
284da6c28aaSamw
2858d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL);
286da6c28aaSamw return (num_shares);
287da6c28aaSamw }
288da6c28aaSamw
2893db3f65cSamw uint32_t
smb_share_delete(char * share_name)290c8ec8eeaSjose borrego smb_share_delete(char *share_name)
291da6c28aaSamw {
292dc20a302Sas door_arg_t *arg;
293da6c28aaSamw smb_dr_ctx_t *dec_ctx;
294da6c28aaSamw smb_dr_ctx_t *enc_ctx;
2953db3f65cSamw uint32_t rc;
296da6c28aaSamw
2978d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL)
298da6c28aaSamw return (NERR_InternalError);
299da6c28aaSamw
3003db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE);
3013db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_DELETE);
302da6c28aaSamw smb_dr_put_string(enc_ctx, share_name);
303da6c28aaSamw
304dc20a302Sas rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size);
305dc20a302Sas if (rc != 0) {
3068d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode");
307da6c28aaSamw return (NERR_InternalError);
308da6c28aaSamw }
309da6c28aaSamw
3108d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) {
3118d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call");
312da6c28aaSamw return (NERR_InternalError);
313da6c28aaSamw }
314da6c28aaSamw
315dc20a302Sas dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size);
316*2bc647a2SToomas Soome if (dec_ctx == NULL || smb_share_dchk(dec_ctx) != 0) {
317*2bc647a2SToomas Soome if (dec_ctx != NULL)
318*2bc647a2SToomas Soome (void) smb_dr_decode_finish(dec_ctx);
3198d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode");
320da6c28aaSamw return (NERR_InternalError);
321da6c28aaSamw }
322da6c28aaSamw
323da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx);
324dc20a302Sas if (smb_dr_decode_finish(dec_ctx) != 0) {
3258d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode");
326da6c28aaSamw return (NERR_InternalError);
327da6c28aaSamw }
328da6c28aaSamw
3298d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL);
330da6c28aaSamw return (rc);
331da6c28aaSamw
332da6c28aaSamw }
333da6c28aaSamw
3343db3f65cSamw uint32_t
smb_share_rename(char * from,char * to)335c8ec8eeaSjose borrego smb_share_rename(char *from, char *to)
336da6c28aaSamw {
337dc20a302Sas door_arg_t *arg;
338da6c28aaSamw smb_dr_ctx_t *dec_ctx;
339da6c28aaSamw smb_dr_ctx_t *enc_ctx;
3403db3f65cSamw uint32_t rc;
341da6c28aaSamw
3428d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL)
343da6c28aaSamw return (NERR_InternalError);
344da6c28aaSamw
3453db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE);
3463db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_RENAME);
347da6c28aaSamw smb_dr_put_string(enc_ctx, from);
348da6c28aaSamw smb_dr_put_string(enc_ctx, to);
349da6c28aaSamw
350dc20a302Sas rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size);
351dc20a302Sas if (rc != 0) {
3528d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode");
353da6c28aaSamw return (NERR_InternalError);
354da6c28aaSamw }
355da6c28aaSamw
3568d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) {
3578d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call");
358da6c28aaSamw return (NERR_InternalError);
359da6c28aaSamw }
360da6c28aaSamw
361dc20a302Sas dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size);
362*2bc647a2SToomas Soome if (dec_ctx == NULL || smb_share_dchk(dec_ctx) != 0) {
363*2bc647a2SToomas Soome if (dec_ctx != NULL)
364*2bc647a2SToomas Soome (void) smb_dr_decode_finish(dec_ctx);
3658d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode");
366da6c28aaSamw return (NERR_InternalError);
367da6c28aaSamw }
368da6c28aaSamw
369da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx);
370dc20a302Sas if (smb_dr_decode_finish(dec_ctx) != 0) {
3718d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode");
372da6c28aaSamw return (NERR_InternalError);
373da6c28aaSamw }
374da6c28aaSamw
3758d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL);
376da6c28aaSamw return (rc);
377da6c28aaSamw }
378da6c28aaSamw
3793db3f65cSamw uint32_t
smb_share_create(smb_share_t * si)380c8ec8eeaSjose borrego smb_share_create(smb_share_t *si)
381da6c28aaSamw {
382dc20a302Sas door_arg_t *arg;
383da6c28aaSamw smb_dr_ctx_t *dec_ctx;
384da6c28aaSamw smb_dr_ctx_t *enc_ctx;
3853db3f65cSamw uint32_t rc;
386da6c28aaSamw
3878d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL)
388da6c28aaSamw return (NERR_InternalError);
389da6c28aaSamw
3903db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE);
3913db3f65cSamw smb_dr_put_uint32(enc_ctx, SMB_SHROP_ADD);
3923db3f65cSamw smb_dr_put_share(enc_ctx, si);
393da6c28aaSamw
394dc20a302Sas rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size);
395dc20a302Sas if (rc != 0) {
3968d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode");
397da6c28aaSamw return (NERR_InternalError);
398da6c28aaSamw }
399da6c28aaSamw
4008d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) {
4018d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call");
402da6c28aaSamw return (NERR_InternalError);
403da6c28aaSamw }
404da6c28aaSamw
405dc20a302Sas dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size);
406*2bc647a2SToomas Soome if (dec_ctx == NULL || smb_share_dchk(dec_ctx) != 0) {
407*2bc647a2SToomas Soome if (dec_ctx != NULL)
408*2bc647a2SToomas Soome (void) smb_dr_decode_finish(dec_ctx);
4098d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode");
410da6c28aaSamw return (NERR_InternalError);
411da6c28aaSamw }
412da6c28aaSamw
413da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx);
4143db3f65cSamw smb_dr_get_share(dec_ctx, si);
415dc20a302Sas if (smb_dr_decode_finish(dec_ctx) != 0) {
4168d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode");
417da6c28aaSamw return (NERR_InternalError);
418da6c28aaSamw }
419da6c28aaSamw
4208d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL);
421da6c28aaSamw return (rc);
422da6c28aaSamw }
423da6c28aaSamw
4243db3f65cSamw uint32_t
smb_share_modify(smb_share_t * si)425b89a8333Snatalie li - Sun Microsystems - Irvine United States smb_share_modify(smb_share_t *si)
426da6c28aaSamw {
427dc20a302Sas door_arg_t *arg;
428da6c28aaSamw smb_dr_ctx_t *dec_ctx;
429da6c28aaSamw smb_dr_ctx_t *enc_ctx;
4303db3f65cSamw uint32_t rc;
431da6c28aaSamw
4328d96b23eSAlan Wright if ((arg = smb_share_door_clnt_enter()) == NULL)
433da6c28aaSamw return (NERR_InternalError);
434da6c28aaSamw
4353db3f65cSamw enc_ctx = smb_dr_encode_start(arg->data_ptr, SMB_SHARE_DSIZE);
436c8ec8eeaSjose borrego smb_dr_put_uint32(enc_ctx, SMB_SHROP_MODIFY);
437b89a8333Snatalie li - Sun Microsystems - Irvine United States smb_dr_put_share(enc_ctx, si);
438da6c28aaSamw
439dc20a302Sas rc = smb_dr_encode_finish(enc_ctx, (unsigned int *)&arg->data_size);
440dc20a302Sas if (rc != 0) {
4418d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "encode");
442da6c28aaSamw return (NERR_InternalError);
443da6c28aaSamw }
444da6c28aaSamw
4458d96b23eSAlan Wright if (smb_share_door_call(smb_share_dfd, arg) < 0) {
4468d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_TRUE, "door call");
447da6c28aaSamw return (NERR_InternalError);
448da6c28aaSamw }
449da6c28aaSamw
450dc20a302Sas dec_ctx = smb_dr_decode_start(arg->data_ptr, arg->data_size);
451*2bc647a2SToomas Soome if (dec_ctx == NULL || smb_share_dchk(dec_ctx) != 0) {
452*2bc647a2SToomas Soome if (dec_ctx != NULL)
453*2bc647a2SToomas Soome (void) smb_dr_decode_finish(dec_ctx);
4548d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode");
455da6c28aaSamw return (NERR_InternalError);
456da6c28aaSamw }
457da6c28aaSamw
458da6c28aaSamw rc = smb_dr_get_uint32(dec_ctx);
459dc20a302Sas if (smb_dr_decode_finish(dec_ctx) != 0) {
4608d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, "decode");
461da6c28aaSamw return (NERR_InternalError);
462da6c28aaSamw }
463da6c28aaSamw
4648d96b23eSAlan Wright smb_share_door_clnt_exit(arg, B_FALSE, NULL);
465da6c28aaSamw return (rc);
466da6c28aaSamw }
467