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 /*
23c5866007SKeyur Desai * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
241160dcf7SMatt Barden * Copyright 2017 Nexenta Systems, Inc. All rights reserved.
25814e0daaSGordon Ross * Copyright 2022 RackTop Systems.
26da6c28aaSamw */
27da6c28aaSamw
28da6c28aaSamw /*
29da6c28aaSamw * SMB specific functions
30da6c28aaSamw */
31da6c28aaSamw #include <stdio.h>
32da6c28aaSamw #include <string.h>
33da6c28aaSamw #include <ctype.h>
34da6c28aaSamw #include <stdlib.h>
35da6c28aaSamw #include <unistd.h>
36da6c28aaSamw #include <zone.h>
37da6c28aaSamw #include <errno.h>
38da6c28aaSamw #include <locale.h>
39da6c28aaSamw #include <fcntl.h>
40da6c28aaSamw #include <sys/types.h>
41da6c28aaSamw #include <sys/stat.h>
42da6c28aaSamw #include <syslog.h>
43da6c28aaSamw #include "libshare.h"
44da6c28aaSamw #include "libshare_impl.h"
45da6c28aaSamw #include <pwd.h>
46da6c28aaSamw #include <limits.h>
47da6c28aaSamw #include <libscf.h>
48b56bf881SAntonello Cruz #include <libscf_priv.h>
49da6c28aaSamw #include <strings.h>
50da6c28aaSamw #include "libshare_smb.h"
51da6c28aaSamw #include <rpcsvc/daemon_utils.h>
523db3f65cSamw #include <smbsrv/smb_share.h>
53da6c28aaSamw #include <smbsrv/smbinfo.h>
54da6c28aaSamw #include <smbsrv/libsmb.h>
558d7e4166Sjose borrego #include <libdlpi.h>
568d7e4166Sjose borrego
578d7e4166Sjose borrego #define SMB_CSC_BUFSZ 64
58da6c28aaSamw
5929bd2886SAlan Wright #define SMB_VALID_SUB_CHRS "UDhMLmIiSPu" /* substitution characters */
6029bd2886SAlan Wright
61da6c28aaSamw /* internal functions */
62da6c28aaSamw static int smb_share_init(void);
63da6c28aaSamw static void smb_share_fini(void);
64da6c28aaSamw static int smb_enable_share(sa_share_t);
65da6c28aaSamw static int smb_share_changed(sa_share_t);
66da6c28aaSamw static int smb_resource_changed(sa_resource_t);
67da6c28aaSamw static int smb_rename_resource(sa_handle_t, sa_resource_t, char *);
68da6c28aaSamw static int smb_disable_share(sa_share_t share, char *);
69687915e9Sdougm static int smb_validate_property(sa_handle_t, sa_property_t, sa_optionset_t);
70da6c28aaSamw static int smb_set_proto_prop(sa_property_t);
71da6c28aaSamw static sa_protocol_properties_t smb_get_proto_set(void);
72da6c28aaSamw static char *smb_get_status(void);
73da6c28aaSamw static int smb_parse_optstring(sa_group_t, char *);
74da6c28aaSamw static char *smb_format_options(sa_group_t, int);
75da6c28aaSamw
76da6c28aaSamw static int smb_enable_service(void);
77da6c28aaSamw
78da6c28aaSamw static int range_check_validator(int, char *);
79da6c28aaSamw static int range_check_validator_zero_ok(int, char *);
80da6c28aaSamw static int string_length_check_validator(int, char *);
8186d7016bSGordon Ross static int print_enable_validator(int, char *);
82da6c28aaSamw static int true_false_validator(int, char *);
8329bd2886SAlan Wright static int ipv4_validator(int, char *);
8496a62adaSjoyce mcintosh static int hostname_validator(int, char *);
85da6c28aaSamw static int path_validator(int, char *);
8629bd2886SAlan Wright static int cmd_validator(int, char *);
8729bd2886SAlan Wright static int disposition_validator(int, char *);
883e2c0c09SMatt Barden static int protocol_validator(int, char *);
891160dcf7SMatt Barden static int require_validator(int, char *);
90b0bb0d63SGordon Ross static int ciphers_validator(int, char *);
91da6c28aaSamw
92da6c28aaSamw static int smb_enable_resource(sa_resource_t);
93da6c28aaSamw static int smb_disable_resource(sa_resource_t);
94da6c28aaSamw static uint64_t smb_share_features(void);
95da6c28aaSamw static int smb_list_transient(sa_handle_t);
96dc20a302Sas200622
97c8ec8eeaSjose borrego static int smb_build_shareinfo(sa_share_t, sa_resource_t, smb_share_t *);
988d7e4166Sjose borrego static void smb_csc_option(const char *, smb_share_t *);
9989dc44ceSjose borrego static char *smb_csc_name(const smb_share_t *);
100c8ec8eeaSjose borrego static sa_group_t smb_get_defaultgrp(sa_handle_t);
1018d7e4166Sjose borrego static int interface_validator(int, char *);
10296a62adaSjoyce mcintosh static int smb_update_optionset_props(sa_handle_t, sa_resource_t, nvlist_t *);
103c8ec8eeaSjose borrego
104ca5fb90aSGordon Ross static boolean_t smb_saprop_getbool(sa_optionset_t, char *, boolean_t);
1059fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States static boolean_t smb_saprop_getstr(sa_optionset_t, char *, char *, size_t);
1069fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
10789dc44ceSjose borrego static struct {
10889dc44ceSjose borrego char *value;
10989dc44ceSjose borrego uint32_t flag;
11089dc44ceSjose borrego } cscopt[] = {
11189dc44ceSjose borrego { "disabled", SMB_SHRF_CSC_DISABLED },
11289dc44ceSjose borrego { "manual", SMB_SHRF_CSC_MANUAL },
11389dc44ceSjose borrego { "auto", SMB_SHRF_CSC_AUTO },
11489dc44ceSjose borrego { "vdo", SMB_SHRF_CSC_VDO }
11589dc44ceSjose borrego };
11689dc44ceSjose borrego
117da6c28aaSamw /* size of basic format allocation */
118da6c28aaSamw #define OPT_CHUNK 1024
119da6c28aaSamw
120dc20a302Sas200622 /* size of string for types - big enough to hold "dependency" */
121dc20a302Sas200622 #define SCFTYPE_LEN 32
122dc20a302Sas200622
123da6c28aaSamw /*
124da6c28aaSamw * Indexes of entries in smb_proto_options table.
125da6c28aaSamw * Changes to smb_proto_options table may require
126da6c28aaSamw * an update to these values.
127da6c28aaSamw */
128da6c28aaSamw #define PROTO_OPT_WINS1 6
129da6c28aaSamw #define PROTO_OPT_WINS_EXCLUDE 8
130da6c28aaSamw
1318d7e4166Sjose borrego typedef struct smb_hostifs_walker {
1328d7e4166Sjose borrego const char *hiw_ifname;
1338d7e4166Sjose borrego boolean_t hiw_matchfound;
1348d7e4166Sjose borrego } smb_hostifs_walker_t;
1358d7e4166Sjose borrego
136da6c28aaSamw
137da6c28aaSamw /*
138da6c28aaSamw * ops vector that provides the protocol specific info and operations
139da6c28aaSamw * for share management.
140da6c28aaSamw */
141da6c28aaSamw
142da6c28aaSamw struct sa_plugin_ops sa_plugin_ops = {
143da6c28aaSamw SA_PLUGIN_VERSION,
144da6c28aaSamw SMB_PROTOCOL_NAME,
145da6c28aaSamw smb_share_init,
146da6c28aaSamw smb_share_fini,
147da6c28aaSamw smb_enable_share,
148da6c28aaSamw smb_disable_share,
149da6c28aaSamw smb_validate_property,
1504bff34e3Sthurlow NULL, /* valid_space */
1514bff34e3Sthurlow NULL, /* security_prop */
152da6c28aaSamw smb_parse_optstring,
153da6c28aaSamw smb_format_options,
154da6c28aaSamw smb_set_proto_prop,
155da6c28aaSamw smb_get_proto_set,
156da6c28aaSamw smb_get_status,
1574bff34e3Sthurlow NULL, /* space_alias */
1584bff34e3Sthurlow NULL, /* update_legacy */
1594bff34e3Sthurlow NULL, /* delete_legacy */
160da6c28aaSamw smb_share_changed,
161da6c28aaSamw smb_enable_resource,
162da6c28aaSamw smb_disable_resource,
163da6c28aaSamw smb_share_features,
164da6c28aaSamw smb_list_transient,
165da6c28aaSamw smb_resource_changed,
166da6c28aaSamw smb_rename_resource,
1674bff34e3Sthurlow NULL, /* run_command */
1684bff34e3Sthurlow NULL, /* command_help */
1694bff34e3Sthurlow NULL /* delete_proto_section */
170da6c28aaSamw };
171da6c28aaSamw
172da6c28aaSamw struct option_defs optdefs[] = {
1738d7e4166Sjose borrego { SHOPT_AD_CONTAINER, OPT_TYPE_STRING },
174e3f2c991SKeyur Desai { SHOPT_ABE, OPT_TYPE_BOOLEAN },
1758d7e4166Sjose borrego { SHOPT_NAME, OPT_TYPE_NAME },
176b89a8333Snatalie li - Sun Microsystems - Irvine United States { SHOPT_RO, OPT_TYPE_ACCLIST },
177b89a8333Snatalie li - Sun Microsystems - Irvine United States { SHOPT_RW, OPT_TYPE_ACCLIST },
178b89a8333Snatalie li - Sun Microsystems - Irvine United States { SHOPT_NONE, OPT_TYPE_ACCLIST },
1798b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States { SHOPT_CATIA, OPT_TYPE_BOOLEAN },
1808d7e4166Sjose borrego { SHOPT_CSC, OPT_TYPE_CSC },
18129bd2886SAlan Wright { SHOPT_GUEST, OPT_TYPE_BOOLEAN },
1829fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States { SHOPT_DFSROOT, OPT_TYPE_BOOLEAN },
183148c5f43SAlan Wright { SHOPT_DESCRIPTION, OPT_TYPE_STRING },
1848d94f651SGordon Ross { SHOPT_CA, OPT_TYPE_BOOLEAN },
18594047d49SGordon Ross { SHOPT_FSO, OPT_TYPE_BOOLEAN },
186ca5fb90aSGordon Ross { SHOPT_QUOTAS, OPT_TYPE_BOOLEAN },
1871160dcf7SMatt Barden { SHOPT_ENCRYPT, OPT_TYPE_STRING },
188ff168298SToomas Soome { NULL, 0 }
189da6c28aaSamw };
190da6c28aaSamw
191da6c28aaSamw /*
192da6c28aaSamw * findopt(name)
193da6c28aaSamw *
194da6c28aaSamw * Lookup option "name" in the option table and return the table
195da6c28aaSamw * index.
196da6c28aaSamw */
197da6c28aaSamw static int
findopt(char * name)198da6c28aaSamw findopt(char *name)
199da6c28aaSamw {
200da6c28aaSamw int i;
201da6c28aaSamw if (name != NULL) {
202da6c28aaSamw for (i = 0; optdefs[i].tag != NULL; i++) {
203da6c28aaSamw if (strcmp(optdefs[i].tag, name) == 0)
204da6c28aaSamw return (i);
205da6c28aaSamw }
206da6c28aaSamw }
207da6c28aaSamw return (-1);
208da6c28aaSamw }
209da6c28aaSamw
210da6c28aaSamw /*
211da6c28aaSamw * is_a_number(number)
212da6c28aaSamw *
213da6c28aaSamw * is the string a number in one of the forms we want to use?
214da6c28aaSamw */
215c8ec8eeaSjose borrego static boolean_t
is_a_number(char * number)216da6c28aaSamw is_a_number(char *number)
217da6c28aaSamw {
218c8ec8eeaSjose borrego boolean_t isnum = B_TRUE;
219c8ec8eeaSjose borrego boolean_t ishex = B_FALSE;
220da6c28aaSamw
221c8ec8eeaSjose borrego if (number == NULL || *number == '\0')
222c8ec8eeaSjose borrego return (B_FALSE);
223c8ec8eeaSjose borrego
224c8ec8eeaSjose borrego if (strncasecmp(number, "0x", 2) == 0) {
225da6c28aaSamw number += 2;
226c8ec8eeaSjose borrego ishex = B_TRUE;
227da6c28aaSamw } else if (*number == '-') {
228c8ec8eeaSjose borrego number++;
229da6c28aaSamw }
230da6c28aaSamw
231c8ec8eeaSjose borrego while (isnum && (*number != '\0')) {
232c8ec8eeaSjose borrego isnum = (ishex) ? isxdigit(*number) : isdigit(*number);
233c8ec8eeaSjose borrego number++;
234da6c28aaSamw }
235c8ec8eeaSjose borrego
236c8ec8eeaSjose borrego return (isnum);
237da6c28aaSamw }
238da6c28aaSamw
239da6c28aaSamw /*
240b89a8333Snatalie li - Sun Microsystems - Irvine United States * check ro vs rw values. Over time this may get beefed up.
241b89a8333Snatalie li - Sun Microsystems - Irvine United States * for now it just does simple checks.
242b89a8333Snatalie li - Sun Microsystems - Irvine United States */
243b89a8333Snatalie li - Sun Microsystems - Irvine United States
244b89a8333Snatalie li - Sun Microsystems - Irvine United States static int
check_rorw(char * v1,char * v2)245b89a8333Snatalie li - Sun Microsystems - Irvine United States check_rorw(char *v1, char *v2)
246b89a8333Snatalie li - Sun Microsystems - Irvine United States {
247b89a8333Snatalie li - Sun Microsystems - Irvine United States int ret = SA_OK;
248b89a8333Snatalie li - Sun Microsystems - Irvine United States if (strcmp(v1, v2) == 0)
249b89a8333Snatalie li - Sun Microsystems - Irvine United States ret = SA_VALUE_CONFLICT;
250b89a8333Snatalie li - Sun Microsystems - Irvine United States return (ret);
251b89a8333Snatalie li - Sun Microsystems - Irvine United States }
252b89a8333Snatalie li - Sun Microsystems - Irvine United States
253b89a8333Snatalie li - Sun Microsystems - Irvine United States /*
254da6c28aaSamw * validresource(name)
255da6c28aaSamw *
256da6c28aaSamw * Check that name only has valid characters in it. The current valid
257da6c28aaSamw * set are the printable characters but not including:
258da6c28aaSamw * " / \ [ ] : | < > + ; , ? * = \t
259da6c28aaSamw * Note that space is included and there is a maximum length.
260da6c28aaSamw */
261c8ec8eeaSjose borrego static boolean_t
validresource(const char * name)262da6c28aaSamw validresource(const char *name)
263da6c28aaSamw {
264da6c28aaSamw const char *cp;
265da6c28aaSamw size_t len;
266da6c28aaSamw
267da6c28aaSamw if (name == NULL)
268da6c28aaSamw return (B_FALSE);
269da6c28aaSamw
270da6c28aaSamw len = strlen(name);
271da6c28aaSamw if (len == 0 || len > SA_MAX_RESOURCE_NAME)
272da6c28aaSamw return (B_FALSE);
273da6c28aaSamw
274da6c28aaSamw if (strpbrk(name, "\"/\\[]:|<>+;,?*=\t") != NULL) {
275da6c28aaSamw return (B_FALSE);
276da6c28aaSamw }
277da6c28aaSamw
278da6c28aaSamw for (cp = name; *cp != '\0'; cp++)
279da6c28aaSamw if (iscntrl(*cp))
280da6c28aaSamw return (B_FALSE);
281da6c28aaSamw
282da6c28aaSamw return (B_TRUE);
283da6c28aaSamw }
284da6c28aaSamw
285da6c28aaSamw /*
2868d7e4166Sjose borrego * Check that the client-side caching (CSC) option value is valid.
2878d7e4166Sjose borrego */
2888d7e4166Sjose borrego static boolean_t
validcsc(const char * value)2898d7e4166Sjose borrego validcsc(const char *value)
2908d7e4166Sjose borrego {
2918d7e4166Sjose borrego int i;
2928d7e4166Sjose borrego
2938d7e4166Sjose borrego for (i = 0; i < (sizeof (cscopt) / sizeof (cscopt[0])); ++i) {
29489dc44ceSjose borrego if (strcasecmp(value, cscopt[i].value) == 0)
2958d7e4166Sjose borrego return (B_TRUE);
2968d7e4166Sjose borrego }
2978d7e4166Sjose borrego
2988d7e4166Sjose borrego return (B_FALSE);
2998d7e4166Sjose borrego }
3008d7e4166Sjose borrego
3018d7e4166Sjose borrego /*
302da6c28aaSamw * smb_isonline()
303da6c28aaSamw *
304da6c28aaSamw * Determine if the SMF service instance is in the online state or
305da6c28aaSamw * not. A number of operations depend on this state.
306da6c28aaSamw */
307da6c28aaSamw static boolean_t
smb_isonline(void)308da6c28aaSamw smb_isonline(void)
309da6c28aaSamw {
310da6c28aaSamw char *str;
311da6c28aaSamw boolean_t ret = B_FALSE;
312da6c28aaSamw
313da6c28aaSamw if ((str = smf_get_state(SMBD_DEFAULT_INSTANCE_FMRI)) != NULL) {
314da6c28aaSamw ret = (strcmp(str, SCF_STATE_STRING_ONLINE) == 0);
315da6c28aaSamw free(str);
316da6c28aaSamw }
317da6c28aaSamw return (ret);
318da6c28aaSamw }
319da6c28aaSamw
320da6c28aaSamw /*
321dc20a302Sas200622 * smb_isdisabled()
322dc20a302Sas200622 *
323dc20a302Sas200622 * Determine if the SMF service instance is in the disabled state or
324dc20a302Sas200622 * not. A number of operations depend on this state.
325dc20a302Sas200622 */
326dc20a302Sas200622 static boolean_t
smb_isdisabled(void)327dc20a302Sas200622 smb_isdisabled(void)
328dc20a302Sas200622 {
329dc20a302Sas200622 char *str;
330dc20a302Sas200622 boolean_t ret = B_FALSE;
331dc20a302Sas200622
332dc20a302Sas200622 if ((str = smf_get_state(SMBD_DEFAULT_INSTANCE_FMRI)) != NULL) {
333dc20a302Sas200622 ret = (strcmp(str, SCF_STATE_STRING_DISABLED) == 0);
334dc20a302Sas200622 free(str);
335dc20a302Sas200622 }
336dc20a302Sas200622 return (ret);
337dc20a302Sas200622 }
338dc20a302Sas200622
339dc20a302Sas200622 /*
340dc20a302Sas200622 * smb_isautoenable()
341dc20a302Sas200622 *
342dc20a302Sas200622 * Determine if the SMF service instance auto_enabled set or not. A
343dc20a302Sas200622 * number of operations depend on this state. The property not being
344dc20a302Sas200622 * set or being set to true means autoenable. Only being set to false
345dc20a302Sas200622 * is not autoenabled.
346dc20a302Sas200622 */
347dc20a302Sas200622 static boolean_t
smb_isautoenable(void)348dc20a302Sas200622 smb_isautoenable(void)
349dc20a302Sas200622 {
350dc20a302Sas200622 boolean_t ret = B_TRUE;
351dc20a302Sas200622 scf_simple_prop_t *prop;
352dc20a302Sas200622 uint8_t *retstr;
353dc20a302Sas200622
354dc20a302Sas200622 prop = scf_simple_prop_get(NULL, SMBD_DEFAULT_INSTANCE_FMRI,
355dc20a302Sas200622 "application", "auto_enable");
356dc20a302Sas200622 if (prop != NULL) {
357dc20a302Sas200622 retstr = scf_simple_prop_next_boolean(prop);
358dc20a302Sas200622 ret = *retstr != 0;
359dc20a302Sas200622 scf_simple_prop_free(prop);
360dc20a302Sas200622 }
361dc20a302Sas200622 return (ret);
362dc20a302Sas200622 }
363dc20a302Sas200622
364dc20a302Sas200622 /*
3657b59d02dSjb150015 * smb_ismaint()
3667b59d02dSjb150015 *
3677b59d02dSjb150015 * Determine if the SMF service instance is in the disabled state or
3687b59d02dSjb150015 * not. A number of operations depend on this state.
3697b59d02dSjb150015 */
3707b59d02dSjb150015 static boolean_t
smb_ismaint(void)3717b59d02dSjb150015 smb_ismaint(void)
3727b59d02dSjb150015 {
3737b59d02dSjb150015 char *str;
3747b59d02dSjb150015 boolean_t ret = B_FALSE;
3757b59d02dSjb150015
3767b59d02dSjb150015 if ((str = smf_get_state(SMBD_DEFAULT_INSTANCE_FMRI)) != NULL) {
3777b59d02dSjb150015 ret = (strcmp(str, SCF_STATE_STRING_MAINT) == 0);
3787b59d02dSjb150015 free(str);
3797b59d02dSjb150015 }
3807b59d02dSjb150015 return (ret);
3817b59d02dSjb150015 }
3827b59d02dSjb150015
3837b59d02dSjb150015 /*
384da6c28aaSamw * smb_enable_share tells the implementation that it is to enable the share.
385da6c28aaSamw * This entails converting the path and options into the appropriate ioctl
386da6c28aaSamw * calls. It is assumed that all error checking of paths, etc. were
387da6c28aaSamw * done earlier.
388da6c28aaSamw */
389da6c28aaSamw static int
smb_enable_share(sa_share_t share)390da6c28aaSamw smb_enable_share(sa_share_t share)
391da6c28aaSamw {
392da6c28aaSamw char *path;
3933db3f65cSamw smb_share_t si;
394da6c28aaSamw sa_resource_t resource;
395da6c28aaSamw boolean_t iszfs;
396da6c28aaSamw int err = SA_OK;
397da6c28aaSamw boolean_t online;
398da6c28aaSamw
399f85463f2Sdougm /*
4008622ec45SGordon Ross * Don't support Trusted Extensions.
401f85463f2Sdougm */
402f85463f2Sdougm if (is_system_labeled()) {
403f85463f2Sdougm (void) printf(dgettext(TEXT_DOMAIN,
404f85463f2Sdougm "SMB: service not supported with Trusted Extensions\n"));
405f85463f2Sdougm return (SA_NOT_SUPPORTED);
406f85463f2Sdougm }
407f85463f2Sdougm
408da6c28aaSamw /* get the path since it is important in several places */
409da6c28aaSamw path = sa_get_share_attr(share, "path");
410da6c28aaSamw if (path == NULL)
411da6c28aaSamw return (SA_NO_SUCH_PATH);
412da6c28aaSamw
413dc20a302Sas200622 /*
414dc20a302Sas200622 * If administratively disabled, don't try to start anything.
415dc20a302Sas200622 */
416da6c28aaSamw online = smb_isonline();
417dc20a302Sas200622 if (!online && !smb_isautoenable() && smb_isdisabled())
418dc20a302Sas200622 goto done;
419da6c28aaSamw
420da6c28aaSamw iszfs = sa_path_is_zfs(path);
421da6c28aaSamw
422da6c28aaSamw if (!online) {
423da6c28aaSamw err = smb_enable_service();
424da6c28aaSamw if (err != SA_OK) {
425da6c28aaSamw (void) printf(dgettext(TEXT_DOMAIN,
426da6c28aaSamw "SMB: Unable to enable service\n"));
427da6c28aaSamw } else {
428da6c28aaSamw online = B_TRUE;
429da6c28aaSamw }
430da6c28aaSamw }
431da6c28aaSamw
432da6c28aaSamw /*
433da6c28aaSamw * Don't bother trying to start shares if the service isn't
434da6c28aaSamw * running.
435da6c28aaSamw */
436da6c28aaSamw if (!online)
437da6c28aaSamw goto done;
438da6c28aaSamw
439da6c28aaSamw /* Each share can have multiple resources */
440da6c28aaSamw for (resource = sa_get_share_resource(share, NULL);
441da6c28aaSamw resource != NULL;
442da6c28aaSamw resource = sa_get_next_resource(resource)) {
443c8ec8eeaSjose borrego err = smb_build_shareinfo(share, resource, &si);
444c8ec8eeaSjose borrego if (err != SA_OK) {
445da6c28aaSamw sa_free_attr_string(path);
446c8ec8eeaSjose borrego return (err);
447da6c28aaSamw }
448da6c28aaSamw
449da6c28aaSamw if (!iszfs) {
450c8ec8eeaSjose borrego err = smb_share_create(&si);
451da6c28aaSamw } else {
452da6c28aaSamw share_t sh;
453da6c28aaSamw
4545ad42b1bSSurya Prakki (void) sa_sharetab_fill_zfs(share, &sh, "smb");
455743a77edSAlan Wright err = sa_share_zfs(share, resource, (char *)path, &sh,
456da6c28aaSamw &si, ZFS_SHARE_SMB);
457a63214d6SBill Krier if (err != SA_OK) {
458a63214d6SBill Krier errno = err;
459a63214d6SBill Krier err = -1;
460a63214d6SBill Krier }
461da6c28aaSamw sa_emptyshare(&sh);
462da6c28aaSamw }
463da6c28aaSamw }
464da6c28aaSamw if (!iszfs)
465da6c28aaSamw (void) sa_update_sharetab(share, "smb");
466da6c28aaSamw done:
467da6c28aaSamw sa_free_attr_string(path);
468da6c28aaSamw
469da6c28aaSamw return (err == NERR_DuplicateShare ? 0 : err);
470da6c28aaSamw }
471da6c28aaSamw
472da6c28aaSamw /*
473da6c28aaSamw * This is the share for CIFS all shares have resource names.
474da6c28aaSamw * Enable tells the smb server to update its hash. If it fails
475da6c28aaSamw * because smb server is down, we just ignore as smb server loads
476da6c28aaSamw * the resources from sharemanager at startup.
477da6c28aaSamw */
478da6c28aaSamw
479da6c28aaSamw static int
smb_enable_resource(sa_resource_t resource)480da6c28aaSamw smb_enable_resource(sa_resource_t resource)
481da6c28aaSamw {
482da6c28aaSamw sa_share_t share;
4833db3f65cSamw smb_share_t si;
484dc20a302Sas200622 int ret = SA_OK;
485dc20a302Sas200622 int err;
486dc20a302Sas200622 boolean_t isonline;
487da6c28aaSamw
488da6c28aaSamw share = sa_get_resource_parent(resource);
489da6c28aaSamw if (share == NULL)
490da6c28aaSamw return (SA_NO_SUCH_PATH);
491dc20a302Sas200622
492dc20a302Sas200622 /*
493dc20a302Sas200622 * If administratively disabled, don't try to start anything.
494dc20a302Sas200622 */
495dc20a302Sas200622 isonline = smb_isonline();
496dc20a302Sas200622 if (!isonline && !smb_isautoenable() && smb_isdisabled())
497c8ec8eeaSjose borrego return (SA_OK);
498dc20a302Sas200622
499c8ec8eeaSjose borrego if (!isonline) {
500c8ec8eeaSjose borrego (void) smb_enable_service();
501c8ec8eeaSjose borrego
502c8ec8eeaSjose borrego if (!smb_isonline())
503c8ec8eeaSjose borrego return (SA_OK);
504dc20a302Sas200622 }
505dc20a302Sas200622
506c8ec8eeaSjose borrego if ((ret = smb_build_shareinfo(share, resource, &si)) != SA_OK)
507c8ec8eeaSjose borrego return (ret);
508dc20a302Sas200622
509dc20a302Sas200622 /*
510dc20a302Sas200622 * Attempt to add the share. Any error that occurs if it was
511dc20a302Sas200622 * online is an error but don't count NERR_DuplicateName if
512dc20a302Sas200622 * smb/server had to be brought online since bringing the
513dc20a302Sas200622 * service up will enable the share that was just added prior
514dc20a302Sas200622 * to the attempt to enable.
515dc20a302Sas200622 */
516c8ec8eeaSjose borrego err = smb_share_create(&si);
517dc20a302Sas200622 if (err == NERR_Success || !(!isonline && err == NERR_DuplicateName))
518da6c28aaSamw (void) sa_update_sharetab(share, "smb");
519dc20a302Sas200622 else
520dc20a302Sas200622 return (SA_NOT_SHARED);
521da6c28aaSamw
522c8ec8eeaSjose borrego return (SA_OK);
523da6c28aaSamw }
524da6c28aaSamw
525da6c28aaSamw /*
526da6c28aaSamw * Remove it from smb server hash.
527da6c28aaSamw */
528da6c28aaSamw static int
smb_disable_resource(sa_resource_t resource)529da6c28aaSamw smb_disable_resource(sa_resource_t resource)
530da6c28aaSamw {
531da6c28aaSamw char *rname;
5323db3f65cSamw uint32_t res;
533da6c28aaSamw sa_share_t share;
534da6c28aaSamw
535da6c28aaSamw rname = sa_get_resource_attr(resource, "name");
536da6c28aaSamw if (rname == NULL)
537da6c28aaSamw return (SA_NO_SUCH_RESOURCE);
538da6c28aaSamw
539da6c28aaSamw if (smb_isonline()) {
540c8ec8eeaSjose borrego res = smb_share_delete(rname);
541fe1c642dSBill Krier if (res != NERR_Success &&
542fe1c642dSBill Krier res != NERR_NetNameNotFound) {
543da6c28aaSamw sa_free_attr_string(rname);
544da6c28aaSamw return (SA_CONFIG_ERR);
545da6c28aaSamw }
546da6c28aaSamw }
5475b6e0c46Sdougm
5485b6e0c46Sdougm sa_free_attr_string(rname);
5495b6e0c46Sdougm
550da6c28aaSamw share = sa_get_resource_parent(resource);
551da6c28aaSamw if (share != NULL) {
552da6c28aaSamw rname = sa_get_share_attr(share, "path");
553da6c28aaSamw if (rname != NULL) {
5545b6e0c46Sdougm sa_handle_t handle;
5555b6e0c46Sdougm
5565b6e0c46Sdougm handle = sa_find_group_handle((sa_group_t)resource);
5575b6e0c46Sdougm (void) sa_delete_sharetab(handle, rname, "smb");
558da6c28aaSamw sa_free_attr_string(rname);
559da6c28aaSamw }
560da6c28aaSamw }
561da6c28aaSamw /*
562da6c28aaSamw * Always return OK as smb/server may be down and
563da6c28aaSamw * Shares will be picked up when loaded.
564da6c28aaSamw */
565da6c28aaSamw return (SA_OK);
566da6c28aaSamw }
567da6c28aaSamw
568da6c28aaSamw /*
569da6c28aaSamw * smb_share_changed(sa_share_t share)
570da6c28aaSamw *
571da6c28aaSamw * The specified share has changed.
572da6c28aaSamw */
573da6c28aaSamw static int
smb_share_changed(sa_share_t share)574da6c28aaSamw smb_share_changed(sa_share_t share)
575da6c28aaSamw {
576da6c28aaSamw char *path;
577da6c28aaSamw sa_resource_t resource;
578da6c28aaSamw
579c8ec8eeaSjose borrego if (!smb_isonline())
580c8ec8eeaSjose borrego return (SA_OK);
581c8ec8eeaSjose borrego
582da6c28aaSamw /* get the path since it is important in several places */
583da6c28aaSamw path = sa_get_share_attr(share, "path");
584da6c28aaSamw if (path == NULL)
585da6c28aaSamw return (SA_NO_SUCH_PATH);
586c8ec8eeaSjose borrego
587da6c28aaSamw for (resource = sa_get_share_resource(share, NULL);
588da6c28aaSamw resource != NULL;
589da6c28aaSamw resource = sa_get_next_resource(resource))
590da6c28aaSamw (void) smb_resource_changed(resource);
591da6c28aaSamw
592da6c28aaSamw sa_free_attr_string(path);
593da6c28aaSamw
594da6c28aaSamw return (SA_OK);
595da6c28aaSamw }
596da6c28aaSamw
597da6c28aaSamw /*
598da6c28aaSamw * smb_resource_changed(sa_resource_t resource)
599da6c28aaSamw *
600da6c28aaSamw * The specified resource has changed.
601da6c28aaSamw */
602da6c28aaSamw static int
smb_resource_changed(sa_resource_t resource)603da6c28aaSamw smb_resource_changed(sa_resource_t resource)
604da6c28aaSamw {
6053db3f65cSamw uint32_t res;
606da6c28aaSamw sa_share_t share;
607c8ec8eeaSjose borrego smb_share_t si;
608da6c28aaSamw
609c8ec8eeaSjose borrego if (!smb_isonline())
610da6c28aaSamw return (SA_OK);
611da6c28aaSamw
612c8ec8eeaSjose borrego if ((share = sa_get_resource_parent(resource)) == NULL)
613da6c28aaSamw return (SA_CONFIG_ERR);
614da6c28aaSamw
615c8ec8eeaSjose borrego if ((res = smb_build_shareinfo(share, resource, &si)) != SA_OK)
616c8ec8eeaSjose borrego return (res);
617da6c28aaSamw
618b89a8333Snatalie li - Sun Microsystems - Irvine United States res = smb_share_modify(&si);
619c8ec8eeaSjose borrego
620c8ec8eeaSjose borrego if (res != NERR_Success)
621da6c28aaSamw return (SA_CONFIG_ERR);
622c8ec8eeaSjose borrego
623da6c28aaSamw return (smb_enable_service());
624da6c28aaSamw }
625da6c28aaSamw
626da6c28aaSamw /*
6278e314a44Sdougm * smb_disable_share(sa_share_t share, char *path)
628da6c28aaSamw *
6298e314a44Sdougm * Unshare the specified share. Note that "path" is the same
6308e314a44Sdougm * path as what is in the "share" object. It is passed in to avoid an
6318e314a44Sdougm * additional lookup. A missing "path" value makes this a no-op
6328e314a44Sdougm * function.
633da6c28aaSamw */
634da6c28aaSamw static int
smb_disable_share(sa_share_t share,char * path)635da6c28aaSamw smb_disable_share(sa_share_t share, char *path)
636da6c28aaSamw {
637da6c28aaSamw char *rname;
638da6c28aaSamw sa_resource_t resource;
6398e314a44Sdougm sa_group_t parent;
640da6c28aaSamw boolean_t iszfs;
641da6c28aaSamw int err = SA_OK;
642a63214d6SBill Krier int ret = SA_OK;
6435b6e0c46Sdougm sa_handle_t handle;
6441f713840SDoug McCallum boolean_t first = B_TRUE; /* work around sharetab issue */
645da6c28aaSamw
6468e314a44Sdougm if (path == NULL)
647a63214d6SBill Krier return (ret);
6488e314a44Sdougm
6498e314a44Sdougm /*
6508e314a44Sdougm * If the share is in a ZFS group we need to handle it
6518e314a44Sdougm * differently. Just being on a ZFS file system isn't
6528e314a44Sdougm * enough since we may be in a legacy share case.
6538e314a44Sdougm */
6548e314a44Sdougm parent = sa_get_parent_group(share);
6558e314a44Sdougm iszfs = sa_group_is_zfs(parent);
6568e314a44Sdougm
657da6c28aaSamw if (!smb_isonline())
658da6c28aaSamw goto done;
659da6c28aaSamw
660da6c28aaSamw for (resource = sa_get_share_resource(share, NULL);
661a63214d6SBill Krier resource != NULL;
662da6c28aaSamw resource = sa_get_next_resource(resource)) {
663da6c28aaSamw rname = sa_get_resource_attr(resource, "name");
664da6c28aaSamw if (rname == NULL) {
665da6c28aaSamw continue;
666da6c28aaSamw }
667da6c28aaSamw if (!iszfs) {
668c8ec8eeaSjose borrego err = smb_share_delete(rname);
669da6c28aaSamw switch (err) {
670da6c28aaSamw case NERR_NetNameNotFound:
671da6c28aaSamw case NERR_Success:
672da6c28aaSamw err = SA_OK;
673da6c28aaSamw break;
674da6c28aaSamw default:
675da6c28aaSamw err = SA_CONFIG_ERR;
676da6c28aaSamw break;
677da6c28aaSamw }
678da6c28aaSamw } else {
679da6c28aaSamw share_t sh;
680da6c28aaSamw
6815ad42b1bSSurya Prakki (void) sa_sharetab_fill_zfs(share, &sh, "smb");
682743a77edSAlan Wright err = sa_share_zfs(share, resource, (char *)path, &sh,
683da6c28aaSamw rname, ZFS_UNSHARE_SMB);
684a63214d6SBill Krier if (err != SA_OK) {
685a63214d6SBill Krier switch (err) {
686a63214d6SBill Krier case EINVAL:
687a63214d6SBill Krier case ENOENT:
6881f713840SDoug McCallum err = SA_OK;
689a63214d6SBill Krier break;
690a63214d6SBill Krier default:
691a63214d6SBill Krier /*
692a63214d6SBill Krier * If we are no longer the first case,
693a63214d6SBill Krier * we don't care about the sa_share_zfs
694a63214d6SBill Krier * err if it is -1. This works around
695a63214d6SBill Krier * a problem in sharefs and should be
696a63214d6SBill Krier * removed when sharefs supports
697a63214d6SBill Krier * multiple entries per path.
698a63214d6SBill Krier */
699a63214d6SBill Krier if (!first)
700a63214d6SBill Krier err = SA_OK;
701a63214d6SBill Krier else
702a63214d6SBill Krier err = SA_SYSTEM_ERR;
703a63214d6SBill Krier break;
704a63214d6SBill Krier }
705a63214d6SBill Krier }
706a63214d6SBill Krier
7071f713840SDoug McCallum first = B_FALSE;
7081f713840SDoug McCallum
709da6c28aaSamw sa_emptyshare(&sh);
710da6c28aaSamw }
711a63214d6SBill Krier
712a63214d6SBill Krier if (err != SA_OK)
713a63214d6SBill Krier ret = err;
714da6c28aaSamw sa_free_attr_string(rname);
715da6c28aaSamw }
716da6c28aaSamw done:
7175b6e0c46Sdougm if (!iszfs) {
7185b6e0c46Sdougm handle = sa_find_group_handle((sa_group_t)share);
7195b6e0c46Sdougm if (handle != NULL)
7205b6e0c46Sdougm (void) sa_delete_sharetab(handle, path, "smb");
7215b6e0c46Sdougm else
722a63214d6SBill Krier ret = SA_SYSTEM_ERR;
7235b6e0c46Sdougm }
724a63214d6SBill Krier return (ret);
725da6c28aaSamw }
726da6c28aaSamw
727da6c28aaSamw /*
728687915e9Sdougm * smb_validate_property(handle, property, parent)
729da6c28aaSamw *
730da6c28aaSamw * Check that the property has a legitimate value for its type.
731687915e9Sdougm * Handle isn't currently used but may need to be in the future.
732da6c28aaSamw */
733da6c28aaSamw
734687915e9Sdougm /*ARGSUSED*/
735da6c28aaSamw static int
smb_validate_property(sa_handle_t handle,sa_property_t property,sa_optionset_t parent)736687915e9Sdougm smb_validate_property(sa_handle_t handle, sa_property_t property,
737687915e9Sdougm sa_optionset_t parent)
738da6c28aaSamw {
739da6c28aaSamw int ret = SA_OK;
740da6c28aaSamw char *propname;
741da6c28aaSamw int optindex;
742da6c28aaSamw sa_group_t parent_group;
743da6c28aaSamw char *value;
744b89a8333Snatalie li - Sun Microsystems - Irvine United States char *other;
745da6c28aaSamw
746da6c28aaSamw propname = sa_get_property_attr(property, "type");
747da6c28aaSamw
748da6c28aaSamw if ((optindex = findopt(propname)) < 0)
749da6c28aaSamw ret = SA_NO_SUCH_PROP;
750da6c28aaSamw
751da6c28aaSamw /* need to validate value range here as well */
752da6c28aaSamw if (ret == SA_OK) {
753da6c28aaSamw parent_group = sa_get_parent_group((sa_share_t)parent);
754da6c28aaSamw if (optdefs[optindex].share && !sa_is_share(parent_group))
755da6c28aaSamw ret = SA_PROP_SHARE_ONLY;
756da6c28aaSamw }
757da6c28aaSamw if (ret != SA_OK) {
758da6c28aaSamw if (propname != NULL)
759da6c28aaSamw sa_free_attr_string(propname);
760da6c28aaSamw return (ret);
761da6c28aaSamw }
762da6c28aaSamw
763da6c28aaSamw value = sa_get_property_attr(property, "value");
764da6c28aaSamw if (value != NULL) {
765da6c28aaSamw /* first basic type checking */
766da6c28aaSamw switch (optdefs[optindex].type) {
767da6c28aaSamw case OPT_TYPE_NUMBER:
768da6c28aaSamw /* check that the value is all digits */
769da6c28aaSamw if (!is_a_number(value))
770da6c28aaSamw ret = SA_BAD_VALUE;
771da6c28aaSamw break;
772da6c28aaSamw case OPT_TYPE_BOOLEAN:
77329bd2886SAlan Wright ret = true_false_validator(0, value);
774da6c28aaSamw break;
775da6c28aaSamw case OPT_TYPE_NAME:
776da6c28aaSamw /*
777da6c28aaSamw * Make sure no invalid characters
778da6c28aaSamw */
77929bd2886SAlan Wright if (!validresource(value))
780da6c28aaSamw ret = SA_BAD_VALUE;
781da6c28aaSamw break;
782da6c28aaSamw case OPT_TYPE_STRING:
783da6c28aaSamw /* whatever is here should be ok */
784da6c28aaSamw break;
7858d7e4166Sjose borrego case OPT_TYPE_CSC:
78629bd2886SAlan Wright if (!validcsc(value))
7878d7e4166Sjose borrego ret = SA_BAD_VALUE;
7888d7e4166Sjose borrego break;
789b89a8333Snatalie li - Sun Microsystems - Irvine United States case OPT_TYPE_ACCLIST: {
790b89a8333Snatalie li - Sun Microsystems - Irvine United States sa_property_t oprop;
791b89a8333Snatalie li - Sun Microsystems - Irvine United States char *ovalue;
792b89a8333Snatalie li - Sun Microsystems - Irvine United States /*
793b89a8333Snatalie li - Sun Microsystems - Irvine United States * access list handling. Should eventually
794b89a8333Snatalie li - Sun Microsystems - Irvine United States * validate that all the values make sense.
795b89a8333Snatalie li - Sun Microsystems - Irvine United States * Also, ro and rw may have cross value
796b89a8333Snatalie li - Sun Microsystems - Irvine United States * conflicts.
797b89a8333Snatalie li - Sun Microsystems - Irvine United States */
798b89a8333Snatalie li - Sun Microsystems - Irvine United States if (parent == NULL)
799b89a8333Snatalie li - Sun Microsystems - Irvine United States break;
800b89a8333Snatalie li - Sun Microsystems - Irvine United States if (strcmp(propname, SHOPT_RO) == 0)
801b89a8333Snatalie li - Sun Microsystems - Irvine United States other = SHOPT_RW;
802b89a8333Snatalie li - Sun Microsystems - Irvine United States else if (strcmp(propname, SHOPT_RW) == 0)
803b89a8333Snatalie li - Sun Microsystems - Irvine United States other = SHOPT_RO;
804b89a8333Snatalie li - Sun Microsystems - Irvine United States else
805b89a8333Snatalie li - Sun Microsystems - Irvine United States other = NULL;
806b89a8333Snatalie li - Sun Microsystems - Irvine United States if (other == NULL)
807b89a8333Snatalie li - Sun Microsystems - Irvine United States break;
808b89a8333Snatalie li - Sun Microsystems - Irvine United States
809b89a8333Snatalie li - Sun Microsystems - Irvine United States /* compare rw(ro) with ro(rw) */
810b89a8333Snatalie li - Sun Microsystems - Irvine United States oprop = sa_get_property(parent, other);
811b89a8333Snatalie li - Sun Microsystems - Irvine United States if (oprop == NULL)
812b89a8333Snatalie li - Sun Microsystems - Irvine United States break;
813b89a8333Snatalie li - Sun Microsystems - Irvine United States /*
814b89a8333Snatalie li - Sun Microsystems - Irvine United States * only potential
815b89a8333Snatalie li - Sun Microsystems - Irvine United States * confusion if other
816b89a8333Snatalie li - Sun Microsystems - Irvine United States * exists
817b89a8333Snatalie li - Sun Microsystems - Irvine United States */
818b89a8333Snatalie li - Sun Microsystems - Irvine United States ovalue = sa_get_property_attr(oprop, "value");
819b89a8333Snatalie li - Sun Microsystems - Irvine United States if (ovalue != NULL) {
820b89a8333Snatalie li - Sun Microsystems - Irvine United States ret = check_rorw(value, ovalue);
821b89a8333Snatalie li - Sun Microsystems - Irvine United States sa_free_attr_string(ovalue);
822b89a8333Snatalie li - Sun Microsystems - Irvine United States }
823b89a8333Snatalie li - Sun Microsystems - Irvine United States break;
824b89a8333Snatalie li - Sun Microsystems - Irvine United States }
825da6c28aaSamw default:
826da6c28aaSamw break;
827da6c28aaSamw }
828da6c28aaSamw }
829da6c28aaSamw
830da6c28aaSamw if (value != NULL)
831da6c28aaSamw sa_free_attr_string(value);
832da6c28aaSamw if (ret == SA_OK && optdefs[optindex].check != NULL)
833da6c28aaSamw /* do the property specific check */
834da6c28aaSamw ret = optdefs[optindex].check(property);
835da6c28aaSamw
836da6c28aaSamw if (propname != NULL)
837da6c28aaSamw sa_free_attr_string(propname);
838da6c28aaSamw return (ret);
839da6c28aaSamw }
840da6c28aaSamw
841da6c28aaSamw /*
842da6c28aaSamw * Protocol management functions
843da6c28aaSamw *
844da6c28aaSamw * properties defined in the default files are defined in
845da6c28aaSamw * proto_option_defs for parsing and validation.
846da6c28aaSamw */
847da6c28aaSamw
848da6c28aaSamw struct smb_proto_option_defs {
849da6c28aaSamw int smb_index;
850da6c28aaSamw int32_t minval;
851da6c28aaSamw int32_t maxval; /* In case of length of string this should be max */
852da6c28aaSamw int (*validator)(int, char *);
853da6c28aaSamw int32_t refresh;
854da6c28aaSamw } smb_proto_options[] = {
855dc20a302Sas200622 { SMB_CI_SYS_CMNT, 0, MAX_VALUE_BUFLEN,
856da6c28aaSamw string_length_check_validator, SMB_REFRESH_REFRESH },
857a90cf9f2SGordon Ross { SMB_CI_MAX_WORKERS, SMB_PI_MAX_WORKERS_MIN, SMB_PI_MAX_WORKERS_MAX,
858a90cf9f2SGordon Ross range_check_validator, SMB_REFRESH_REFRESH },
859a90cf9f2SGordon Ross { SMB_CI_NETBIOS_ENABLE, 0, 0, true_false_validator,
860da6c28aaSamw SMB_REFRESH_REFRESH },
861dc20a302Sas200622 { SMB_CI_NBSCOPE, 0, MAX_VALUE_BUFLEN,
862dc20a302Sas200622 string_length_check_validator, 0 },
863dc20a302Sas200622 { SMB_CI_LM_LEVEL, 2, 5, range_check_validator, 0 },
864dc20a302Sas200622 { SMB_CI_KEEPALIVE, 20, 5400, range_check_validator_zero_ok,
865da6c28aaSamw SMB_REFRESH_REFRESH },
866dc20a302Sas200622 { SMB_CI_WINS_SRV1, 0, MAX_VALUE_BUFLEN,
86729bd2886SAlan Wright ipv4_validator, SMB_REFRESH_REFRESH },
868dc20a302Sas200622 { SMB_CI_WINS_SRV2, 0, MAX_VALUE_BUFLEN,
86929bd2886SAlan Wright ipv4_validator, SMB_REFRESH_REFRESH },
870dc20a302Sas200622 { SMB_CI_WINS_EXCL, 0, MAX_VALUE_BUFLEN,
8718d7e4166Sjose borrego interface_validator, SMB_REFRESH_REFRESH },
872dc20a302Sas200622 { SMB_CI_SIGNING_ENABLE, 0, 0, true_false_validator,
873da6c28aaSamw SMB_REFRESH_REFRESH },
874dc20a302Sas200622 { SMB_CI_SIGNING_REQD, 0, 0, true_false_validator,
875da6c28aaSamw SMB_REFRESH_REFRESH },
876dc20a302Sas200622 { SMB_CI_RESTRICT_ANON, 0, 0, true_false_validator,
877da6c28aaSamw SMB_REFRESH_REFRESH },
878dc20a302Sas200622 { SMB_CI_DOMAIN_SRV, 0, MAX_VALUE_BUFLEN,
87996a62adaSjoyce mcintosh hostname_validator, SMB_REFRESH_REFRESH },
880dc20a302Sas200622 { SMB_CI_ADS_SITE, 0, MAX_VALUE_BUFLEN,
881da6c28aaSamw string_length_check_validator, SMB_REFRESH_REFRESH },
882dc20a302Sas200622 { SMB_CI_DYNDNS_ENABLE, 0, 0, true_false_validator, 0 },
883dc20a302Sas200622 { SMB_CI_AUTOHOME_MAP, 0, MAX_VALUE_BUFLEN, path_validator, 0 },
8847f667e74Sjose borrego { SMB_CI_IPV6_ENABLE, 0, 0, true_false_validator,
8857f667e74Sjose borrego SMB_REFRESH_REFRESH },
88686d7016bSGordon Ross { SMB_CI_PRINT_ENABLE, 0, 0, print_enable_validator,
887cb174861Sjoyce mcintosh SMB_REFRESH_REFRESH },
8885f1ef25cSAram Hăvărneanu { SMB_CI_TRAVERSE_MOUNTS, 0, 0, true_false_validator,
8895f1ef25cSAram Hăvărneanu SMB_REFRESH_REFRESH },
89029bd2886SAlan Wright { SMB_CI_MAP, 0, MAX_VALUE_BUFLEN, cmd_validator, SMB_REFRESH_REFRESH },
89129bd2886SAlan Wright { SMB_CI_UNMAP, 0, MAX_VALUE_BUFLEN, cmd_validator,
89229bd2886SAlan Wright SMB_REFRESH_REFRESH },
89329bd2886SAlan Wright { SMB_CI_DISPOSITION, 0, MAX_VALUE_BUFLEN,
89429bd2886SAlan Wright disposition_validator, SMB_REFRESH_REFRESH },
89576b0ca5aSGordon Ross { SMB_CI_MIN_PROTOCOL, 0, MAX_VALUE_BUFLEN, protocol_validator,
89676b0ca5aSGordon Ross SMB_REFRESH_REFRESH },
8973e2c0c09SMatt Barden { SMB_CI_MAX_PROTOCOL, 0, MAX_VALUE_BUFLEN, protocol_validator,
89883d2dfe6SGordon Ross SMB_REFRESH_REFRESH },
8991160dcf7SMatt Barden { SMB_CI_ENCRYPT, 0, MAX_VALUE_BUFLEN, require_validator,
9001160dcf7SMatt Barden SMB_REFRESH_REFRESH },
901b0bb0d63SGordon Ross { SMB_CI_ENCRYPT_CIPHERS, 0, MAX_VALUE_BUFLEN, ciphers_validator,
902b0bb0d63SGordon Ross SMB_REFRESH_REFRESH },
903cc3780e6SGordon Ross { SMB_CI_BYPASS_TRAVERSE_CHECKING, 0, 0, true_false_validator,
904cc3780e6SGordon Ross SMB_REFRESH_REFRESH },
90594047d49SGordon Ross { SMB_CI_OPLOCK_ENABLE, 0, 0, true_false_validator,
90694047d49SGordon Ross SMB_REFRESH_REFRESH },
907814e0daaSGordon Ross { SMB_CI_SHORT_NAMES, 0, 0, true_false_validator,
908814e0daaSGordon Ross SMB_REFRESH_REFRESH },
909da6c28aaSamw };
910da6c28aaSamw
911dc20a302Sas200622 #define SMB_OPT_NUM \
912dc20a302Sas200622 (sizeof (smb_proto_options) / sizeof (smb_proto_options[0]))
913dc20a302Sas200622
9141160dcf7SMatt Barden static int
require_validator(int index,char * value)9151160dcf7SMatt Barden require_validator(int index, char *value)
9161160dcf7SMatt Barden {
9171160dcf7SMatt Barden if (string_length_check_validator(index, value) != SA_OK)
9181160dcf7SMatt Barden return (SA_BAD_VALUE);
9191160dcf7SMatt Barden
9201160dcf7SMatt Barden if (strcmp(value, "required") == 0)
9211160dcf7SMatt Barden return (SA_OK);
9221160dcf7SMatt Barden
9231160dcf7SMatt Barden if (strcmp(value, "disabled") == 0)
9241160dcf7SMatt Barden return (SA_OK);
9251160dcf7SMatt Barden
9261160dcf7SMatt Barden if (strcmp(value, "enabled") == 0)
9271160dcf7SMatt Barden return (SA_OK);
9281160dcf7SMatt Barden
9291160dcf7SMatt Barden return (SA_BAD_VALUE);
9301160dcf7SMatt Barden }
9311160dcf7SMatt Barden
932da6c28aaSamw /*
933da6c28aaSamw * Check the range of value as int range.
934da6c28aaSamw */
935da6c28aaSamw static int
range_check_validator(int index,char * value)936da6c28aaSamw range_check_validator(int index, char *value)
937da6c28aaSamw {
938da6c28aaSamw int ret = SA_OK;
939da6c28aaSamw
940da6c28aaSamw if (!is_a_number(value)) {
941da6c28aaSamw ret = SA_BAD_VALUE;
942da6c28aaSamw } else {
943da6c28aaSamw int val;
944da6c28aaSamw val = strtoul(value, NULL, 0);
945da6c28aaSamw if (val < smb_proto_options[index].minval ||
946da6c28aaSamw val > smb_proto_options[index].maxval)
947da6c28aaSamw ret = SA_BAD_VALUE;
948da6c28aaSamw }
949da6c28aaSamw return (ret);
950da6c28aaSamw }
951da6c28aaSamw
952da6c28aaSamw /*
953da6c28aaSamw * Check the range of value as int range.
954da6c28aaSamw */
955da6c28aaSamw static int
range_check_validator_zero_ok(int index,char * value)956da6c28aaSamw range_check_validator_zero_ok(int index, char *value)
957da6c28aaSamw {
958da6c28aaSamw int ret = SA_OK;
959da6c28aaSamw
960da6c28aaSamw if (!is_a_number(value)) {
961da6c28aaSamw ret = SA_BAD_VALUE;
962da6c28aaSamw } else {
963da6c28aaSamw int val;
964da6c28aaSamw val = strtoul(value, NULL, 0);
965da6c28aaSamw if (val == 0)
966da6c28aaSamw ret = SA_OK;
967da6c28aaSamw else {
968da6c28aaSamw if (val < smb_proto_options[index].minval ||
969da6c28aaSamw val > smb_proto_options[index].maxval)
970da6c28aaSamw ret = SA_BAD_VALUE;
971da6c28aaSamw }
972da6c28aaSamw }
973da6c28aaSamw return (ret);
974da6c28aaSamw }
975da6c28aaSamw
976da6c28aaSamw /*
977da6c28aaSamw * Check the length of the string
978da6c28aaSamw */
979da6c28aaSamw static int
string_length_check_validator(int index,char * value)980da6c28aaSamw string_length_check_validator(int index, char *value)
981da6c28aaSamw {
982da6c28aaSamw int ret = SA_OK;
983da6c28aaSamw
984da6c28aaSamw if (value == NULL)
985da6c28aaSamw return (SA_BAD_VALUE);
986da6c28aaSamw if (strlen(value) > smb_proto_options[index].maxval)
987da6c28aaSamw ret = SA_BAD_VALUE;
988da6c28aaSamw return (ret);
989da6c28aaSamw }
990da6c28aaSamw
991da6c28aaSamw /*
992da6c28aaSamw * Check yes/no
993da6c28aaSamw */
994da6c28aaSamw /*ARGSUSED*/
995da6c28aaSamw static int
true_false_validator(int index,char * value)996da6c28aaSamw true_false_validator(int index, char *value)
997da6c28aaSamw {
998da6c28aaSamw if (value == NULL)
999da6c28aaSamw return (SA_BAD_VALUE);
1000da6c28aaSamw if ((strcasecmp(value, "true") == 0) ||
1001da6c28aaSamw (strcasecmp(value, "false") == 0))
1002da6c28aaSamw return (SA_OK);
1003da6c28aaSamw return (SA_BAD_VALUE);
1004da6c28aaSamw }
1005da6c28aaSamw
1006da6c28aaSamw /*
100786d7016bSGordon Ross * If printing support is compiled in, this is the same as:
100886d7016bSGordon Ross * true_false_validator. Otherwise, only allow false.
100986d7016bSGordon Ross */
101086d7016bSGordon Ross /*ARGSUSED*/
101186d7016bSGordon Ross static int
print_enable_validator(int index,char * value)101286d7016bSGordon Ross print_enable_validator(int index, char *value)
101386d7016bSGordon Ross {
101486d7016bSGordon Ross if (value == NULL)
101586d7016bSGordon Ross return (SA_BAD_VALUE);
101686d7016bSGordon Ross
101786d7016bSGordon Ross #ifdef HAVE_CUPS
101886d7016bSGordon Ross if (strcasecmp(value, "true") == 0)
101986d7016bSGordon Ross return (SA_OK);
102086d7016bSGordon Ross #endif
102186d7016bSGordon Ross if (strcasecmp(value, "false") == 0)
102286d7016bSGordon Ross return (SA_OK);
102386d7016bSGordon Ross
102486d7016bSGordon Ross return (SA_BAD_VALUE);
102586d7016bSGordon Ross }
102686d7016bSGordon Ross
102786d7016bSGordon Ross /*
102829bd2886SAlan Wright * Check IP v4 address.
1029da6c28aaSamw */
1030da6c28aaSamw /*ARGSUSED*/
1031da6c28aaSamw static int
ipv4_validator(int index,char * value)103229bd2886SAlan Wright ipv4_validator(int index, char *value)
1033da6c28aaSamw {
1034da6c28aaSamw char sbytes[16];
1035da6c28aaSamw
1036da6c28aaSamw if (value == NULL)
1037da6c28aaSamw return (SA_OK);
103829bd2886SAlan Wright
103929bd2886SAlan Wright if (strlen(value) == 0)
1040da6c28aaSamw return (SA_OK);
104129bd2886SAlan Wright
1042da6c28aaSamw if (inet_pton(AF_INET, value, (void *)sbytes) != 1)
1043da6c28aaSamw return (SA_BAD_VALUE);
1044da6c28aaSamw
1045da6c28aaSamw return (SA_OK);
1046da6c28aaSamw }
1047da6c28aaSamw
1048da6c28aaSamw /*
104996a62adaSjoyce mcintosh * Check that the specified name is an IP address (v4 or v6) or a hostname.
105096a62adaSjoyce mcintosh * Per RFC 1035 and 1123, names may contain alphanumeric characters, hyphens
105196a62adaSjoyce mcintosh * and dots. The first and last character of a label must be alphanumeric.
105296a62adaSjoyce mcintosh * Interior characters may be alphanumeric or hypens.
105396a62adaSjoyce mcintosh *
105496a62adaSjoyce mcintosh * Domain names should not contain underscores but we allow them because
105596a62adaSjoyce mcintosh * Windows names are often in non-compliance with this rule.
105629bd2886SAlan Wright */
105729bd2886SAlan Wright /*ARGSUSED*/
105829bd2886SAlan Wright static int
hostname_validator(int index,char * value)105996a62adaSjoyce mcintosh hostname_validator(int index, char *value)
106029bd2886SAlan Wright {
106129bd2886SAlan Wright char sbytes[INET6_ADDRSTRLEN];
106296a62adaSjoyce mcintosh boolean_t new_label = B_TRUE;
106396a62adaSjoyce mcintosh char *p;
106496a62adaSjoyce mcintosh char label_terminator;
106596a62adaSjoyce mcintosh int len;
106629bd2886SAlan Wright
106729bd2886SAlan Wright if (value == NULL)
106829bd2886SAlan Wright return (SA_OK);
106929bd2886SAlan Wright
107096a62adaSjoyce mcintosh if ((len = strlen(value)) == 0)
107129bd2886SAlan Wright return (SA_OK);
107229bd2886SAlan Wright
107396a62adaSjoyce mcintosh if (inet_pton(AF_INET, value, (void *)sbytes) == 1)
107496a62adaSjoyce mcintosh return (SA_OK);
107596a62adaSjoyce mcintosh
107696a62adaSjoyce mcintosh if (inet_pton(AF_INET6, value, (void *)sbytes) == 1)
107796a62adaSjoyce mcintosh return (SA_OK);
107896a62adaSjoyce mcintosh
107996a62adaSjoyce mcintosh if (len >= MAXHOSTNAMELEN)
108096a62adaSjoyce mcintosh return (SA_BAD_VALUE);
108196a62adaSjoyce mcintosh
108296a62adaSjoyce mcintosh if (strspn(value, "0123456789.") == len)
108396a62adaSjoyce mcintosh return (SA_BAD_VALUE);
108496a62adaSjoyce mcintosh
108596a62adaSjoyce mcintosh label_terminator = *value;
108696a62adaSjoyce mcintosh
108796a62adaSjoyce mcintosh for (p = value; *p != '\0'; ++p) {
108896a62adaSjoyce mcintosh if (new_label) {
108996a62adaSjoyce mcintosh if (!isalnum(*p))
109096a62adaSjoyce mcintosh return (SA_BAD_VALUE);
109196a62adaSjoyce mcintosh new_label = B_FALSE;
109296a62adaSjoyce mcintosh label_terminator = *p;
109396a62adaSjoyce mcintosh continue;
109496a62adaSjoyce mcintosh }
109596a62adaSjoyce mcintosh
109696a62adaSjoyce mcintosh if (*p == '.') {
109796a62adaSjoyce mcintosh if (!isalnum(label_terminator))
109896a62adaSjoyce mcintosh return (SA_BAD_VALUE);
109996a62adaSjoyce mcintosh new_label = B_TRUE;
110096a62adaSjoyce mcintosh label_terminator = *p;
110196a62adaSjoyce mcintosh continue;
110296a62adaSjoyce mcintosh }
110396a62adaSjoyce mcintosh
110496a62adaSjoyce mcintosh label_terminator = *p;
110596a62adaSjoyce mcintosh
110696a62adaSjoyce mcintosh if (isalnum(*p) || *p == '-' || *p == '_')
110796a62adaSjoyce mcintosh continue;
110896a62adaSjoyce mcintosh
110996a62adaSjoyce mcintosh return (SA_BAD_VALUE);
111096a62adaSjoyce mcintosh }
111196a62adaSjoyce mcintosh
111296a62adaSjoyce mcintosh if (!isalnum(label_terminator))
111329bd2886SAlan Wright return (SA_BAD_VALUE);
111429bd2886SAlan Wright
111529bd2886SAlan Wright return (SA_OK);
111629bd2886SAlan Wright }
111729bd2886SAlan Wright
111829bd2886SAlan Wright /*
11198d7e4166Sjose borrego * Call back function for dlpi_walk.
11208d7e4166Sjose borrego * Returns TRUE if interface name exists on the host.
11218d7e4166Sjose borrego */
11228d7e4166Sjose borrego static boolean_t
smb_get_interface(const char * ifname,void * arg)11238d7e4166Sjose borrego smb_get_interface(const char *ifname, void *arg)
11248d7e4166Sjose borrego {
11258d7e4166Sjose borrego smb_hostifs_walker_t *iterp = arg;
11268d7e4166Sjose borrego
11278d7e4166Sjose borrego iterp->hiw_matchfound = (strcmp(ifname, iterp->hiw_ifname) == 0);
11288d7e4166Sjose borrego
11298d7e4166Sjose borrego return (iterp->hiw_matchfound);
11308d7e4166Sjose borrego }
11318d7e4166Sjose borrego
11328d7e4166Sjose borrego /*
11338d7e4166Sjose borrego * Checks to see if the input interface exists on the host.
11348d7e4166Sjose borrego * Returns B_TRUE if the match is found, B_FALSE otherwise.
11358d7e4166Sjose borrego */
11368d7e4166Sjose borrego static boolean_t
smb_validate_interface(const char * ifname)11378d7e4166Sjose borrego smb_validate_interface(const char *ifname)
11388d7e4166Sjose borrego {
11398d7e4166Sjose borrego smb_hostifs_walker_t iter;
11408d7e4166Sjose borrego
11418d7e4166Sjose borrego if ((ifname == NULL) || (*ifname == '\0'))
11428d7e4166Sjose borrego return (B_FALSE);
11438d7e4166Sjose borrego
11448d7e4166Sjose borrego iter.hiw_ifname = ifname;
11458d7e4166Sjose borrego iter.hiw_matchfound = B_FALSE;
11468d7e4166Sjose borrego dlpi_walk(smb_get_interface, &iter, 0);
11478d7e4166Sjose borrego
11488d7e4166Sjose borrego return (iter.hiw_matchfound);
11498d7e4166Sjose borrego }
11508d7e4166Sjose borrego
11518d7e4166Sjose borrego /*
11528d7e4166Sjose borrego * Check valid interfaces. Interface names value can be NULL or empty.
11538d7e4166Sjose borrego * Returns SA_BAD_VALUE if interface cannot be found on the host.
1154da6c28aaSamw */
1155da6c28aaSamw /*ARGSUSED*/
1156da6c28aaSamw static int
interface_validator(int index,char * value)11578d7e4166Sjose borrego interface_validator(int index, char *value)
1158da6c28aaSamw {
11598d7e4166Sjose borrego char buf[16];
11608d7e4166Sjose borrego int ret = SA_OK;
11618d7e4166Sjose borrego char *ifname, *tmp, *p;
1162da6c28aaSamw
1163da6c28aaSamw if (value == NULL || *value == '\0')
11648d7e4166Sjose borrego return (ret);
1165da6c28aaSamw
1166da6c28aaSamw if (strlen(value) > MAX_VALUE_BUFLEN)
1167da6c28aaSamw return (SA_BAD_VALUE);
1168da6c28aaSamw
11698d7e4166Sjose borrego if ((p = strdup(value)) == NULL)
1170da6c28aaSamw return (SA_NO_MEMORY);
1171da6c28aaSamw
11728d7e4166Sjose borrego tmp = p;
11738d7e4166Sjose borrego while ((ifname = strsep(&tmp, ",")) != NULL) {
11748d7e4166Sjose borrego if (*ifname == '\0') {
11758d7e4166Sjose borrego ret = SA_BAD_VALUE;
11768d7e4166Sjose borrego break;
1177da6c28aaSamw }
1178da6c28aaSamw
11798d7e4166Sjose borrego if (!smb_validate_interface(ifname)) {
11808d7e4166Sjose borrego if (inet_pton(AF_INET, ifname, (void *)buf) == 0) {
11818d7e4166Sjose borrego ret = SA_BAD_VALUE;
11828d7e4166Sjose borrego break;
11838d7e4166Sjose borrego }
11848d7e4166Sjose borrego }
11858d7e4166Sjose borrego }
11868d7e4166Sjose borrego
11878d7e4166Sjose borrego free(p);
11888d7e4166Sjose borrego return (ret);
1189da6c28aaSamw }
1190da6c28aaSamw
1191da6c28aaSamw /*
1192da6c28aaSamw * Check path
1193da6c28aaSamw */
1194da6c28aaSamw /*ARGSUSED*/
1195da6c28aaSamw static int
path_validator(int index,char * path)11968d96b23eSAlan Wright path_validator(int index, char *path)
1197da6c28aaSamw {
1198da6c28aaSamw struct stat buffer;
1199da6c28aaSamw int fd, status;
1200da6c28aaSamw
12018d96b23eSAlan Wright if (path == NULL)
1202da6c28aaSamw return (SA_BAD_VALUE);
1203da6c28aaSamw
12048d96b23eSAlan Wright fd = open(path, O_RDONLY);
1205da6c28aaSamw if (fd < 0)
1206da6c28aaSamw return (SA_BAD_VALUE);
1207da6c28aaSamw
1208da6c28aaSamw status = fstat(fd, &buffer);
1209da6c28aaSamw (void) close(fd);
1210da6c28aaSamw
1211da6c28aaSamw if (status < 0)
1212da6c28aaSamw return (SA_BAD_VALUE);
1213da6c28aaSamw
1214da6c28aaSamw if (buffer.st_mode & S_IFDIR)
1215da6c28aaSamw return (SA_OK);
1216da6c28aaSamw return (SA_BAD_VALUE);
1217da6c28aaSamw }
1218da6c28aaSamw
1219da6c28aaSamw /*
1220da6c28aaSamw * the protoset holds the defined options so we don't have to read
1221da6c28aaSamw * them multiple times
1222da6c28aaSamw */
1223da6c28aaSamw static sa_protocol_properties_t protoset;
1224da6c28aaSamw
1225da6c28aaSamw static int
findprotoopt(char * name)1226da6c28aaSamw findprotoopt(char *name)
1227da6c28aaSamw {
1228da6c28aaSamw int i;
1229dc20a302Sas200622 char *sc_name;
1230dc20a302Sas200622
1231dc20a302Sas200622 for (i = 0; i < SMB_OPT_NUM; i++) {
1232dc20a302Sas200622 sc_name = smb_config_getname(smb_proto_options[i].smb_index);
1233dc20a302Sas200622 if (strcasecmp(sc_name, name) == 0)
1234da6c28aaSamw return (i);
1235da6c28aaSamw }
1236dc20a302Sas200622
1237da6c28aaSamw return (-1);
1238da6c28aaSamw }
1239da6c28aaSamw
1240da6c28aaSamw /*
1241da6c28aaSamw * smb_load_proto_properties()
1242da6c28aaSamw *
1243da6c28aaSamw * read the smb config values from SMF.
1244da6c28aaSamw */
1245da6c28aaSamw
1246da6c28aaSamw static int
smb_load_proto_properties()1247da6c28aaSamw smb_load_proto_properties()
1248da6c28aaSamw {
1249da6c28aaSamw sa_property_t prop;
1250dc20a302Sas200622 char value[MAX_VALUE_BUFLEN];
1251dc20a302Sas200622 char *name;
1252da6c28aaSamw int index;
1253e7bab347Sdougm int ret = SA_OK;
1254dc20a302Sas200622 int rc;
1255da6c28aaSamw
1256da6c28aaSamw protoset = sa_create_protocol_properties(SMB_PROTOCOL_NAME);
1257da6c28aaSamw if (protoset == NULL)
1258da6c28aaSamw return (SA_NO_MEMORY);
1259da6c28aaSamw
1260e7bab347Sdougm for (index = 0; index < SMB_OPT_NUM && ret == SA_OK; index++) {
1261dc20a302Sas200622 rc = smb_config_get(smb_proto_options[index].smb_index,
1262dc20a302Sas200622 value, sizeof (value));
1263dc20a302Sas200622 if (rc != SMBD_SMF_OK)
1264dc20a302Sas200622 continue;
1265dc20a302Sas200622 name = smb_config_getname(smb_proto_options[index].smb_index);
1266dc20a302Sas200622 prop = sa_create_property(name, value);
126797df5ac9Sdougm if (prop != NULL)
1268e7bab347Sdougm ret = sa_add_protocol_property(protoset, prop);
1269e7bab347Sdougm else
1270e7bab347Sdougm ret = SA_NO_MEMORY;
1271da6c28aaSamw }
1272e7bab347Sdougm return (ret);
1273da6c28aaSamw }
1274da6c28aaSamw
1275da6c28aaSamw /*
1276da6c28aaSamw * smb_share_init()
1277da6c28aaSamw *
1278da6c28aaSamw * Initialize the smb plugin.
1279da6c28aaSamw */
1280da6c28aaSamw
1281da6c28aaSamw static int
smb_share_init(void)1282da6c28aaSamw smb_share_init(void)
1283da6c28aaSamw {
1284da6c28aaSamw if (sa_plugin_ops.sa_init != smb_share_init)
1285da6c28aaSamw return (SA_SYSTEM_ERR);
1286da6c28aaSamw
12878d96b23eSAlan Wright smb_share_door_clnt_init();
1288c8ec8eeaSjose borrego return (smb_load_proto_properties());
1289da6c28aaSamw }
1290da6c28aaSamw
1291da6c28aaSamw /*
1292da6c28aaSamw * smb_share_fini()
1293da6c28aaSamw *
1294da6c28aaSamw */
1295da6c28aaSamw static void
smb_share_fini(void)1296da6c28aaSamw smb_share_fini(void)
1297da6c28aaSamw {
1298da6c28aaSamw xmlFreeNode(protoset);
1299da6c28aaSamw protoset = NULL;
1300dc20a302Sas200622
13018d96b23eSAlan Wright smb_share_door_clnt_fini();
1302da6c28aaSamw }
1303da6c28aaSamw
1304da6c28aaSamw /*
1305da6c28aaSamw * smb_get_proto_set()
1306da6c28aaSamw *
1307da6c28aaSamw * Return an optionset with all the protocol specific properties in
1308da6c28aaSamw * it.
1309da6c28aaSamw */
1310da6c28aaSamw static sa_protocol_properties_t
smb_get_proto_set(void)1311da6c28aaSamw smb_get_proto_set(void)
1312da6c28aaSamw {
1313da6c28aaSamw return (protoset);
1314da6c28aaSamw }
1315da6c28aaSamw
1316da6c28aaSamw /*
1317dc20a302Sas200622 * smb_enable_dependencies()
1318dc20a302Sas200622 *
1319dc20a302Sas200622 * SMBD_DEFAULT_INSTANCE_FMRI may have some dependencies that aren't
1320dc20a302Sas200622 * enabled. This will attempt to enable all of them.
1321dc20a302Sas200622 */
1322dc20a302Sas200622 static void
smb_enable_dependencies(const char * fmri)1323dc20a302Sas200622 smb_enable_dependencies(const char *fmri)
1324dc20a302Sas200622 {
1325dc20a302Sas200622 scf_handle_t *handle;
1326dc20a302Sas200622 scf_service_t *service;
1327dc20a302Sas200622 scf_instance_t *inst = NULL;
1328dc20a302Sas200622 scf_iter_t *iter;
1329dc20a302Sas200622 scf_property_t *prop;
1330dc20a302Sas200622 scf_value_t *value;
1331dc20a302Sas200622 scf_propertygroup_t *pg;
1332dc20a302Sas200622 scf_scope_t *scope;
1333dc20a302Sas200622 char type[SCFTYPE_LEN];
1334dc20a302Sas200622 char *dependency;
1335dc20a302Sas200622 char *servname;
1336dc20a302Sas200622 int maxlen;
1337dc20a302Sas200622
1338dc20a302Sas200622 /*
1339dc20a302Sas200622 * Get all required handles and storage.
1340dc20a302Sas200622 */
1341dc20a302Sas200622 handle = scf_handle_create(SCF_VERSION);
1342dc20a302Sas200622 if (handle == NULL)
1343dc20a302Sas200622 return;
1344dc20a302Sas200622
1345dc20a302Sas200622 if (scf_handle_bind(handle) != 0) {
1346dc20a302Sas200622 scf_handle_destroy(handle);
1347dc20a302Sas200622 return;
1348dc20a302Sas200622 }
1349dc20a302Sas200622
1350dc20a302Sas200622 maxlen = scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH);
1351dc20a302Sas200622 if (maxlen == (ssize_t)-1)
1352dc20a302Sas200622 maxlen = MAXPATHLEN;
1353dc20a302Sas200622
1354dc20a302Sas200622 dependency = malloc(maxlen);
1355dc20a302Sas200622
1356dc20a302Sas200622 service = scf_service_create(handle);
1357dc20a302Sas200622
1358dc20a302Sas200622 iter = scf_iter_create(handle);
1359dc20a302Sas200622
1360dc20a302Sas200622 pg = scf_pg_create(handle);
1361dc20a302Sas200622
1362dc20a302Sas200622 prop = scf_property_create(handle);
1363dc20a302Sas200622
1364dc20a302Sas200622 value = scf_value_create(handle);
1365dc20a302Sas200622
1366dc20a302Sas200622 scope = scf_scope_create(handle);
1367dc20a302Sas200622
1368dc20a302Sas200622 if (service == NULL || iter == NULL || pg == NULL || prop == NULL ||
1369dc20a302Sas200622 value == NULL || scope == NULL || dependency == NULL)
1370dc20a302Sas200622 goto done;
1371dc20a302Sas200622
1372dc20a302Sas200622 /*
1373dc20a302Sas200622 * We passed in the FMRI for the default instance but for
1374dc20a302Sas200622 * some things we need the simple form so construct it. Since
1375dc20a302Sas200622 * we reuse the storage that dependency points to, we need to
1376dc20a302Sas200622 * use the servname early.
1377dc20a302Sas200622 */
1378dc20a302Sas200622 (void) snprintf(dependency, maxlen, "%s", fmri + sizeof ("svc:"));
1379dc20a302Sas200622 servname = strrchr(dependency, ':');
1380dc20a302Sas200622 if (servname == NULL)
1381dc20a302Sas200622 goto done;
1382dc20a302Sas200622 *servname = '\0';
1383dc20a302Sas200622 servname = dependency;
1384dc20a302Sas200622
1385dc20a302Sas200622 /*
1386dc20a302Sas200622 * Setup to iterate over the service property groups, only
1387dc20a302Sas200622 * looking at those that are "dependency" types. The "entity"
1388dc20a302Sas200622 * property will have the FMRI of the service we are dependent
1389dc20a302Sas200622 * on.
1390dc20a302Sas200622 */
1391dc20a302Sas200622 if (scf_handle_get_scope(handle, SCF_SCOPE_LOCAL, scope) != 0)
1392dc20a302Sas200622 goto done;
1393dc20a302Sas200622
1394dc20a302Sas200622 if (scf_scope_get_service(scope, servname, service) != 0)
1395dc20a302Sas200622 goto done;
1396dc20a302Sas200622
1397dc20a302Sas200622 if (scf_iter_service_pgs(iter, service) != 0)
1398dc20a302Sas200622 goto done;
1399dc20a302Sas200622
1400dc20a302Sas200622 while (scf_iter_next_pg(iter, pg) > 0) {
1401dc20a302Sas200622 char *services[2];
1402dc20a302Sas200622 /*
1403dc20a302Sas200622 * Have a property group for the service. See if it is
1404dc20a302Sas200622 * a dependency pg and only do operations on those.
1405dc20a302Sas200622 */
1406dc20a302Sas200622 if (scf_pg_get_type(pg, type, SCFTYPE_LEN) <= 0)
1407dc20a302Sas200622 continue;
1408dc20a302Sas200622
1409dc20a302Sas200622 if (strncmp(type, SCF_GROUP_DEPENDENCY, SCFTYPE_LEN) != 0)
1410dc20a302Sas200622 continue;
1411dc20a302Sas200622 /*
1412dc20a302Sas200622 * Have a dependency. Attempt to enable it.
1413dc20a302Sas200622 */
1414dc20a302Sas200622 if (scf_pg_get_property(pg, SCF_PROPERTY_ENTITIES, prop) != 0)
1415dc20a302Sas200622 continue;
1416dc20a302Sas200622
1417dc20a302Sas200622 if (scf_property_get_value(prop, value) != 0)
1418dc20a302Sas200622 continue;
1419dc20a302Sas200622
1420dc20a302Sas200622 services[1] = NULL;
1421dc20a302Sas200622
1422dc20a302Sas200622 if (scf_value_get_as_string(value, dependency, maxlen) > 0) {
1423dc20a302Sas200622 services[0] = dependency;
1424dc20a302Sas200622 _check_services(services);
1425dc20a302Sas200622 }
1426dc20a302Sas200622 }
1427dc20a302Sas200622
1428dc20a302Sas200622 done:
1429dc20a302Sas200622 if (dependency != NULL)
1430dc20a302Sas200622 free(dependency);
1431dc20a302Sas200622 if (value != NULL)
1432dc20a302Sas200622 scf_value_destroy(value);
1433dc20a302Sas200622 if (prop != NULL)
1434dc20a302Sas200622 scf_property_destroy(prop);
1435dc20a302Sas200622 if (pg != NULL)
1436dc20a302Sas200622 scf_pg_destroy(pg);
1437dc20a302Sas200622 if (iter != NULL)
1438dc20a302Sas200622 scf_iter_destroy(iter);
1439dc20a302Sas200622 if (scope != NULL)
1440dc20a302Sas200622 scf_scope_destroy(scope);
1441dc20a302Sas200622 if (inst != NULL)
1442dc20a302Sas200622 scf_instance_destroy(inst);
1443dc20a302Sas200622 if (service != NULL)
1444dc20a302Sas200622 scf_service_destroy(service);
1445dc20a302Sas200622
1446dc20a302Sas200622 (void) scf_handle_unbind(handle);
1447dc20a302Sas200622 scf_handle_destroy(handle);
1448dc20a302Sas200622 }
1449dc20a302Sas200622
1450dc20a302Sas200622 /*
1451da6c28aaSamw * How long to wait for service to come online
1452da6c28aaSamw */
1453da6c28aaSamw #define WAIT_FOR_SERVICE 15
1454da6c28aaSamw
1455da6c28aaSamw /*
1456da6c28aaSamw * smb_enable_service()
1457da6c28aaSamw *
1458da6c28aaSamw */
1459da6c28aaSamw static int
smb_enable_service(void)1460da6c28aaSamw smb_enable_service(void)
1461da6c28aaSamw {
1462da6c28aaSamw int i;
1463da6c28aaSamw int ret = SA_OK;
1464dc20a302Sas200622 char *service[] = { SMBD_DEFAULT_INSTANCE_FMRI, NULL };
1465da6c28aaSamw
1466da6c28aaSamw if (!smb_isonline()) {
1467dc20a302Sas200622 /*
1468dc20a302Sas200622 * Attempt to start the idmap, and other dependent
1469dc20a302Sas200622 * services, first. If it fails, the SMB service will
1470dc20a302Sas200622 * ultimately fail so we use that as the error. If we
1471dc20a302Sas200622 * don't try to enable idmap, smb won't start the
1472dc20a302Sas200622 * first time unless the admin has done it
1473dc20a302Sas200622 * manually. The service could be administratively
1474dc20a302Sas200622 * disabled so we won't always get started.
1475dc20a302Sas200622 */
1476dc20a302Sas200622 smb_enable_dependencies(SMBD_DEFAULT_INSTANCE_FMRI);
1477dc20a302Sas200622 _check_services(service);
1478da6c28aaSamw
1479da6c28aaSamw /* Wait for service to come online */
1480da6c28aaSamw for (i = 0; i < WAIT_FOR_SERVICE; i++) {
1481da6c28aaSamw if (smb_isonline()) {
1482da6c28aaSamw ret = SA_OK;
1483da6c28aaSamw break;
14847b59d02dSjb150015 } else if (smb_ismaint()) {
14857b59d02dSjb150015 /* maintenance requires help */
14867b59d02dSjb150015 ret = SA_SYSTEM_ERR;
14877b59d02dSjb150015 break;
1488da6c28aaSamw } else {
14897b59d02dSjb150015 /* try another time */
1490da6c28aaSamw ret = SA_BUSY;
1491da6c28aaSamw (void) sleep(1);
1492da6c28aaSamw }
1493da6c28aaSamw }
1494da6c28aaSamw }
1495da6c28aaSamw return (ret);
1496da6c28aaSamw }
1497da6c28aaSamw
1498da6c28aaSamw /*
1499da6c28aaSamw * smb_set_proto_prop(prop)
1500da6c28aaSamw *
1501da6c28aaSamw * check that prop is valid.
1502da6c28aaSamw */
1503da6c28aaSamw /*ARGSUSED*/
1504da6c28aaSamw static int
smb_set_proto_prop(sa_property_t prop)1505da6c28aaSamw smb_set_proto_prop(sa_property_t prop)
1506da6c28aaSamw {
1507da6c28aaSamw int ret = SA_OK;
1508da6c28aaSamw char *name;
1509da6c28aaSamw char *value;
1510da6c28aaSamw int index = -1;
151155bf511dSas200622 struct smb_proto_option_defs *opt;
1512da6c28aaSamw
1513da6c28aaSamw name = sa_get_property_attr(prop, "type");
1514da6c28aaSamw value = sa_get_property_attr(prop, "value");
151576b0ca5aSGordon Ross if (name == NULL || value == NULL) {
151676b0ca5aSGordon Ross ret = SA_NO_SUCH_PROP;
151776b0ca5aSGordon Ross goto out;
151876b0ca5aSGordon Ross }
151976b0ca5aSGordon Ross
1520da6c28aaSamw index = findprotoopt(name);
152176b0ca5aSGordon Ross if (index < 0) {
152276b0ca5aSGordon Ross ret = SA_NO_SUCH_PROP;
152376b0ca5aSGordon Ross goto out;
152476b0ca5aSGordon Ross }
152555bf511dSas200622 opt = &smb_proto_options[index];
152655bf511dSas200622
152776b0ca5aSGordon Ross /*
152876b0ca5aSGordon Ross * When setting max_protocol or min_protocol,
152976b0ca5aSGordon Ross * allow"3.1.1" as an alias for "3.11".
153076b0ca5aSGordon Ross */
153176b0ca5aSGordon Ross if (opt->smb_index == SMB_CI_MAX_PROTOCOL ||
153276b0ca5aSGordon Ross opt->smb_index == SMB_CI_MIN_PROTOCOL)
153376b0ca5aSGordon Ross if (strcmp(value, "3.1.1") == 0)
1534*2bc647a2SToomas Soome (void) strcpy(value, "3.11");
153576b0ca5aSGordon Ross
153676b0ca5aSGordon Ross /* Test for valid value */
153776b0ca5aSGordon Ross if (opt->validator != NULL &&
153876b0ca5aSGordon Ross (ret = opt->validator(index, value)) != SA_OK)
153976b0ca5aSGordon Ross goto out;
154076b0ca5aSGordon Ross
1541da6c28aaSamw /* Save to SMF */
154276b0ca5aSGordon Ross if (smb_config_set(opt->smb_index, value) != 0) {
15431160dcf7SMatt Barden ret = SA_BAD_VALUE;
15441160dcf7SMatt Barden goto out;
15451160dcf7SMatt Barden }
154676b0ca5aSGordon Ross
1547da6c28aaSamw /*
1548da6c28aaSamw * Specialized refresh mechanisms can
1549da6c28aaSamw * be flagged in the proto_options and
1550da6c28aaSamw * processed here.
1551da6c28aaSamw */
155255bf511dSas200622 if (opt->refresh & SMB_REFRESH_REFRESH)
1553faa1795aSjb150015 (void) smf_refresh_instance(
1554faa1795aSjb150015 SMBD_DEFAULT_INSTANCE_FMRI);
155555bf511dSas200622 else if (opt->refresh & SMB_REFRESH_RESTART)
1556da6c28aaSamw (void) smf_restart_instance(
1557da6c28aaSamw SMBD_DEFAULT_INSTANCE_FMRI);
155855bf511dSas200622
15591160dcf7SMatt Barden out:
1560da6c28aaSamw if (name != NULL)
1561da6c28aaSamw sa_free_attr_string(name);
1562da6c28aaSamw if (value != NULL)
1563da6c28aaSamw sa_free_attr_string(value);
1564da6c28aaSamw
1565da6c28aaSamw return (ret);
1566da6c28aaSamw }
1567da6c28aaSamw
1568da6c28aaSamw /*
1569da6c28aaSamw * smb_get_status()
1570da6c28aaSamw *
1571da6c28aaSamw * What is the current status of the smbd? We use the SMF state here.
1572da6c28aaSamw * Caller must free the returned value.
1573da6c28aaSamw */
1574da6c28aaSamw
1575da6c28aaSamw static char *
smb_get_status(void)1576da6c28aaSamw smb_get_status(void)
1577da6c28aaSamw {
1578652601fbSRobert Mustacchi return (smf_get_state(SMBD_DEFAULT_INSTANCE_FMRI));
1579da6c28aaSamw }
1580da6c28aaSamw
1581da6c28aaSamw /*
1582da6c28aaSamw * This protocol plugin require resource names
1583da6c28aaSamw */
1584da6c28aaSamw static uint64_t
smb_share_features(void)1585da6c28aaSamw smb_share_features(void)
1586da6c28aaSamw {
1587da6c28aaSamw return (SA_FEATURE_RESOURCE | SA_FEATURE_ALLOWSUBDIRS |
15889e5da854Sdougm SA_FEATURE_ALLOWPARDIRS | SA_FEATURE_SERVER);
1589da6c28aaSamw }
1590da6c28aaSamw
1591da6c28aaSamw /*
1592c8ec8eeaSjose borrego * This should be used to convert smb_share_t to sa_resource_t
1593c8ec8eeaSjose borrego * Should only be needed to build transient shares/resources to be
1594c8ec8eeaSjose borrego * supplied to sharemgr to display.
1595da6c28aaSamw */
1596da6c28aaSamw static int
smb_add_transient(sa_handle_t handle,smb_share_t * si)1597c8ec8eeaSjose borrego smb_add_transient(sa_handle_t handle, smb_share_t *si)
1598da6c28aaSamw {
1599da6c28aaSamw int err;
1600da6c28aaSamw sa_share_t share;
1601da6c28aaSamw sa_group_t group;
1602da6c28aaSamw sa_resource_t resource;
160396a62adaSjoyce mcintosh nvlist_t *nvl;
160429bd2886SAlan Wright char *opt;
1605da6c28aaSamw
1606da6c28aaSamw if (si == NULL)
1607da6c28aaSamw return (SA_INVALID_NAME);
1608da6c28aaSamw
1609c8ec8eeaSjose borrego if ((share = sa_find_share(handle, si->shr_path)) == NULL) {
1610c8ec8eeaSjose borrego if ((group = smb_get_defaultgrp(handle)) == NULL)
1611da6c28aaSamw return (SA_NO_SUCH_GROUP);
1612c8ec8eeaSjose borrego
16133db3f65cSamw share = sa_get_share(group, si->shr_path);
1614da6c28aaSamw if (share == NULL) {
16153db3f65cSamw share = sa_add_share(group, si->shr_path,
1616da6c28aaSamw SA_SHARE_TRANSIENT, &err);
1617da6c28aaSamw if (share == NULL)
1618da6c28aaSamw return (SA_NO_SUCH_PATH);
1619da6c28aaSamw }
1620da6c28aaSamw }
1621da6c28aaSamw
1622da6c28aaSamw /*
1623da6c28aaSamw * Now handle the resource. Make sure that the resource is
1624da6c28aaSamw * transient and added to the share.
1625da6c28aaSamw */
16263db3f65cSamw resource = sa_get_share_resource(share, si->shr_name);
1627da6c28aaSamw if (resource == NULL) {
1628da6c28aaSamw resource = sa_add_resource(share,
16293db3f65cSamw si->shr_name, SA_SHARE_TRANSIENT, &err);
1630da6c28aaSamw if (resource == NULL)
1631da6c28aaSamw return (SA_NO_SUCH_RESOURCE);
1632da6c28aaSamw }
1633da6c28aaSamw
163489dc44ceSjose borrego if (si->shr_cmnt[0] != '\0')
163589dc44ceSjose borrego (void) sa_set_resource_description(resource, si->shr_cmnt);
163629bd2886SAlan Wright
163789dc44ceSjose borrego if (si->shr_container[0] != '\0')
16388d7e4166Sjose borrego (void) sa_set_resource_attr(resource, SHOPT_AD_CONTAINER,
16393db3f65cSamw si->shr_container);
164029bd2886SAlan Wright
164196a62adaSjoyce mcintosh if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
164296a62adaSjoyce mcintosh return (SA_NO_MEMORY);
164396a62adaSjoyce mcintosh
164429bd2886SAlan Wright if ((opt = smb_csc_name(si)) != NULL)
164596a62adaSjoyce mcintosh err |= nvlist_add_string(nvl, SHOPT_CSC, opt);
164629bd2886SAlan Wright
1647e3f2c991SKeyur Desai opt = (si->shr_flags & SMB_SHRF_ABE) ? "true" : "false";
164896a62adaSjoyce mcintosh err |= nvlist_add_string(nvl, SHOPT_ABE, opt);
1649e3f2c991SKeyur Desai
1650148c5f43SAlan Wright if ((si->shr_flags & SMB_SHRF_AUTOHOME) == 0) {
165129bd2886SAlan Wright opt = (si->shr_flags & SMB_SHRF_GUEST_OK) ? "true" : "false";
165296a62adaSjoyce mcintosh err |= nvlist_add_string(nvl, SHOPT_GUEST, opt);
1653148c5f43SAlan Wright }
1654148c5f43SAlan Wright
1655148c5f43SAlan Wright if (si->shr_access_ro[0] != '\0')
1656148c5f43SAlan Wright err |= nvlist_add_string(nvl, SHOPT_RO, si->shr_access_ro);
1657148c5f43SAlan Wright
1658148c5f43SAlan Wright if (si->shr_access_rw[0] != '\0')
1659148c5f43SAlan Wright err |= nvlist_add_string(nvl, SHOPT_RW, si->shr_access_rw);
1660148c5f43SAlan Wright
1661148c5f43SAlan Wright if (si->shr_access_none[0] != '\0')
1662148c5f43SAlan Wright err |= nvlist_add_string(nvl, SHOPT_NONE, si->shr_access_none);
1663148c5f43SAlan Wright
166496a62adaSjoyce mcintosh if (err) {
166596a62adaSjoyce mcintosh nvlist_free(nvl);
166696a62adaSjoyce mcintosh return (SA_CONFIG_ERR);
166796a62adaSjoyce mcintosh }
1668da6c28aaSamw
166996a62adaSjoyce mcintosh err = smb_update_optionset_props(handle, resource, nvl);
167096a62adaSjoyce mcintosh
167196a62adaSjoyce mcintosh nvlist_free(nvl);
167296a62adaSjoyce mcintosh return (err);
1673da6c28aaSamw }
1674da6c28aaSamw
1675da6c28aaSamw /*
1676c8ec8eeaSjose borrego * Return smb transient shares.
1677da6c28aaSamw */
1678da6c28aaSamw static int
smb_list_transient(sa_handle_t handle)1679da6c28aaSamw smb_list_transient(sa_handle_t handle)
1680da6c28aaSamw {
1681c8ec8eeaSjose borrego int i, offset;
16823db3f65cSamw smb_shrlist_t list;
1683da6c28aaSamw int res;
1684da6c28aaSamw
1685c8ec8eeaSjose borrego if (smb_share_count() <= 0)
1686da6c28aaSamw return (SA_OK);
1687c8ec8eeaSjose borrego
1688da6c28aaSamw offset = 0;
1689c8ec8eeaSjose borrego while (smb_share_list(offset, &list) == NERR_Success) {
1690c8ec8eeaSjose borrego if (list.sl_cnt == 0)
1691da6c28aaSamw break;
1692c8ec8eeaSjose borrego
1693c8ec8eeaSjose borrego for (i = 0; i < list.sl_cnt; i++) {
1694c8ec8eeaSjose borrego res = smb_add_transient(handle, &(list.sl_shares[i]));
1695da6c28aaSamw if (res != SA_OK)
1696da6c28aaSamw return (res);
1697da6c28aaSamw }
1698c8ec8eeaSjose borrego offset += list.sl_cnt;
1699da6c28aaSamw }
1700da6c28aaSamw
1701da6c28aaSamw return (SA_OK);
1702da6c28aaSamw }
1703da6c28aaSamw
1704da6c28aaSamw /*
1705da6c28aaSamw * fix_resource_name(share, name, prefix)
1706da6c28aaSamw *
1707da6c28aaSamw * Construct a name where the ZFS dataset has the prefix replaced with "name".
1708da6c28aaSamw */
1709da6c28aaSamw static char *
fix_resource_name(sa_share_t share,char * name,char * prefix)1710da6c28aaSamw fix_resource_name(sa_share_t share, char *name, char *prefix)
1711da6c28aaSamw {
171289dc44ceSjose borrego char buf[SA_MAX_RESOURCE_NAME + 1];
171389dc44ceSjose borrego char *dataset;
171489dc44ceSjose borrego size_t bufsz = SA_MAX_RESOURCE_NAME + 1;
171589dc44ceSjose borrego size_t prelen;
1716da6c28aaSamw
1717f96bd5c8SAlan Wright if (prefix == NULL)
1718f96bd5c8SAlan Wright return (strdup(name));
1719f96bd5c8SAlan Wright
1720da6c28aaSamw dataset = sa_get_share_attr(share, "dataset");
172189dc44ceSjose borrego if (dataset == NULL)
1722da6c28aaSamw return (strdup(name));
172389dc44ceSjose borrego
172489dc44ceSjose borrego (void) strlcpy(buf, name, bufsz);
172589dc44ceSjose borrego prelen = strlen(prefix);
172689dc44ceSjose borrego
172789dc44ceSjose borrego if (strncmp(dataset, prefix, prelen) == 0)
172889dc44ceSjose borrego (void) strlcat(buf, dataset + prelen, bufsz);
172989dc44ceSjose borrego
173089dc44ceSjose borrego sa_free_attr_string(dataset);
173189dc44ceSjose borrego sa_fix_resource_name(buf);
173289dc44ceSjose borrego return (strdup(buf));
1733da6c28aaSamw }
1734da6c28aaSamw
1735da6c28aaSamw /*
1736da6c28aaSamw * smb_parse_optstring(group, options)
1737da6c28aaSamw *
1738da6c28aaSamw * parse a compact option string into individual options. This allows
1739da6c28aaSamw * ZFS sharesmb and sharemgr "share" command to work. group can be a
1740da6c28aaSamw * group, a share or a resource.
1741da6c28aaSamw */
1742da6c28aaSamw static int
smb_parse_optstring(sa_group_t group,char * options)1743da6c28aaSamw smb_parse_optstring(sa_group_t group, char *options)
1744da6c28aaSamw {
1745da6c28aaSamw char *dup;
1746da6c28aaSamw char *base;
1747da6c28aaSamw char *lasts;
1748da6c28aaSamw char *token;
1749da6c28aaSamw sa_optionset_t optionset;
1750da6c28aaSamw sa_group_t parent = NULL;
1751da6c28aaSamw sa_resource_t resource = NULL;
1752da6c28aaSamw int iszfs = 0;
1753da6c28aaSamw int persist = 0;
1754da6c28aaSamw int need_optionset = 0;
1755da6c28aaSamw int ret = SA_OK;
1756da6c28aaSamw sa_property_t prop;
1757da6c28aaSamw
1758da6c28aaSamw /*
1759da6c28aaSamw * In order to not attempt to change ZFS properties unless
1760da6c28aaSamw * absolutely necessary, we never do it in the legacy parsing
1761da6c28aaSamw * so we need to keep track of this.
1762da6c28aaSamw */
1763da6c28aaSamw if (sa_is_share(group)) {
1764da6c28aaSamw char *zfs;
1765da6c28aaSamw
1766da6c28aaSamw parent = sa_get_parent_group(group);
1767da6c28aaSamw if (parent != NULL) {
1768da6c28aaSamw zfs = sa_get_group_attr(parent, "zfs");
1769da6c28aaSamw if (zfs != NULL) {
1770da6c28aaSamw sa_free_attr_string(zfs);
1771da6c28aaSamw iszfs = 1;
1772da6c28aaSamw }
1773da6c28aaSamw }
1774da6c28aaSamw } else {
1775da6c28aaSamw iszfs = sa_group_is_zfs(group);
1776da6c28aaSamw /*
1777da6c28aaSamw * If a ZFS group, then we need to see if a resource
1778da6c28aaSamw * name is being set. If so, bail with
1779da6c28aaSamw * SA_PROP_SHARE_ONLY, so we come back in with a share
1780da6c28aaSamw * instead of a group.
1781da6c28aaSamw */
1782148c5f43SAlan Wright if (iszfs ||
1783148c5f43SAlan Wright strncmp(options, "name=", sizeof ("name=") - 1) == 0 ||
1784da6c28aaSamw strstr(options, ",name=") != NULL) {
1785da6c28aaSamw return (SA_PROP_SHARE_ONLY);
1786da6c28aaSamw }
1787da6c28aaSamw }
1788da6c28aaSamw
1789da6c28aaSamw /* do we have an existing optionset? */
1790da6c28aaSamw optionset = sa_get_optionset(group, "smb");
1791da6c28aaSamw if (optionset == NULL) {
1792da6c28aaSamw /* didn't find existing optionset so create one */
1793da6c28aaSamw optionset = sa_create_optionset(group, "smb");
1794da6c28aaSamw if (optionset == NULL)
1795da6c28aaSamw return (SA_NO_MEMORY);
1796da6c28aaSamw } else {
1797da6c28aaSamw /*
1798da6c28aaSamw * If an optionset already exists, we've come through
1799da6c28aaSamw * twice so ignore the second time.
1800da6c28aaSamw */
1801da6c28aaSamw return (ret);
1802da6c28aaSamw }
1803da6c28aaSamw
1804da6c28aaSamw /* We need a copy of options for the next part. */
1805da6c28aaSamw dup = strdup(options);
1806da6c28aaSamw if (dup == NULL)
1807da6c28aaSamw return (SA_NO_MEMORY);
1808da6c28aaSamw
1809da6c28aaSamw /*
1810da6c28aaSamw * SMB properties are straightforward and are strings,
1811da6c28aaSamw * integers or booleans. Properties are separated by
1812da6c28aaSamw * commas. It will be necessary to parse quotes due to some
1813da6c28aaSamw * strings not having a restricted characters set.
1814da6c28aaSamw *
1815da6c28aaSamw * Note that names will create a resource. For now, if there
1816da6c28aaSamw * is a set of properties "before" the first name="", those
1817da6c28aaSamw * properties will be placed on the group.
1818da6c28aaSamw */
1819da6c28aaSamw persist = sa_is_persistent(group);
1820da6c28aaSamw base = dup;
1821da6c28aaSamw token = dup;
1822da6c28aaSamw lasts = NULL;
1823da6c28aaSamw while (token != NULL && ret == SA_OK) {
1824da6c28aaSamw ret = SA_OK;
1825da6c28aaSamw token = strtok_r(base, ",", &lasts);
1826da6c28aaSamw base = NULL;
1827da6c28aaSamw if (token != NULL) {
1828da6c28aaSamw char *value;
1829da6c28aaSamw /*
1830da6c28aaSamw * All SMB properties have values so there
1831da6c28aaSamw * MUST be an '=' character. If it doesn't,
1832da6c28aaSamw * it is a syntax error.
1833da6c28aaSamw */
1834da6c28aaSamw value = strchr(token, '=');
1835da6c28aaSamw if (value != NULL) {
1836da6c28aaSamw *value++ = '\0';
1837da6c28aaSamw } else {
1838da6c28aaSamw ret = SA_SYNTAX_ERR;
1839da6c28aaSamw break;
1840da6c28aaSamw }
1841da6c28aaSamw /*
1842da6c28aaSamw * We may need to handle a "name" property
1843da6c28aaSamw * that is a ZFS imposed resource name. Each
1844da6c28aaSamw * name would trigger getting a new "resource"
1845da6c28aaSamw * to put properties on. For now, assume no
1846da6c28aaSamw * "name" property for special handling.
1847da6c28aaSamw */
1848da6c28aaSamw
1849148c5f43SAlan Wright if (strcmp(token, SHOPT_NAME) == 0) {
1850da6c28aaSamw char *prefix;
1851da6c28aaSamw char *name = NULL;
1852da6c28aaSamw /*
1853da6c28aaSamw * We have a name, so now work on the
1854da6c28aaSamw * resource level. We have a "share"
1855da6c28aaSamw * in "group" due to the caller having
1856da6c28aaSamw * added it. If we are called with a
1857da6c28aaSamw * group, the check for group/share
1858da6c28aaSamw * at the beginning of this function
1859da6c28aaSamw * will bail out the parse if there is a
1860da6c28aaSamw * "name" but no share.
1861da6c28aaSamw */
1862da6c28aaSamw if (!iszfs) {
1863da6c28aaSamw ret = SA_SYNTAX_ERR;
1864da6c28aaSamw break;
1865da6c28aaSamw }
1866da6c28aaSamw /*
1867da6c28aaSamw * Make sure the parent group has the
1868da6c28aaSamw * "prefix" property since we will
1869da6c28aaSamw * need to use this for constructing
1870da6c28aaSamw * inherited name= values.
1871da6c28aaSamw */
1872da6c28aaSamw prefix = sa_get_group_attr(parent, "prefix");
1873da6c28aaSamw if (prefix == NULL) {
1874da6c28aaSamw prefix = sa_get_group_attr(parent,
1875da6c28aaSamw "name");
1876da6c28aaSamw if (prefix != NULL) {
1877da6c28aaSamw (void) sa_set_group_attr(parent,
1878da6c28aaSamw "prefix", prefix);
1879da6c28aaSamw }
1880da6c28aaSamw }
1881f96bd5c8SAlan Wright name = fix_resource_name((sa_share_t)group,
1882f96bd5c8SAlan Wright value, prefix);
1883da6c28aaSamw if (name != NULL) {
1884da6c28aaSamw resource = sa_add_resource(
1885da6c28aaSamw (sa_share_t)group, name,
1886da6c28aaSamw SA_SHARE_TRANSIENT, &ret);
1887da6c28aaSamw sa_free_attr_string(name);
1888da6c28aaSamw } else {
1889da6c28aaSamw ret = SA_NO_MEMORY;
1890da6c28aaSamw }
1891da6c28aaSamw if (prefix != NULL)
1892da6c28aaSamw sa_free_attr_string(prefix);
1893da6c28aaSamw
1894da6c28aaSamw /* A resource level optionset is needed */
1895da6c28aaSamw
1896da6c28aaSamw need_optionset = 1;
1897da6c28aaSamw if (resource == NULL) {
1898da6c28aaSamw ret = SA_NO_MEMORY;
1899da6c28aaSamw break;
1900da6c28aaSamw }
1901da6c28aaSamw continue;
1902da6c28aaSamw }
1903da6c28aaSamw
1904148c5f43SAlan Wright if (iszfs && strcmp(token, SHOPT_DESCRIPTION) == 0) {
1905148c5f43SAlan Wright if (resource == NULL)
1906148c5f43SAlan Wright (void) sa_set_share_description(
1907148c5f43SAlan Wright (sa_share_t)group, value);
1908148c5f43SAlan Wright else
1909148c5f43SAlan Wright (void) sa_set_resource_description(
1910148c5f43SAlan Wright resource, value);
1911148c5f43SAlan Wright continue;
1912148c5f43SAlan Wright }
1913148c5f43SAlan Wright
1914da6c28aaSamw if (need_optionset) {
1915da6c28aaSamw optionset = sa_create_optionset(resource,
1916da6c28aaSamw "smb");
1917da6c28aaSamw need_optionset = 0;
1918da6c28aaSamw }
1919da6c28aaSamw
1920da6c28aaSamw prop = sa_create_property(token, value);
1921da6c28aaSamw if (prop == NULL)
1922da6c28aaSamw ret = SA_NO_MEMORY;
1923da6c28aaSamw else
1924da6c28aaSamw ret = sa_add_property(optionset, prop);
1925da6c28aaSamw if (ret != SA_OK)
1926da6c28aaSamw break;
1927da6c28aaSamw if (!iszfs)
1928da6c28aaSamw ret = sa_commit_properties(optionset, !persist);
1929da6c28aaSamw }
1930da6c28aaSamw }
1931da6c28aaSamw free(dup);
1932da6c28aaSamw return (ret);
1933da6c28aaSamw }
1934da6c28aaSamw
1935da6c28aaSamw /*
1936da6c28aaSamw * smb_sprint_option(rbuff, rbuffsize, incr, prop, sep)
1937da6c28aaSamw *
1938da6c28aaSamw * provides a mechanism to format SMB properties into legacy output
1939da6c28aaSamw * format. If the buffer would overflow, it is reallocated and grown
1940da6c28aaSamw * as appropriate. Special cases of converting internal form of values
1941da6c28aaSamw * to those used by "share" are done. this function does one property
1942da6c28aaSamw * at a time.
1943da6c28aaSamw */
1944da6c28aaSamw
1945da6c28aaSamw static void
smb_sprint_option(char ** rbuff,size_t * rbuffsize,size_t incr,sa_property_t prop,int sep)1946da6c28aaSamw smb_sprint_option(char **rbuff, size_t *rbuffsize, size_t incr,
1947da6c28aaSamw sa_property_t prop, int sep)
1948da6c28aaSamw {
1949da6c28aaSamw char *name;
1950da6c28aaSamw char *value;
1951da6c28aaSamw int curlen;
1952da6c28aaSamw char *buff = *rbuff;
1953da6c28aaSamw size_t buffsize = *rbuffsize;
1954da6c28aaSamw
1955da6c28aaSamw name = sa_get_property_attr(prop, "type");
1956da6c28aaSamw value = sa_get_property_attr(prop, "value");
1957da6c28aaSamw if (buff != NULL)
1958da6c28aaSamw curlen = strlen(buff);
1959da6c28aaSamw else
1960da6c28aaSamw curlen = 0;
1961da6c28aaSamw if (name != NULL) {
1962da6c28aaSamw int len;
1963da6c28aaSamw len = strlen(name) + sep;
1964da6c28aaSamw
1965da6c28aaSamw /*
1966da6c28aaSamw * A future RFE would be to replace this with more
1967da6c28aaSamw * generic code and to possibly handle more types.
1968da6c28aaSamw *
1969da6c28aaSamw * For now, everything else is treated as a string. If
1970da6c28aaSamw * we get any properties that aren't exactly
1971da6c28aaSamw * name/value pairs, we may need to
1972da6c28aaSamw * interpret/transform.
1973da6c28aaSamw */
1974da6c28aaSamw if (value != NULL)
1975da6c28aaSamw len += 1 + strlen(value);
1976da6c28aaSamw
1977da6c28aaSamw while (buffsize <= (curlen + len)) {
1978da6c28aaSamw /* need more room */
1979da6c28aaSamw buffsize += incr;
1980da6c28aaSamw buff = realloc(buff, buffsize);
1981da6c28aaSamw *rbuff = buff;
1982da6c28aaSamw *rbuffsize = buffsize;
1983da6c28aaSamw if (buff == NULL) {
1984da6c28aaSamw /* realloc failed so free everything */
1985da6c28aaSamw if (*rbuff != NULL)
1986da6c28aaSamw free(*rbuff);
1987da6c28aaSamw goto err;
1988da6c28aaSamw }
1989da6c28aaSamw }
1990da6c28aaSamw if (buff == NULL)
1991da6c28aaSamw goto err;
1992da6c28aaSamw (void) snprintf(buff + curlen, buffsize - curlen,
1993da6c28aaSamw "%s%s=%s", sep ? "," : "",
1994da6c28aaSamw name, value != NULL ? value : "\"\"");
1995da6c28aaSamw
1996da6c28aaSamw }
1997da6c28aaSamw err:
1998da6c28aaSamw if (name != NULL)
1999da6c28aaSamw sa_free_attr_string(name);
2000da6c28aaSamw if (value != NULL)
2001da6c28aaSamw sa_free_attr_string(value);
2002da6c28aaSamw }
2003da6c28aaSamw
2004da6c28aaSamw /*
2005da6c28aaSamw * smb_format_resource_options(resource, hier)
2006da6c28aaSamw *
2007da6c28aaSamw * format all the options on the group into a flattened option
2008da6c28aaSamw * string. If hier is non-zero, walk up the tree to get inherited
2009da6c28aaSamw * options.
2010da6c28aaSamw */
2011da6c28aaSamw
2012da6c28aaSamw static char *
smb_format_options(sa_group_t group,int hier)2013da6c28aaSamw smb_format_options(sa_group_t group, int hier)
2014da6c28aaSamw {
2015da6c28aaSamw sa_optionset_t options = NULL;
2016da6c28aaSamw sa_property_t prop;
2017da6c28aaSamw int sep = 0;
2018da6c28aaSamw char *buff;
2019da6c28aaSamw size_t buffsize;
2020da6c28aaSamw
2021da6c28aaSamw
2022da6c28aaSamw buff = malloc(OPT_CHUNK);
2023da6c28aaSamw if (buff == NULL)
2024da6c28aaSamw return (NULL);
2025da6c28aaSamw
2026da6c28aaSamw buff[0] = '\0';
2027da6c28aaSamw buffsize = OPT_CHUNK;
2028da6c28aaSamw
2029da6c28aaSamw /*
2030da6c28aaSamw * We may have a an optionset relative to this item. format
2031da6c28aaSamw * these if we find them and then add any security definitions.
2032da6c28aaSamw */
2033da6c28aaSamw
2034da6c28aaSamw options = sa_get_derived_optionset(group, "smb", hier);
2035da6c28aaSamw
2036da6c28aaSamw /*
2037da6c28aaSamw * do the default set first but skip any option that is also
2038da6c28aaSamw * in the protocol specific optionset.
2039da6c28aaSamw */
2040da6c28aaSamw if (options != NULL) {
2041da6c28aaSamw for (prop = sa_get_property(options, NULL);
2042da6c28aaSamw prop != NULL; prop = sa_get_next_property(prop)) {
2043da6c28aaSamw /*
2044da6c28aaSamw * use this one since we skipped any
2045da6c28aaSamw * of these that were also in
2046da6c28aaSamw * optdefault
2047da6c28aaSamw */
2048da6c28aaSamw smb_sprint_option(&buff, &buffsize, OPT_CHUNK,
2049da6c28aaSamw prop, sep);
2050da6c28aaSamw if (buff == NULL) {
2051da6c28aaSamw /*
2052da6c28aaSamw * buff could become NULL if there
2053da6c28aaSamw * isn't enough memory for
2054da6c28aaSamw * smb_sprint_option to realloc()
2055da6c28aaSamw * as necessary. We can't really
2056da6c28aaSamw * do anything about it at this
2057da6c28aaSamw * point so we return NULL. The
2058da6c28aaSamw * caller should handle the
2059da6c28aaSamw * failure.
2060da6c28aaSamw */
2061da6c28aaSamw if (options != NULL)
2062da6c28aaSamw sa_free_derived_optionset(
2063da6c28aaSamw options);
2064da6c28aaSamw return (buff);
2065da6c28aaSamw }
2066da6c28aaSamw sep = 1;
2067da6c28aaSamw }
2068da6c28aaSamw }
2069da6c28aaSamw
2070da6c28aaSamw if (options != NULL)
2071da6c28aaSamw sa_free_derived_optionset(options);
2072da6c28aaSamw return (buff);
2073da6c28aaSamw }
2074da6c28aaSamw
2075da6c28aaSamw /*
2076da6c28aaSamw * smb_rename_resource(resource, newname)
2077da6c28aaSamw *
2078da6c28aaSamw * Change the current exported name of the resource to newname.
2079da6c28aaSamw */
2080da6c28aaSamw /*ARGSUSED*/
2081da6c28aaSamw int
smb_rename_resource(sa_handle_t handle,sa_resource_t resource,char * newname)2082da6c28aaSamw smb_rename_resource(sa_handle_t handle, sa_resource_t resource, char *newname)
2083da6c28aaSamw {
2084da6c28aaSamw int ret = SA_OK;
2085da6c28aaSamw int err;
2086da6c28aaSamw char *oldname;
2087da6c28aaSamw
2088c8ec8eeaSjose borrego if (!smb_isonline())
2089c8ec8eeaSjose borrego return (SA_OK);
2090c8ec8eeaSjose borrego
2091da6c28aaSamw oldname = sa_get_resource_attr(resource, "name");
2092da6c28aaSamw if (oldname == NULL)
2093da6c28aaSamw return (SA_NO_SUCH_RESOURCE);
2094da6c28aaSamw
2095c8ec8eeaSjose borrego err = smb_share_rename(oldname, newname);
2096da6c28aaSamw
2097fe1c642dSBill Krier sa_free_attr_string(oldname);
2098fe1c642dSBill Krier
2099da6c28aaSamw /* improve error values somewhat */
2100da6c28aaSamw switch (err) {
2101da6c28aaSamw case NERR_Success:
2102da6c28aaSamw break;
2103da6c28aaSamw case NERR_InternalError:
2104da6c28aaSamw ret = SA_SYSTEM_ERR;
2105da6c28aaSamw break;
2106da6c28aaSamw case NERR_DuplicateShare:
2107da6c28aaSamw ret = SA_DUPLICATE_NAME;
2108da6c28aaSamw break;
2109da6c28aaSamw default:
2110da6c28aaSamw ret = SA_CONFIG_ERR;
2111da6c28aaSamw break;
2112da6c28aaSamw }
2113da6c28aaSamw
2114da6c28aaSamw return (ret);
2115da6c28aaSamw }
2116c8ec8eeaSjose borrego
2117c8ec8eeaSjose borrego static int
smb_build_shareinfo(sa_share_t share,sa_resource_t resource,smb_share_t * si)2118c8ec8eeaSjose borrego smb_build_shareinfo(sa_share_t share, sa_resource_t resource, smb_share_t *si)
2119c8ec8eeaSjose borrego {
2120c8ec8eeaSjose borrego sa_optionset_t opts;
2121c8ec8eeaSjose borrego char *path;
2122c8ec8eeaSjose borrego char *rname;
2123c8ec8eeaSjose borrego char *val = NULL;
21249fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States char csc_value[SMB_CSC_BUFSZ];
21251160dcf7SMatt Barden char strbuf[sizeof ("required")];
2126c8ec8eeaSjose borrego
2127c8ec8eeaSjose borrego bzero(si, sizeof (smb_share_t));
2128c8ec8eeaSjose borrego
2129c8ec8eeaSjose borrego if ((path = sa_get_share_attr(share, "path")) == NULL)
2130c8ec8eeaSjose borrego return (SA_NO_SUCH_PATH);
2131c8ec8eeaSjose borrego
2132c8ec8eeaSjose borrego if ((rname = sa_get_resource_attr(resource, "name")) == NULL) {
2133c8ec8eeaSjose borrego sa_free_attr_string(path);
2134c8ec8eeaSjose borrego return (SA_NO_SUCH_RESOURCE);
2135c8ec8eeaSjose borrego }
2136c8ec8eeaSjose borrego
2137c8ec8eeaSjose borrego (void) strlcpy(si->shr_path, path, sizeof (si->shr_path));
2138c8ec8eeaSjose borrego (void) strlcpy(si->shr_name, rname, sizeof (si->shr_name));
2139c8ec8eeaSjose borrego sa_free_attr_string(path);
2140c8ec8eeaSjose borrego sa_free_attr_string(rname);
2141c8ec8eeaSjose borrego
2142c8ec8eeaSjose borrego val = sa_get_resource_description(resource);
2143c8ec8eeaSjose borrego if (val == NULL)
2144c8ec8eeaSjose borrego val = sa_get_share_description(share);
2145c8ec8eeaSjose borrego
2146c8ec8eeaSjose borrego if (val != NULL) {
2147c8ec8eeaSjose borrego (void) strlcpy(si->shr_cmnt, val, sizeof (si->shr_cmnt));
2148c8ec8eeaSjose borrego sa_free_share_description(val);
2149c8ec8eeaSjose borrego }
2150c8ec8eeaSjose borrego
21519fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States si->shr_flags = (sa_is_persistent(share))
21529fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States ? SMB_SHRF_PERM : SMB_SHRF_TRANS;
21539fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
2154c8ec8eeaSjose borrego opts = sa_get_derived_optionset(resource, SMB_PROTOCOL_NAME, 1);
2155c8ec8eeaSjose borrego if (opts == NULL)
2156c8ec8eeaSjose borrego return (SA_OK);
2157c8ec8eeaSjose borrego
2158ca5fb90aSGordon Ross if (smb_saprop_getbool(opts, SHOPT_CATIA, B_FALSE))
21598b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States si->shr_flags |= SMB_SHRF_CATIA;
21608b2cc8acSafshin salek ardakani - Sun Microsystems - Irvine United States
2161ca5fb90aSGordon Ross if (smb_saprop_getbool(opts, SHOPT_ABE, B_FALSE))
2162e3f2c991SKeyur Desai si->shr_flags |= SMB_SHRF_ABE;
2163e3f2c991SKeyur Desai
2164ca5fb90aSGordon Ross if (smb_saprop_getbool(opts, SHOPT_GUEST, B_FALSE))
216529bd2886SAlan Wright si->shr_flags |= SMB_SHRF_GUEST_OK;
216629bd2886SAlan Wright
2167ca5fb90aSGordon Ross if (smb_saprop_getbool(opts, SHOPT_DFSROOT, B_FALSE))
21689fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States si->shr_flags |= SMB_SHRF_DFSROOT;
21699fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
21708d94f651SGordon Ross if (smb_saprop_getbool(opts, SHOPT_CA, B_FALSE))
21718d94f651SGordon Ross si->shr_flags |= SMB_SHRF_CA;
21728d94f651SGordon Ross
217394047d49SGordon Ross if (smb_saprop_getbool(opts, SHOPT_FSO, B_FALSE))
217494047d49SGordon Ross si->shr_flags |= SMB_SHRF_FSO;
217594047d49SGordon Ross
2176ca5fb90aSGordon Ross /* Quotas are enabled by default. */
21771160dcf7SMatt Barden if (smb_saprop_getbool(opts, SHOPT_QUOTAS, B_TRUE))
2178ca5fb90aSGordon Ross si->shr_flags |= SMB_SHRF_QUOTAS;
21791160dcf7SMatt Barden
21801160dcf7SMatt Barden if (smb_saprop_getstr(opts, SHOPT_ENCRYPT, strbuf, sizeof (strbuf)))
21811160dcf7SMatt Barden smb_cfg_set_require(strbuf, &si->shr_encrypt);
2182ca5fb90aSGordon Ross
21839fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States (void) smb_saprop_getstr(opts, SHOPT_AD_CONTAINER, si->shr_container,
21849fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States sizeof (si->shr_container));
21859fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
21869fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States if (smb_saprop_getstr(opts, SHOPT_CSC, csc_value, sizeof (csc_value)))
21879fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_csc_option(csc_value, si);
21889fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
21899fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States if (smb_saprop_getstr(opts, SHOPT_RO, si->shr_access_ro,
21909fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States sizeof (si->shr_access_ro)))
2191b89a8333Snatalie li - Sun Microsystems - Irvine United States si->shr_flags |= SMB_SHRF_ACC_RO;
2192b89a8333Snatalie li - Sun Microsystems - Irvine United States
21939fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States if (smb_saprop_getstr(opts, SHOPT_RW, si->shr_access_rw,
21949fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States sizeof (si->shr_access_rw)))
2195b89a8333Snatalie li - Sun Microsystems - Irvine United States si->shr_flags |= SMB_SHRF_ACC_RW;
2196b89a8333Snatalie li - Sun Microsystems - Irvine United States
21979fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States if (smb_saprop_getstr(opts, SHOPT_NONE, si->shr_access_none,
21989fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States sizeof (si->shr_access_none)))
2199b89a8333Snatalie li - Sun Microsystems - Irvine United States si->shr_flags |= SMB_SHRF_ACC_NONE;
2200b89a8333Snatalie li - Sun Microsystems - Irvine United States
2201c8ec8eeaSjose borrego sa_free_derived_optionset(opts);
2202c8ec8eeaSjose borrego return (SA_OK);
2203c8ec8eeaSjose borrego }
2204c8ec8eeaSjose borrego
2205c8ec8eeaSjose borrego /*
22068d7e4166Sjose borrego * Map a client-side caching (CSC) option to the appropriate share
22078d7e4166Sjose borrego * flag. Only one option is allowed; an error will be logged if
22088d7e4166Sjose borrego * multiple options have been specified. We don't need to do anything
22098d7e4166Sjose borrego * about multiple values here because the SRVSVC will not recognize
22108d7e4166Sjose borrego * a value containing multiple flags and will return the default value.
22118d7e4166Sjose borrego *
22128d7e4166Sjose borrego * If the option value is not recognized, it will be ignored: invalid
22138d7e4166Sjose borrego * values will typically be caught and rejected by sharemgr.
22148d7e4166Sjose borrego */
22158d7e4166Sjose borrego static void
smb_csc_option(const char * value,smb_share_t * si)22168d7e4166Sjose borrego smb_csc_option(const char *value, smb_share_t *si)
22178d7e4166Sjose borrego {
22188d7e4166Sjose borrego char buf[SMB_CSC_BUFSZ];
22198d7e4166Sjose borrego int i;
22208d7e4166Sjose borrego
22218d7e4166Sjose borrego for (i = 0; i < (sizeof (cscopt) / sizeof (cscopt[0])); ++i) {
22228d7e4166Sjose borrego if (strcasecmp(value, cscopt[i].value) == 0) {
22238d7e4166Sjose borrego si->shr_flags |= cscopt[i].flag;
22248d7e4166Sjose borrego break;
22258d7e4166Sjose borrego }
22268d7e4166Sjose borrego }
22278d7e4166Sjose borrego
22288d7e4166Sjose borrego switch (si->shr_flags & SMB_SHRF_CSC_MASK) {
22298d7e4166Sjose borrego case 0:
22308d7e4166Sjose borrego case SMB_SHRF_CSC_DISABLED:
22318d7e4166Sjose borrego case SMB_SHRF_CSC_MANUAL:
22328d7e4166Sjose borrego case SMB_SHRF_CSC_AUTO:
22338d7e4166Sjose borrego case SMB_SHRF_CSC_VDO:
22348d7e4166Sjose borrego break;
22358d7e4166Sjose borrego
22368d7e4166Sjose borrego default:
22378d7e4166Sjose borrego buf[0] = '\0';
22388d7e4166Sjose borrego
22398d7e4166Sjose borrego for (i = 0; i < (sizeof (cscopt) / sizeof (cscopt[0])); ++i) {
22408d7e4166Sjose borrego if (si->shr_flags & cscopt[i].flag) {
22418d7e4166Sjose borrego (void) strlcat(buf, " ", SMB_CSC_BUFSZ);
22428d7e4166Sjose borrego (void) strlcat(buf, cscopt[i].value,
22438d7e4166Sjose borrego SMB_CSC_BUFSZ);
22448d7e4166Sjose borrego }
22458d7e4166Sjose borrego }
22468d7e4166Sjose borrego
22478d7e4166Sjose borrego syslog(LOG_ERR, "csc option conflict:%s", buf);
22488d7e4166Sjose borrego break;
22498d7e4166Sjose borrego }
22508d7e4166Sjose borrego }
22518d7e4166Sjose borrego
22528d7e4166Sjose borrego /*
225389dc44ceSjose borrego * Return the option name for the first CSC flag (there should be only
225489dc44ceSjose borrego * one) encountered in the share flags.
225589dc44ceSjose borrego */
225689dc44ceSjose borrego static char *
smb_csc_name(const smb_share_t * si)225789dc44ceSjose borrego smb_csc_name(const smb_share_t *si)
225889dc44ceSjose borrego {
225989dc44ceSjose borrego int i;
226089dc44ceSjose borrego
226189dc44ceSjose borrego for (i = 0; i < (sizeof (cscopt) / sizeof (cscopt[0])); ++i) {
226289dc44ceSjose borrego if (si->shr_flags & cscopt[i].flag)
226389dc44ceSjose borrego return (cscopt[i].value);
226489dc44ceSjose borrego }
226589dc44ceSjose borrego
226689dc44ceSjose borrego return (NULL);
226789dc44ceSjose borrego }
226889dc44ceSjose borrego
226989dc44ceSjose borrego /*
2270c8ec8eeaSjose borrego * smb_get_defaultgrp
2271c8ec8eeaSjose borrego *
2272c8ec8eeaSjose borrego * If default group for CIFS shares (i.e. "smb") exists
2273c8ec8eeaSjose borrego * then it will return the group handle, otherwise it will
2274c8ec8eeaSjose borrego * create the group and return the handle.
2275c8ec8eeaSjose borrego *
2276c8ec8eeaSjose borrego * All the shares created by CIFS clients (this is only possible
2277c8ec8eeaSjose borrego * via RPC) will be added to "smb" groups.
2278c8ec8eeaSjose borrego */
2279c8ec8eeaSjose borrego static sa_group_t
smb_get_defaultgrp(sa_handle_t handle)2280c8ec8eeaSjose borrego smb_get_defaultgrp(sa_handle_t handle)
2281c8ec8eeaSjose borrego {
2282c8ec8eeaSjose borrego sa_group_t group = NULL;
2283c8ec8eeaSjose borrego int err;
2284c8ec8eeaSjose borrego
2285c8ec8eeaSjose borrego group = sa_get_group(handle, SMB_DEFAULT_SHARE_GROUP);
2286c8ec8eeaSjose borrego if (group != NULL)
2287c8ec8eeaSjose borrego return (group);
2288c8ec8eeaSjose borrego
2289c8ec8eeaSjose borrego group = sa_create_group(handle, SMB_DEFAULT_SHARE_GROUP, &err);
2290c8ec8eeaSjose borrego if (group == NULL)
2291c8ec8eeaSjose borrego return (NULL);
2292c8ec8eeaSjose borrego
2293c8ec8eeaSjose borrego if (sa_create_optionset(group, SMB_DEFAULT_SHARE_GROUP) == NULL) {
2294c8ec8eeaSjose borrego (void) sa_remove_group(group);
2295c8ec8eeaSjose borrego group = NULL;
2296c8ec8eeaSjose borrego }
2297c8ec8eeaSjose borrego
2298c8ec8eeaSjose borrego return (group);
2299c8ec8eeaSjose borrego }
230029bd2886SAlan Wright
230129bd2886SAlan Wright /*
230229bd2886SAlan Wright * Checks to see if the command args are the supported substitution specifier.
230329bd2886SAlan Wright * i.e. <cmd> %U %S
230429bd2886SAlan Wright */
230529bd2886SAlan Wright static int
cmd_validator(int index,char * value)230629bd2886SAlan Wright cmd_validator(int index, char *value)
230729bd2886SAlan Wright {
230829bd2886SAlan Wright char cmd[MAXPATHLEN];
230929bd2886SAlan Wright char *ptr, *v;
231029bd2886SAlan Wright boolean_t skip_cmdname;
231129bd2886SAlan Wright
231229bd2886SAlan Wright if (string_length_check_validator(index, value) != SA_OK)
231329bd2886SAlan Wright return (SA_BAD_VALUE);
231429bd2886SAlan Wright
231529bd2886SAlan Wright if (*value == '\0')
231629bd2886SAlan Wright return (SA_OK);
231729bd2886SAlan Wright
231829bd2886SAlan Wright (void) strlcpy(cmd, value, sizeof (cmd));
231929bd2886SAlan Wright
232029bd2886SAlan Wright ptr = cmd;
232129bd2886SAlan Wright skip_cmdname = B_TRUE;
232229bd2886SAlan Wright do {
232329bd2886SAlan Wright if ((v = strsep(&ptr, " ")) == NULL)
232429bd2886SAlan Wright break;
232529bd2886SAlan Wright
232629bd2886SAlan Wright if (*v != '\0') {
232729bd2886SAlan Wright
232829bd2886SAlan Wright if (skip_cmdname) {
232929bd2886SAlan Wright skip_cmdname = B_FALSE;
233029bd2886SAlan Wright continue;
233129bd2886SAlan Wright }
233229bd2886SAlan Wright
233329bd2886SAlan Wright if ((strlen(v) != 2) || *v != '%')
233429bd2886SAlan Wright return (SA_BAD_VALUE);
233529bd2886SAlan Wright
233629bd2886SAlan Wright if (strpbrk(v, SMB_VALID_SUB_CHRS) == NULL)
233729bd2886SAlan Wright return (SA_BAD_VALUE);
233829bd2886SAlan Wright }
233929bd2886SAlan Wright
234029bd2886SAlan Wright } while (v != NULL);
234129bd2886SAlan Wright
234229bd2886SAlan Wright /*
234329bd2886SAlan Wright * If skip_cmdname is still true then the string contains
234429bd2886SAlan Wright * only spaces. Don't allow such a string.
234529bd2886SAlan Wright */
234629bd2886SAlan Wright if (skip_cmdname)
234729bd2886SAlan Wright return (SA_BAD_VALUE);
234829bd2886SAlan Wright
234929bd2886SAlan Wright return (SA_OK);
235029bd2886SAlan Wright }
235129bd2886SAlan Wright
235229bd2886SAlan Wright /*ARGSUSED*/
235329bd2886SAlan Wright static int
disposition_validator(int index,char * value)235429bd2886SAlan Wright disposition_validator(int index, char *value)
235529bd2886SAlan Wright {
235629bd2886SAlan Wright if (value == NULL)
235729bd2886SAlan Wright return (SA_BAD_VALUE);
235829bd2886SAlan Wright
235929bd2886SAlan Wright if (*value == '\0')
236029bd2886SAlan Wright return (SA_OK);
236129bd2886SAlan Wright
2362148c5f43SAlan Wright if ((strcasecmp(value, SMB_EXEC_DISP_CONTINUE) == 0) ||
2363148c5f43SAlan Wright (strcasecmp(value, SMB_EXEC_DISP_TERMINATE) == 0))
236429bd2886SAlan Wright return (SA_OK);
236529bd2886SAlan Wright
236629bd2886SAlan Wright return (SA_BAD_VALUE);
236729bd2886SAlan Wright }
236896a62adaSjoyce mcintosh
2369a90cf9f2SGordon Ross static int
protocol_validator(int index,char * value)23703e2c0c09SMatt Barden protocol_validator(int index, char *value)
2371a90cf9f2SGordon Ross {
237276b0ca5aSGordon Ross struct smb_proto_option_defs *opt;
237376b0ca5aSGordon Ross smb_cfg_val_t encrypt;
237476b0ca5aSGordon Ross uint32_t max;
237576b0ca5aSGordon Ross uint32_t min;
237676b0ca5aSGordon Ross uint32_t val;
237776b0ca5aSGordon Ross
2378a90cf9f2SGordon Ross if (value == NULL)
2379a90cf9f2SGordon Ross return (SA_BAD_VALUE);
2380a90cf9f2SGordon Ross
238176b0ca5aSGordon Ross /* Allow setting back to empty (use defaults) */
2382a90cf9f2SGordon Ross if (*value == '\0')
2383a90cf9f2SGordon Ross return (SA_OK);
2384a90cf9f2SGordon Ross
238576b0ca5aSGordon Ross val = smb_convert_version_str(value);
238676b0ca5aSGordon Ross if (val == 0)
2387a90cf9f2SGordon Ross return (SA_BAD_VALUE);
2388a90cf9f2SGordon Ross
238976b0ca5aSGordon Ross /*
239076b0ca5aSGordon Ross * We don't want people who care enough about protecting their data
239176b0ca5aSGordon Ross * by requiring encryption to accidentally expose their data by
239276b0ca5aSGordon Ross * lowering the max protocol, so prevent them from going below 3.0
239376b0ca5aSGordon Ross * if encryption is required.
239476b0ca5aSGordon Ross * Also, ensure that max_protocol >= min_protocol.
239576b0ca5aSGordon Ross */
239676b0ca5aSGordon Ross opt = &smb_proto_options[index];
239776b0ca5aSGordon Ross switch (opt->smb_index) {
239876b0ca5aSGordon Ross
239976b0ca5aSGordon Ross case SMB_CI_MAX_PROTOCOL:
240076b0ca5aSGordon Ross
240176b0ca5aSGordon Ross encrypt = smb_config_get_require(SMB_CI_ENCRYPT);
240276b0ca5aSGordon Ross if (encrypt == SMB_CONFIG_REQUIRED && val < SMB_VERS_3_0) {
240376b0ca5aSGordon Ross syslog(LOG_ERR, "Cannot set smbd/max_protocol below 3.0"
240476b0ca5aSGordon Ross " while smbd/encrypt == required.");
240576b0ca5aSGordon Ross return (SA_VALUE_CONFLICT);
240676b0ca5aSGordon Ross }
240776b0ca5aSGordon Ross min = smb_config_get_min_protocol();
240876b0ca5aSGordon Ross if (val < min) {
240976b0ca5aSGordon Ross syslog(LOG_ERR, "Cannot set smbd/max_protocol to less"
241076b0ca5aSGordon Ross " than smbd/min_protocol.");
241176b0ca5aSGordon Ross return (SA_VALUE_CONFLICT);
241276b0ca5aSGordon Ross }
241376b0ca5aSGordon Ross break;
241476b0ca5aSGordon Ross
241576b0ca5aSGordon Ross case SMB_CI_MIN_PROTOCOL:
241676b0ca5aSGordon Ross
241776b0ca5aSGordon Ross max = smb_config_get_max_protocol();
241876b0ca5aSGordon Ross if (val > max) {
241976b0ca5aSGordon Ross syslog(LOG_ERR, "Cannot set smbd/min_protocol to more"
242076b0ca5aSGordon Ross " than smbd/max_protocol.");
242176b0ca5aSGordon Ross return (SA_VALUE_CONFLICT);
242276b0ca5aSGordon Ross }
242376b0ca5aSGordon Ross break;
242476b0ca5aSGordon Ross
242576b0ca5aSGordon Ross default:
242676b0ca5aSGordon Ross syslog(LOG_ERR, "Unexpected smb protocol validator index %d",
242776b0ca5aSGordon Ross opt->smb_index);
242876b0ca5aSGordon Ross return (SA_BAD_VALUE);
242976b0ca5aSGordon Ross }
243076b0ca5aSGordon Ross
243176b0ca5aSGordon Ross return (SA_OK);
2432a90cf9f2SGordon Ross }
2433a90cf9f2SGordon Ross
2434b0bb0d63SGordon Ross /*ARGSUSED*/
2435b0bb0d63SGordon Ross static int
ciphers_validator(int index,char * value)2436b0bb0d63SGordon Ross ciphers_validator(int index, char *value)
2437b0bb0d63SGordon Ross {
2438b0bb0d63SGordon Ross
2439b0bb0d63SGordon Ross if (value == NULL)
2440b0bb0d63SGordon Ross return (SA_BAD_VALUE);
2441b0bb0d63SGordon Ross
2442b0bb0d63SGordon Ross /* Allow setting back to empty (use defaults) */
2443b0bb0d63SGordon Ross if (*value == '\0')
2444b0bb0d63SGordon Ross return (SA_OK);
2445b0bb0d63SGordon Ross
2446b0bb0d63SGordon Ross if (smb_convert_encrypt_ciphers(value) <= 0)
2447b0bb0d63SGordon Ross return (SA_BAD_VALUE);
2448b0bb0d63SGordon Ross
2449b0bb0d63SGordon Ross return (SA_OK);
2450b0bb0d63SGordon Ross }
2451b0bb0d63SGordon Ross
245296a62adaSjoyce mcintosh /*
245396a62adaSjoyce mcintosh * Updates the optionset properties of the share resource.
245496a62adaSjoyce mcintosh * The properties are given as a list of name-value pair.
245596a62adaSjoyce mcintosh * The name argument should be the optionset property name and the value
245696a62adaSjoyce mcintosh * should be a valid value for the specified property.
2457c5866007SKeyur Desai *
2458c5866007SKeyur Desai * When calling this function for permanent shares, the caller must also
2459c5866007SKeyur Desai * call sa_commit_properties() to commit the changes to SMF.
246096a62adaSjoyce mcintosh */
246196a62adaSjoyce mcintosh static int
smb_update_optionset_props(sa_handle_t handle,sa_resource_t resource,nvlist_t * nvl)246296a62adaSjoyce mcintosh smb_update_optionset_props(sa_handle_t handle, sa_resource_t resource,
246396a62adaSjoyce mcintosh nvlist_t *nvl)
246496a62adaSjoyce mcintosh {
246596a62adaSjoyce mcintosh sa_property_t prop;
246696a62adaSjoyce mcintosh sa_optionset_t opts;
246796a62adaSjoyce mcintosh int err = SA_OK;
246896a62adaSjoyce mcintosh nvpair_t *cur;
246996a62adaSjoyce mcintosh char *name, *val;
247096a62adaSjoyce mcintosh
247196a62adaSjoyce mcintosh if ((opts = sa_get_optionset(resource, SMB_PROTOCOL_NAME)) == NULL) {
247296a62adaSjoyce mcintosh opts = sa_create_optionset(resource, SMB_PROTOCOL_NAME);
247396a62adaSjoyce mcintosh if (opts == NULL)
247496a62adaSjoyce mcintosh return (SA_CONFIG_ERR);
247596a62adaSjoyce mcintosh }
247696a62adaSjoyce mcintosh
247796a62adaSjoyce mcintosh cur = nvlist_next_nvpair(nvl, NULL);
247896a62adaSjoyce mcintosh while (cur != NULL) {
247996a62adaSjoyce mcintosh name = nvpair_name(cur);
248096a62adaSjoyce mcintosh err = nvpair_value_string(cur, &val);
248196a62adaSjoyce mcintosh if ((err != 0) || (name == NULL) || (val == NULL)) {
248296a62adaSjoyce mcintosh err = SA_CONFIG_ERR;
248396a62adaSjoyce mcintosh break;
248496a62adaSjoyce mcintosh }
248596a62adaSjoyce mcintosh
248696a62adaSjoyce mcintosh prop = NULL;
248796a62adaSjoyce mcintosh if ((prop = sa_get_property(opts, name)) == NULL) {
248896a62adaSjoyce mcintosh prop = sa_create_property(name, val);
248996a62adaSjoyce mcintosh if (prop != NULL) {
249096a62adaSjoyce mcintosh err = sa_valid_property(handle, opts,
249196a62adaSjoyce mcintosh SMB_PROTOCOL_NAME, prop);
249296a62adaSjoyce mcintosh if (err != SA_OK) {
249396a62adaSjoyce mcintosh (void) sa_remove_property(prop);
249496a62adaSjoyce mcintosh break;
249596a62adaSjoyce mcintosh }
249696a62adaSjoyce mcintosh }
249796a62adaSjoyce mcintosh err = sa_add_property(opts, prop);
249896a62adaSjoyce mcintosh if (err != SA_OK)
249996a62adaSjoyce mcintosh break;
250096a62adaSjoyce mcintosh } else {
250196a62adaSjoyce mcintosh err = sa_update_property(prop, val);
250296a62adaSjoyce mcintosh if (err != SA_OK)
250396a62adaSjoyce mcintosh break;
250496a62adaSjoyce mcintosh }
250596a62adaSjoyce mcintosh
250696a62adaSjoyce mcintosh cur = nvlist_next_nvpair(nvl, cur);
250796a62adaSjoyce mcintosh }
250896a62adaSjoyce mcintosh
250996a62adaSjoyce mcintosh return (err);
251096a62adaSjoyce mcintosh }
25119fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
25129fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States static boolean_t
smb_saprop_getbool(sa_optionset_t opts,char * propname,boolean_t def)2513ca5fb90aSGordon Ross smb_saprop_getbool(sa_optionset_t opts, char *propname, boolean_t def)
25149fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States {
25159fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States sa_property_t prop;
25169fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States char *val;
2517ca5fb90aSGordon Ross boolean_t ret = def;
25189fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
25199fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States prop = sa_get_property(opts, propname);
25209fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States if ((val = sa_get_property_attr(prop, "value")) != NULL) {
2521ca5fb90aSGordon Ross if (def) {
2522ca5fb90aSGordon Ross /* Default is true, ret false if... */
2523ca5fb90aSGordon Ross if ((strcasecmp(val, "false") == 0) ||
2524ca5fb90aSGordon Ross (strcmp(val, "0") == 0))
2525ca5fb90aSGordon Ross ret = B_FALSE;
2526ca5fb90aSGordon Ross } else {
2527ca5fb90aSGordon Ross /* Default is false, ret true if... */
2528ca5fb90aSGordon Ross if ((strcasecmp(val, "true") == 0) ||
2529ca5fb90aSGordon Ross (strcmp(val, "1") == 0))
2530ca5fb90aSGordon Ross ret = B_TRUE;
2531ca5fb90aSGordon Ross }
25329fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States free(val);
25339fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States }
25349fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
2535ca5fb90aSGordon Ross return (ret);
25369fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States }
25379fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
25389fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States static boolean_t
smb_saprop_getstr(sa_optionset_t opts,char * propname,char * buf,size_t bufsz)25399fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States smb_saprop_getstr(sa_optionset_t opts, char *propname, char *buf, size_t bufsz)
25409fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States {
25419fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States sa_property_t prop;
25429fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States char *val;
25439fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
25449fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States prop = sa_get_property(opts, propname);
25459fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States if ((val = sa_get_property_attr(prop, "value")) != NULL) {
25469fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States (void) strlcpy(buf, val, bufsz);
25479fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States free(val);
25489fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States return (B_TRUE);
25499fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States }
25509fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States
25519fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States return (B_FALSE);
25529fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States }
2553