xref: /illumos-gate/usr/src/lib/smbsrv/libsmb/common/smb_cfg.c (revision 628e3cbed6489fa1db545d8524a06cd6535af456) 
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #pragma ident	"@(#)smb_cfg.c	1.5	08/07/08 SMI"
27 
28 /*
29  * CIFS configuration management library
30  */
31 
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <unistd.h>
35 #include <synch.h>
36 #include <string.h>
37 #include <strings.h>
38 #include <syslog.h>
39 #include <netdb.h>
40 #include <ctype.h>
41 #include <sys/types.h>
42 #include <libscf.h>
43 #include <assert.h>
44 #include <smbsrv/libsmb.h>
45 
46 typedef struct smb_cfg_param {
47 	smb_cfg_id_t sc_id;
48 	char *sc_name;
49 	int sc_type;
50 	uint32_t sc_flags;
51 } smb_cfg_param_t;
52 
53 /*
54  * config parameter flags
55  */
56 #define	SMB_CF_PROTECTED	0x01
57 
58 /* idmap SMF fmri and Property Group */
59 #define	IDMAP_FMRI_PREFIX		"system/idmap"
60 #define	MACHINE_SID			"machine_sid"
61 #define	IDMAP_DOMAIN			"domain_name"
62 #define	IDMAP_PG_NAME			"config"
63 
64 #define	SMB_SECMODE_WORKGRP_STR 	"workgroup"
65 #define	SMB_SECMODE_DOMAIN_STR  	"domain"
66 
67 #define	SMB_ENC_LEN	1024
68 #define	SMB_DEC_LEN	256
69 
70 static char *b64_data =
71 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
72 
73 static smb_cfg_param_t smb_cfg_table[] =
74 {
75 	/* Oplock configuration, Kernel Only */
76 	{SMB_CI_OPLOCK_ENABLE, "oplock_enable", SCF_TYPE_BOOLEAN, 0},
77 
78 	/* Autohome configuration */
79 	{SMB_CI_AUTOHOME_MAP, "autohome_map", SCF_TYPE_ASTRING, 0},
80 
81 	/* Domain/PDC configuration */
82 	{SMB_CI_DOMAIN_SID, "domain_sid", SCF_TYPE_ASTRING, 0},
83 	{SMB_CI_DOMAIN_MEMB, "domain_member", SCF_TYPE_BOOLEAN, 0},
84 	{SMB_CI_DOMAIN_NAME, "domain_name", SCF_TYPE_ASTRING, 0},
85 	{SMB_CI_DOMAIN_SRV, "pdc", SCF_TYPE_ASTRING, 0},
86 
87 	/* WINS configuration */
88 	{SMB_CI_WINS_SRV1, "wins_server_1", SCF_TYPE_ASTRING, 0},
89 	{SMB_CI_WINS_SRV2, "wins_server_2", SCF_TYPE_ASTRING, 0},
90 	{SMB_CI_WINS_EXCL, "wins_exclude", SCF_TYPE_ASTRING, 0},
91 
92 	/* RPC services configuration */
93 	{SMB_CI_SRVSVC_SHRSET_ENABLE, "srvsvc_sharesetinfo_enable",
94 	    SCF_TYPE_BOOLEAN, 0},
95 	{SMB_CI_MLRPC_KALIVE, "mlrpc_keep_alive_interval",
96 	    SCF_TYPE_INTEGER, 0},
97 
98 	/* Kmod specific configuration */
99 	{SMB_CI_MAX_WORKERS, "max_workers", SCF_TYPE_INTEGER, 0},
100 	{SMB_CI_MAX_CONNECTIONS, "max_connections", SCF_TYPE_INTEGER, 0},
101 	{SMB_CI_KEEPALIVE, "keep_alive", SCF_TYPE_INTEGER, 0},
102 	{SMB_CI_RESTRICT_ANON, "restrict_anonymous", SCF_TYPE_BOOLEAN, 0},
103 
104 	{SMB_CI_SIGNING_ENABLE, "signing_enabled", SCF_TYPE_BOOLEAN, 0},
105 	{SMB_CI_SIGNING_REQD, "signing_required", SCF_TYPE_BOOLEAN, 0},
106 
107 	/* Kmod tuning configuration */
108 	{SMB_CI_SYNC_ENABLE, "sync_enable", SCF_TYPE_BOOLEAN, 0},
109 
110 	/* SMBd configuration */
111 	{SMB_CI_SECURITY, "security", SCF_TYPE_ASTRING, 0},
112 	{SMB_CI_NBSCOPE, "netbios_scope", SCF_TYPE_ASTRING, 0},
113 	{SMB_CI_SYS_CMNT, "system_comment", SCF_TYPE_ASTRING, 0},
114 	{SMB_CI_LM_LEVEL, "lmauth_level", SCF_TYPE_INTEGER, 0},
115 
116 	/* ADS Configuration */
117 	{SMB_CI_ADS_SITE, "ads_site", SCF_TYPE_ASTRING, 0},
118 
119 	/* Dynamic DNS */
120 	{SMB_CI_DYNDNS_ENABLE, "ddns_enable", SCF_TYPE_BOOLEAN, 0},
121 
122 	{SMB_CI_MACHINE_PASSWD, "machine_passwd", SCF_TYPE_ASTRING,
123 	    SMB_CF_PROTECTED},
124 	{SMB_CI_KPASSWD_SRV, "kpasswd_server", SCF_TYPE_ASTRING,
125 	    0},
126 	{SMB_CI_KPASSWD_DOMAIN, "kpasswd_domain", SCF_TYPE_ASTRING,
127 	    0},
128 	{SMB_CI_KPASSWD_SEQNUM, "kpasswd_seqnum", SCF_TYPE_INTEGER,
129 	    0},
130 	{SMB_CI_NETLOGON_SEQNUM, "netlogon_seqnum", SCF_TYPE_INTEGER,
131 	    0}
132 
133 	/* SMB_CI_MAX */
134 };
135 
136 static smb_cfg_param_t *smb_config_getent(smb_cfg_id_t);
137 
138 static boolean_t smb_is_base64(unsigned char c);
139 static char *smb_base64_encode(char *str_to_encode);
140 static char *smb_base64_decode(char *encoded_str);
141 
142 char *
143 smb_config_getname(smb_cfg_id_t id)
144 {
145 	smb_cfg_param_t *cfg;
146 	cfg = smb_config_getent(id);
147 	return (cfg->sc_name);
148 }
149 
150 static boolean_t
151 smb_is_base64(unsigned char c)
152 {
153 	return (isalnum(c) || (c == '+') || (c == '/'));
154 }
155 
156 /*
157  * smb_base64_encode
158  *
159  * Encode a string using base64 algorithm.
160  * Caller should free the returned buffer when done.
161  */
162 static char *
163 smb_base64_encode(char *str_to_encode)
164 {
165 	int ret_cnt = 0;
166 	int i = 0, j = 0;
167 	char arr_3[3], arr_4[4];
168 	int len = strlen(str_to_encode);
169 	char *ret = malloc(SMB_ENC_LEN);
170 
171 	if (ret == NULL) {
172 		return (NULL);
173 	}
174 
175 	while (len--) {
176 		arr_3[i++] = *(str_to_encode++);
177 		if (i == 3) {
178 			arr_4[0] = (arr_3[0] & 0xfc) >> 2;
179 			arr_4[1] = ((arr_3[0] & 0x03) << 4) +
180 			    ((arr_3[1] & 0xf0) >> 4);
181 			arr_4[2] = ((arr_3[1] & 0x0f) << 2) +
182 			    ((arr_3[2] & 0xc0) >> 6);
183 			arr_4[3] = arr_3[2] & 0x3f;
184 
185 			for (i = 0; i < 4; i++)
186 				ret[ret_cnt++] = b64_data[arr_4[i]];
187 			i = 0;
188 		}
189 	}
190 
191 	if (i) {
192 		for (j = i; j < 3; j++)
193 			arr_3[j] = '\0';
194 
195 		arr_4[0] = (arr_3[0] & 0xfc) >> 2;
196 		arr_4[1] = ((arr_3[0] & 0x03) << 4) +
197 		    ((arr_3[1] & 0xf0) >> 4);
198 		arr_4[2] = ((arr_3[1] & 0x0f) << 2) +
199 		    ((arr_3[2] & 0xc0) >> 6);
200 		arr_4[3] = arr_3[2] & 0x3f;
201 
202 		for (j = 0; j < (i + 1); j++)
203 			ret[ret_cnt++] = b64_data[arr_4[j]];
204 
205 		while (i++ < 3)
206 			ret[ret_cnt++] = '=';
207 	}
208 
209 	ret[ret_cnt++] = '\0';
210 	return (ret);
211 }
212 
213 /*
214  * smb_base64_decode
215  *
216  * Decode using base64 algorithm.
217  * Caller should free the returned buffer when done.
218  */
219 static char *
220 smb_base64_decode(char *encoded_str)
221 {
222 	int len = strlen(encoded_str);
223 	int i = 0, j = 0;
224 	int en_ind = 0;
225 	char arr_4[4], arr_3[3];
226 	int ret_cnt = 0;
227 	char *ret = malloc(SMB_DEC_LEN);
228 	char *p;
229 
230 	if (ret == NULL) {
231 		return (NULL);
232 	}
233 
234 	while (len-- && (encoded_str[en_ind] != '=') &&
235 	    smb_is_base64(encoded_str[en_ind])) {
236 		arr_4[i++] = encoded_str[en_ind];
237 		en_ind++;
238 		if (i == 4) {
239 			for (i = 0; i < 4; i++) {
240 				if ((p = strchr(b64_data, arr_4[i])) == NULL)
241 					return (NULL);
242 
243 				arr_4[i] = (int)(p - b64_data);
244 			}
245 
246 			arr_3[0] = (arr_4[0] << 2) +
247 			    ((arr_4[1] & 0x30) >> 4);
248 			arr_3[1] = ((arr_4[1] & 0xf) << 4) +
249 			    ((arr_4[2] & 0x3c) >> 2);
250 			arr_3[2] = ((arr_4[2] & 0x3) << 6) +
251 			    arr_4[3];
252 
253 			for (i = 0; i < 3; i++)
254 				ret[ret_cnt++] = arr_3[i];
255 
256 			i = 0;
257 		}
258 	}
259 
260 	if (i) {
261 		for (j = i; j < 4; j++)
262 			arr_4[j] = 0;
263 
264 		for (j = 0; j < 4; j++) {
265 			if ((p = strchr(b64_data, arr_4[j])) == NULL)
266 				return (NULL);
267 
268 			arr_4[j] = (int)(p - b64_data);
269 		}
270 		arr_3[0] = (arr_4[0] << 2) +
271 		    ((arr_4[1] & 0x30) >> 4);
272 		arr_3[1] = ((arr_4[1] & 0xf) << 4) +
273 		    ((arr_4[2] & 0x3c) >> 2);
274 		arr_3[2] = ((arr_4[2] & 0x3) << 6) +
275 		    arr_4[3];
276 		for (j = 0; j < (i - 1); j++)
277 			ret[ret_cnt++] = arr_3[j];
278 	}
279 
280 	ret[ret_cnt++] = '\0';
281 	return (ret);
282 }
283 
284 static char *
285 smb_config_getenv_generic(char *name, char *svc_fmri_prefix, char *svc_propgrp)
286 {
287 	smb_scfhandle_t *handle;
288 	char *value;
289 
290 	if ((value = malloc(MAX_VALUE_BUFLEN * sizeof (char))) == NULL)
291 		return (NULL);
292 
293 	handle = smb_smf_scf_init(svc_fmri_prefix);
294 	if (handle == NULL) {
295 		free(value);
296 		return (NULL);
297 	}
298 
299 	(void) smb_smf_create_service_pgroup(handle, svc_propgrp);
300 
301 	if (smb_smf_get_string_property(handle, name, value,
302 	    sizeof (char) * MAX_VALUE_BUFLEN) != 0) {
303 		smb_smf_scf_fini(handle);
304 		free(value);
305 		return (NULL);
306 	}
307 
308 	smb_smf_scf_fini(handle);
309 	return (value);
310 
311 }
312 
313 static int
314 smb_config_setenv_generic(char *svc_fmri_prefix, char *svc_propgrp,
315     char *name, char *value)
316 {
317 	smb_scfhandle_t *handle = NULL;
318 	int rc = 0;
319 
320 
321 	handle = smb_smf_scf_init(svc_fmri_prefix);
322 	if (handle == NULL) {
323 		return (1);
324 	}
325 
326 	(void) smb_smf_create_service_pgroup(handle, svc_propgrp);
327 
328 	if (smb_smf_start_transaction(handle) != SMBD_SMF_OK) {
329 		smb_smf_scf_fini(handle);
330 		return (1);
331 	}
332 
333 	if (smb_smf_set_string_property(handle, name, value) != SMBD_SMF_OK)
334 		rc = 1;
335 
336 	if (smb_smf_end_transaction(handle) != SMBD_SMF_OK)
337 		rc = 1;
338 
339 	smb_smf_scf_fini(handle);
340 	return (rc);
341 }
342 
343 /*
344  * smb_config_getstr
345  *
346  * Fetch the specified string configuration item from SMF
347  */
348 int
349 smb_config_getstr(smb_cfg_id_t id, char *cbuf, int bufsz)
350 {
351 	smb_scfhandle_t *handle;
352 	smb_cfg_param_t *cfg;
353 	int rc = SMBD_SMF_OK;
354 
355 	*cbuf = '\0';
356 	cfg = smb_config_getent(id);
357 	assert(cfg->sc_type == SCF_TYPE_ASTRING);
358 
359 	handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
360 	if (handle == NULL)
361 		return (SMBD_SMF_SYSTEM_ERR);
362 
363 	if (cfg->sc_flags & SMB_CF_PROTECTED) {
364 		char protbuf[SMB_ENC_LEN];
365 		char *tmp;
366 
367 		if ((rc = smb_smf_create_service_pgroup(handle,
368 		    SMBD_PROTECTED_PG_NAME)) != SMBD_SMF_OK)
369 			goto error;
370 
371 		if ((rc = smb_smf_get_string_property(handle, cfg->sc_name,
372 		    protbuf, sizeof (protbuf))) != SMBD_SMF_OK)
373 			goto error;
374 
375 		if (*protbuf != '\0') {
376 			tmp = smb_base64_decode(protbuf);
377 			(void) strlcpy(cbuf, tmp, bufsz);
378 			free(tmp);
379 		}
380 	} else {
381 		rc = smb_smf_create_service_pgroup(handle, SMBD_PG_NAME);
382 		if (rc == SMBD_SMF_OK)
383 			rc = smb_smf_get_string_property(handle, cfg->sc_name,
384 			    cbuf, bufsz);
385 	}
386 
387 error:
388 	smb_smf_scf_fini(handle);
389 	return (rc);
390 }
391 
392 /*
393  * smb_config_getnum
394  *
395  * Returns the value of a numeric config param.
396  */
397 int
398 smb_config_getnum(smb_cfg_id_t id, int64_t *cint)
399 {
400 	smb_scfhandle_t *handle;
401 	smb_cfg_param_t *cfg;
402 	int rc = SMBD_SMF_OK;
403 
404 	*cint = 0;
405 	cfg = smb_config_getent(id);
406 	assert(cfg->sc_type == SCF_TYPE_INTEGER);
407 
408 	handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
409 	if (handle == NULL)
410 		return (SMBD_SMF_SYSTEM_ERR);
411 
412 	rc = smb_smf_create_service_pgroup(handle, SMBD_PG_NAME);
413 	if (rc == SMBD_SMF_OK)
414 		rc = smb_smf_get_integer_property(handle, cfg->sc_name, cint);
415 	smb_smf_scf_fini(handle);
416 
417 	return (rc);
418 }
419 
420 /*
421  * smb_config_getbool
422  *
423  * Returns the value of a boolean config param.
424  */
425 boolean_t
426 smb_config_getbool(smb_cfg_id_t id)
427 {
428 	smb_scfhandle_t *handle;
429 	smb_cfg_param_t *cfg;
430 	int rc = SMBD_SMF_OK;
431 	uint8_t vbool;
432 
433 	cfg = smb_config_getent(id);
434 	assert(cfg->sc_type == SCF_TYPE_BOOLEAN);
435 
436 	handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
437 	if (handle == NULL)
438 		return (B_FALSE);
439 
440 	rc = smb_smf_create_service_pgroup(handle, SMBD_PG_NAME);
441 	if (rc == SMBD_SMF_OK)
442 		rc = smb_smf_get_boolean_property(handle, cfg->sc_name, &vbool);
443 	smb_smf_scf_fini(handle);
444 
445 	return ((rc == SMBD_SMF_OK) ? (vbool == 1) : B_FALSE);
446 }
447 
448 /*
449  * smb_config_get
450  *
451  * This function returns the value of the requested config
452  * iterm regardless of its type in string format. This should
453  * be used when the config item type is not known by the caller.
454  */
455 int
456 smb_config_get(smb_cfg_id_t id, char *cbuf, int bufsz)
457 {
458 	smb_cfg_param_t *cfg;
459 	int64_t cint;
460 	int rc;
461 
462 	cfg = smb_config_getent(id);
463 	switch (cfg->sc_type) {
464 	case SCF_TYPE_ASTRING:
465 		return (smb_config_getstr(id, cbuf, bufsz));
466 
467 	case SCF_TYPE_INTEGER:
468 		rc = smb_config_getnum(id, &cint);
469 		if (rc == SMBD_SMF_OK)
470 			(void) snprintf(cbuf, bufsz, "%lld", cint);
471 		return (rc);
472 
473 	case SCF_TYPE_BOOLEAN:
474 		if (smb_config_getbool(id))
475 			(void) strlcpy(cbuf, "true", bufsz);
476 		else
477 			(void) strlcpy(cbuf, "false", bufsz);
478 		return (SMBD_SMF_OK);
479 	}
480 
481 	return (SMBD_SMF_INVALID_ARG);
482 }
483 
484 /*
485  * smb_config_setstr
486  *
487  * Set the specified config param with the given
488  * value.
489  */
490 int
491 smb_config_setstr(smb_cfg_id_t id, char *value)
492 {
493 	smb_scfhandle_t *handle;
494 	smb_cfg_param_t *cfg;
495 	int rc = SMBD_SMF_OK;
496 	boolean_t protected;
497 	char *tmp = NULL;
498 	char *pg;
499 
500 	cfg = smb_config_getent(id);
501 	assert(cfg->sc_type == SCF_TYPE_ASTRING);
502 
503 	if (cfg->sc_flags & SMB_CF_PROTECTED) {
504 		pg = SMBD_PROTECTED_PG_NAME;
505 		protected = B_TRUE;
506 	} else {
507 		pg = SMBD_PG_NAME;
508 		protected = B_FALSE;
509 	}
510 
511 	handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
512 	if (handle == NULL)
513 		return (SMBD_SMF_SYSTEM_ERR);
514 
515 	rc = smb_smf_create_service_pgroup(handle, pg);
516 	if (rc == SMBD_SMF_OK)
517 		rc = smb_smf_start_transaction(handle);
518 
519 	if (rc != SMBD_SMF_OK) {
520 		smb_smf_scf_fini(handle);
521 		return (rc);
522 	}
523 
524 	if (protected && value && (*value != '\0')) {
525 		if ((tmp = smb_base64_encode(value)) == NULL) {
526 			(void) smb_smf_end_transaction(handle);
527 			smb_smf_scf_fini(handle);
528 			return (SMBD_SMF_NO_MEMORY);
529 		}
530 
531 		value = tmp;
532 	}
533 
534 	rc = smb_smf_set_string_property(handle, cfg->sc_name, value);
535 
536 	free(tmp);
537 	(void) smb_smf_end_transaction(handle);
538 	smb_smf_scf_fini(handle);
539 	return (rc);
540 }
541 
542 /*
543  * smb_config_setnum
544  *
545  * Sets a numeric configuration iterm
546  */
547 int
548 smb_config_setnum(smb_cfg_id_t id, int64_t value)
549 {
550 	smb_scfhandle_t *handle;
551 	smb_cfg_param_t *cfg;
552 	int rc = SMBD_SMF_OK;
553 
554 	cfg = smb_config_getent(id);
555 	assert(cfg->sc_type == SCF_TYPE_INTEGER);
556 
557 	handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
558 	if (handle == NULL)
559 		return (SMBD_SMF_SYSTEM_ERR);
560 
561 	rc = smb_smf_create_service_pgroup(handle, SMBD_PG_NAME);
562 	if (rc == SMBD_SMF_OK)
563 		rc = smb_smf_start_transaction(handle);
564 
565 	if (rc != SMBD_SMF_OK) {
566 		smb_smf_scf_fini(handle);
567 		return (rc);
568 	}
569 
570 	rc = smb_smf_set_integer_property(handle, cfg->sc_name, value);
571 
572 	(void) smb_smf_end_transaction(handle);
573 	smb_smf_scf_fini(handle);
574 	return (rc);
575 }
576 
577 /*
578  * smb_config_setbool
579  *
580  * Sets a boolean configuration iterm
581  */
582 int
583 smb_config_setbool(smb_cfg_id_t id, boolean_t value)
584 {
585 	smb_scfhandle_t *handle;
586 	smb_cfg_param_t *cfg;
587 	int rc = SMBD_SMF_OK;
588 
589 	cfg = smb_config_getent(id);
590 	assert(cfg->sc_type == SCF_TYPE_BOOLEAN);
591 
592 	handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
593 	if (handle == NULL)
594 		return (SMBD_SMF_SYSTEM_ERR);
595 
596 	rc = smb_smf_create_service_pgroup(handle, SMBD_PG_NAME);
597 	if (rc == SMBD_SMF_OK)
598 		rc = smb_smf_start_transaction(handle);
599 
600 	if (rc != SMBD_SMF_OK) {
601 		smb_smf_scf_fini(handle);
602 		return (rc);
603 	}
604 
605 	rc = smb_smf_set_boolean_property(handle, cfg->sc_name, value);
606 
607 	(void) smb_smf_end_transaction(handle);
608 	smb_smf_scf_fini(handle);
609 	return (rc);
610 }
611 
612 /*
613  * smb_config_set
614  *
615  * This function sets the value of the specified config
616  * iterm regardless of its type in string format. This should
617  * be used when the config item type is not known by the caller.
618  */
619 int
620 smb_config_set(smb_cfg_id_t id, char *value)
621 {
622 	smb_cfg_param_t *cfg;
623 	int64_t cint;
624 
625 	cfg = smb_config_getent(id);
626 	switch (cfg->sc_type) {
627 	case SCF_TYPE_ASTRING:
628 		return (smb_config_setstr(id, value));
629 
630 	case SCF_TYPE_INTEGER:
631 		cint = atoi(value);
632 		return (smb_config_setnum(id, cint));
633 
634 	case SCF_TYPE_BOOLEAN:
635 		return (smb_config_setbool(id, strcasecmp(value, "true") == 0));
636 	}
637 
638 	return (SMBD_SMF_INVALID_ARG);
639 }
640 uint8_t
641 smb_config_get_fg_flag()
642 {
643 	uint8_t run_fg = 0; /* Default is to run in daemon mode */
644 	smb_scfhandle_t *handle = NULL;
645 
646 	handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
647 	if (handle == NULL) {
648 		return (run_fg);
649 	}
650 
651 	if (smb_smf_create_service_pgroup(handle,
652 	    SMBD_PG_NAME) != SMBD_SMF_OK) {
653 		smb_smf_scf_fini(handle);
654 		return (run_fg);
655 	}
656 
657 	if (smb_smf_get_boolean_property(handle, "run_fg", &run_fg) != 0) {
658 		smb_smf_scf_fini(handle);
659 		return (run_fg);
660 	}
661 
662 	smb_smf_scf_fini(handle);
663 
664 	return (run_fg);
665 }
666 
667 /*
668  * smb_config_get_localsid
669  *
670  * Returns value of the "config/machine_sid" parameter
671  * from the IDMAP SMF configuration repository.
672  *
673  */
674 char *
675 smb_config_get_localsid(void)
676 {
677 	return (smb_config_getenv_generic(MACHINE_SID, IDMAP_FMRI_PREFIX,
678 	    IDMAP_PG_NAME));
679 }
680 
681 /*
682  * smb_config_set_idmap_domain
683  *
684  * Set the "config/domain_name" parameter from IDMAP SMF repository.
685  */
686 int
687 smb_config_set_idmap_domain(char *value)
688 {
689 	return (smb_config_setenv_generic(IDMAP_FMRI_PREFIX, IDMAP_PG_NAME,
690 	    IDMAP_DOMAIN, value));
691 }
692 
693 /*
694  * smb_config_refresh_idmap
695  *
696  * Refresh IDMAP SMF service after making changes to its configuration.
697  */
698 int
699 smb_config_refresh_idmap(void)
700 {
701 	char instance[32];
702 
703 	(void) snprintf(instance, sizeof (instance), "%s:default",
704 	    IDMAP_FMRI_PREFIX);
705 	return (smf_refresh_instance(instance));
706 }
707 
708 int
709 smb_config_secmode_fromstr(char *secmode)
710 {
711 	if (secmode == NULL)
712 		return (SMB_SECMODE_WORKGRP);
713 
714 	if (strcasecmp(secmode, SMB_SECMODE_DOMAIN_STR) == 0)
715 		return (SMB_SECMODE_DOMAIN);
716 
717 	return (SMB_SECMODE_WORKGRP);
718 }
719 
720 char *
721 smb_config_secmode_tostr(int secmode)
722 {
723 	if (secmode == SMB_SECMODE_DOMAIN)
724 		return (SMB_SECMODE_DOMAIN_STR);
725 
726 	return (SMB_SECMODE_WORKGRP_STR);
727 }
728 
729 int
730 smb_config_get_secmode()
731 {
732 	char p[16];
733 
734 	(void) smb_config_getstr(SMB_CI_SECURITY, p, sizeof (p));
735 	return (smb_config_secmode_fromstr(p));
736 }
737 
738 int
739 smb_config_set_secmode(int secmode)
740 {
741 	char *p;
742 
743 	p = smb_config_secmode_tostr(secmode);
744 	return (smb_config_setstr(SMB_CI_SECURITY, p));
745 }
746 
747 static smb_cfg_param_t *
748 smb_config_getent(smb_cfg_id_t id)
749 {
750 	int i;
751 
752 	for (i = 0; i < SMB_CI_MAX; i++)
753 		if (smb_cfg_table[i].sc_id == id)
754 			return (&smb_cfg_table[id]);
755 
756 	assert(0);
757 	return (NULL);
758 }
759