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	"%Z%%M%	%I%	%E% 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 	{SMB_CI_SIGNING_CHECK, "signing_check", SCF_TYPE_BOOLEAN, 0},
107 
108 	/* Kmod tuning configuration */
109 	{SMB_CI_SYNC_ENABLE, "sync_enable", SCF_TYPE_BOOLEAN, 0},
110 
111 	/* SMBd configuration */
112 	{SMB_CI_SECURITY, "security", SCF_TYPE_ASTRING, 0},
113 	{SMB_CI_NBSCOPE, "netbios_scope", SCF_TYPE_ASTRING, 0},
114 	{SMB_CI_SYS_CMNT, "system_comment", SCF_TYPE_ASTRING, 0},
115 	{SMB_CI_LM_LEVEL, "lmauth_level", SCF_TYPE_INTEGER, 0},
116 
117 	/* ADS Configuration */
118 	{SMB_CI_ADS_SITE, "ads_site", SCF_TYPE_ASTRING, 0},
119 
120 	/* Dynamic DNS */
121 	{SMB_CI_DYNDNS_ENABLE, "ddns_enable", SCF_TYPE_BOOLEAN, 0},
122 
123 	{SMB_CI_MACHINE_PASSWD, "machine_passwd", SCF_TYPE_ASTRING,
124 	    SMB_CF_PROTECTED},
125 	{SMB_CI_KPASSWD_SRV, "kpasswd_server", SCF_TYPE_ASTRING,
126 	    0},
127 	{SMB_CI_KPASSWD_DOMAIN, "kpasswd_domain", SCF_TYPE_ASTRING,
128 	    0},
129 	{SMB_CI_KPASSWD_SEQNUM, "kpasswd_seqnum", SCF_TYPE_INTEGER,
130 	    0},
131 	{SMB_CI_NETLOGON_SEQNUM, "netlogon_seqnum", SCF_TYPE_INTEGER,
132 	    0}
133 
134 	/* SMB_CI_MAX */
135 };
136 
137 static smb_cfg_param_t *smb_config_getent(smb_cfg_id_t);
138 
139 static boolean_t smb_is_base64(unsigned char c);
140 static char *smb_base64_encode(char *str_to_encode);
141 static char *smb_base64_decode(char *encoded_str);
142 
143 char *
144 smb_config_getname(smb_cfg_id_t id)
145 {
146 	smb_cfg_param_t *cfg;
147 	cfg = smb_config_getent(id);
148 	return (cfg->sc_name);
149 }
150 
151 static boolean_t
152 smb_is_base64(unsigned char c)
153 {
154 	return (isalnum(c) || (c == '+') || (c == '/'));
155 }
156 
157 /*
158  * smb_base64_encode
159  *
160  * Encode a string using base64 algorithm.
161  * Caller should free the returned buffer when done.
162  */
163 static char *
164 smb_base64_encode(char *str_to_encode)
165 {
166 	int ret_cnt = 0;
167 	int i = 0, j = 0;
168 	char arr_3[3], arr_4[4];
169 	int len = strlen(str_to_encode);
170 	char *ret = malloc(SMB_ENC_LEN);
171 
172 	if (ret == NULL) {
173 		return (NULL);
174 	}
175 
176 	while (len--) {
177 		arr_3[i++] = *(str_to_encode++);
178 		if (i == 3) {
179 			arr_4[0] = (arr_3[0] & 0xfc) >> 2;
180 			arr_4[1] = ((arr_3[0] & 0x03) << 4) +
181 			    ((arr_3[1] & 0xf0) >> 4);
182 			arr_4[2] = ((arr_3[1] & 0x0f) << 2) +
183 			    ((arr_3[2] & 0xc0) >> 6);
184 			arr_4[3] = arr_3[2] & 0x3f;
185 
186 			for (i = 0; i < 4; i++)
187 				ret[ret_cnt++] = b64_data[arr_4[i]];
188 			i = 0;
189 		}
190 	}
191 
192 	if (i) {
193 		for (j = i; j < 3; j++)
194 			arr_3[j] = '\0';
195 
196 		arr_4[0] = (arr_3[0] & 0xfc) >> 2;
197 		arr_4[1] = ((arr_3[0] & 0x03) << 4) +
198 		    ((arr_3[1] & 0xf0) >> 4);
199 		arr_4[2] = ((arr_3[1] & 0x0f) << 2) +
200 		    ((arr_3[2] & 0xc0) >> 6);
201 		arr_4[3] = arr_3[2] & 0x3f;
202 
203 		for (j = 0; j < (i + 1); j++)
204 			ret[ret_cnt++] = b64_data[arr_4[j]];
205 
206 		while (i++ < 3)
207 			ret[ret_cnt++] = '=';
208 	}
209 
210 	ret[ret_cnt++] = '\0';
211 	return (ret);
212 }
213 
214 /*
215  * smb_base64_decode
216  *
217  * Decode using base64 algorithm.
218  * Caller should free the returned buffer when done.
219  */
220 static char *
221 smb_base64_decode(char *encoded_str)
222 {
223 	int len = strlen(encoded_str);
224 	int i = 0, j = 0;
225 	int en_ind = 0;
226 	char arr_4[4], arr_3[3];
227 	int ret_cnt = 0;
228 	char *ret = malloc(SMB_DEC_LEN);
229 	char *p;
230 
231 	if (ret == NULL) {
232 		return (NULL);
233 	}
234 
235 	while (len-- && (encoded_str[en_ind] != '=') &&
236 	    smb_is_base64(encoded_str[en_ind])) {
237 		arr_4[i++] = encoded_str[en_ind];
238 		en_ind++;
239 		if (i == 4) {
240 			for (i = 0; i < 4; i++) {
241 				if ((p = strchr(b64_data, arr_4[i])) == NULL)
242 					return (NULL);
243 
244 				arr_4[i] = (int)(p - b64_data);
245 			}
246 
247 			arr_3[0] = (arr_4[0] << 2) +
248 			    ((arr_4[1] & 0x30) >> 4);
249 			arr_3[1] = ((arr_4[1] & 0xf) << 4) +
250 			    ((arr_4[2] & 0x3c) >> 2);
251 			arr_3[2] = ((arr_4[2] & 0x3) << 6) +
252 			    arr_4[3];
253 
254 			for (i = 0; i < 3; i++)
255 				ret[ret_cnt++] = arr_3[i];
256 
257 			i = 0;
258 		}
259 	}
260 
261 	if (i) {
262 		for (j = i; j < 4; j++)
263 			arr_4[j] = 0;
264 
265 		for (j = 0; j < 4; j++) {
266 			if ((p = strchr(b64_data, arr_4[j])) == NULL)
267 				return (NULL);
268 
269 			arr_4[j] = (int)(p - b64_data);
270 		}
271 		arr_3[0] = (arr_4[0] << 2) +
272 		    ((arr_4[1] & 0x30) >> 4);
273 		arr_3[1] = ((arr_4[1] & 0xf) << 4) +
274 		    ((arr_4[2] & 0x3c) >> 2);
275 		arr_3[2] = ((arr_4[2] & 0x3) << 6) +
276 		    arr_4[3];
277 		for (j = 0; j < (i - 1); j++)
278 			ret[ret_cnt++] = arr_3[j];
279 	}
280 
281 	ret[ret_cnt++] = '\0';
282 	return (ret);
283 }
284 
285 static char *
286 smb_config_getenv_generic(char *name, char *svc_fmri_prefix, char *svc_propgrp)
287 {
288 	smb_scfhandle_t *handle;
289 	char *value;
290 
291 	if ((value = malloc(MAX_VALUE_BUFLEN * sizeof (char))) == NULL)
292 		return (NULL);
293 
294 	handle = smb_smf_scf_init(svc_fmri_prefix);
295 	if (handle == NULL) {
296 		free(value);
297 		return (NULL);
298 	}
299 
300 	(void) smb_smf_create_service_pgroup(handle, svc_propgrp);
301 
302 	if (smb_smf_get_string_property(handle, name, value,
303 	    sizeof (char) * MAX_VALUE_BUFLEN) != 0) {
304 		smb_smf_scf_fini(handle);
305 		free(value);
306 		return (NULL);
307 	}
308 
309 	smb_smf_scf_fini(handle);
310 	return (value);
311 
312 }
313 
314 static int
315 smb_config_setenv_generic(char *svc_fmri_prefix, char *svc_propgrp,
316     char *name, char *value)
317 {
318 	smb_scfhandle_t *handle = NULL;
319 	int rc = 0;
320 
321 
322 	handle = smb_smf_scf_init(svc_fmri_prefix);
323 	if (handle == NULL) {
324 		return (1);
325 	}
326 
327 	(void) smb_smf_create_service_pgroup(handle, svc_propgrp);
328 
329 	if (smb_smf_start_transaction(handle) != SMBD_SMF_OK) {
330 		smb_smf_scf_fini(handle);
331 		return (1);
332 	}
333 
334 	if (smb_smf_set_string_property(handle, name, value) != SMBD_SMF_OK)
335 		rc = 1;
336 
337 	if (smb_smf_end_transaction(handle) != SMBD_SMF_OK)
338 		rc = 1;
339 
340 	smb_smf_scf_fini(handle);
341 	return (rc);
342 }
343 
344 /*
345  * smb_config_getstr
346  *
347  * Fetch the specified string configuration item from SMF
348  */
349 int
350 smb_config_getstr(smb_cfg_id_t id, char *cbuf, int bufsz)
351 {
352 	smb_scfhandle_t *handle;
353 	smb_cfg_param_t *cfg;
354 	int rc = SMBD_SMF_OK;
355 
356 	*cbuf = '\0';
357 	cfg = smb_config_getent(id);
358 	assert(cfg->sc_type == SCF_TYPE_ASTRING);
359 
360 	handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
361 	if (handle == NULL)
362 		return (SMBD_SMF_SYSTEM_ERR);
363 
364 	if (cfg->sc_flags & SMB_CF_PROTECTED) {
365 		char protbuf[SMB_ENC_LEN];
366 		char *tmp;
367 
368 		if ((rc = smb_smf_create_service_pgroup(handle,
369 		    SMBD_PROTECTED_PG_NAME)) != SMBD_SMF_OK)
370 			goto error;
371 
372 		if ((rc = smb_smf_get_string_property(handle, cfg->sc_name,
373 		    protbuf, sizeof (protbuf))) != SMBD_SMF_OK)
374 			goto error;
375 
376 		if (*protbuf != '\0') {
377 			tmp = smb_base64_decode(protbuf);
378 			(void) strlcpy(cbuf, tmp, bufsz);
379 			free(tmp);
380 		}
381 	} else {
382 		rc = smb_smf_create_service_pgroup(handle, SMBD_PG_NAME);
383 		if (rc == SMBD_SMF_OK)
384 			rc = smb_smf_get_string_property(handle, cfg->sc_name,
385 			    cbuf, bufsz);
386 	}
387 
388 error:
389 	smb_smf_scf_fini(handle);
390 	return (rc);
391 }
392 
393 /*
394  * smb_config_getnum
395  *
396  * Returns the value of a numeric config param.
397  */
398 int
399 smb_config_getnum(smb_cfg_id_t id, int64_t *cint)
400 {
401 	smb_scfhandle_t *handle;
402 	smb_cfg_param_t *cfg;
403 	int rc = SMBD_SMF_OK;
404 
405 	*cint = 0;
406 	cfg = smb_config_getent(id);
407 	assert(cfg->sc_type == SCF_TYPE_INTEGER);
408 
409 	handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
410 	if (handle == NULL)
411 		return (SMBD_SMF_SYSTEM_ERR);
412 
413 	rc = smb_smf_create_service_pgroup(handle, SMBD_PG_NAME);
414 	if (rc == SMBD_SMF_OK)
415 		rc = smb_smf_get_integer_property(handle, cfg->sc_name, cint);
416 	smb_smf_scf_fini(handle);
417 
418 	return (rc);
419 }
420 
421 /*
422  * smb_config_getbool
423  *
424  * Returns the value of a boolean config param.
425  */
426 boolean_t
427 smb_config_getbool(smb_cfg_id_t id)
428 {
429 	smb_scfhandle_t *handle;
430 	smb_cfg_param_t *cfg;
431 	int rc = SMBD_SMF_OK;
432 	uint8_t vbool;
433 
434 	cfg = smb_config_getent(id);
435 	assert(cfg->sc_type == SCF_TYPE_BOOLEAN);
436 
437 	handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
438 	if (handle == NULL)
439 		return (B_FALSE);
440 
441 	rc = smb_smf_create_service_pgroup(handle, SMBD_PG_NAME);
442 	if (rc == SMBD_SMF_OK)
443 		rc = smb_smf_get_boolean_property(handle, cfg->sc_name, &vbool);
444 	smb_smf_scf_fini(handle);
445 
446 	return ((rc == SMBD_SMF_OK) ? (vbool == 1) : B_FALSE);
447 }
448 
449 /*
450  * smb_config_get
451  *
452  * This function returns the value of the requested config
453  * iterm regardless of its type in string format. This should
454  * be used when the config item type is not known by the caller.
455  */
456 int
457 smb_config_get(smb_cfg_id_t id, char *cbuf, int bufsz)
458 {
459 	smb_cfg_param_t *cfg;
460 	int64_t cint;
461 	int rc;
462 
463 	cfg = smb_config_getent(id);
464 	switch (cfg->sc_type) {
465 	case SCF_TYPE_ASTRING:
466 		return (smb_config_getstr(id, cbuf, bufsz));
467 
468 	case SCF_TYPE_INTEGER:
469 		rc = smb_config_getnum(id, &cint);
470 		if (rc == SMBD_SMF_OK)
471 			(void) snprintf(cbuf, bufsz, "%lld", cint);
472 		return (rc);
473 
474 	case SCF_TYPE_BOOLEAN:
475 		if (smb_config_getbool(id))
476 			(void) strlcpy(cbuf, "true", bufsz);
477 		else
478 			(void) strlcpy(cbuf, "false", bufsz);
479 		return (SMBD_SMF_OK);
480 	}
481 
482 	return (SMBD_SMF_INVALID_ARG);
483 }
484 
485 /*
486  * smb_config_setstr
487  *
488  * Set the specified config param with the given
489  * value.
490  */
491 int
492 smb_config_setstr(smb_cfg_id_t id, char *value)
493 {
494 	smb_scfhandle_t *handle;
495 	smb_cfg_param_t *cfg;
496 	int rc = SMBD_SMF_OK;
497 	boolean_t protected;
498 	char *tmp = NULL;
499 	char *pg;
500 
501 	cfg = smb_config_getent(id);
502 	assert(cfg->sc_type == SCF_TYPE_ASTRING);
503 
504 	if (cfg->sc_flags & SMB_CF_PROTECTED) {
505 		pg = SMBD_PROTECTED_PG_NAME;
506 		protected = B_TRUE;
507 	} else {
508 		pg = SMBD_PG_NAME;
509 		protected = B_FALSE;
510 	}
511 
512 	handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
513 	if (handle == NULL)
514 		return (SMBD_SMF_SYSTEM_ERR);
515 
516 	rc = smb_smf_create_service_pgroup(handle, pg);
517 	if (rc == SMBD_SMF_OK)
518 		rc = smb_smf_start_transaction(handle);
519 
520 	if (rc != SMBD_SMF_OK) {
521 		smb_smf_scf_fini(handle);
522 		return (rc);
523 	}
524 
525 	if (protected && value && (*value != '\0')) {
526 		if ((tmp = smb_base64_encode(value)) == NULL) {
527 			(void) smb_smf_end_transaction(handle);
528 			smb_smf_scf_fini(handle);
529 			return (SMBD_SMF_NO_MEMORY);
530 		}
531 
532 		value = tmp;
533 	}
534 
535 	rc = smb_smf_set_string_property(handle, cfg->sc_name, value);
536 
537 	free(tmp);
538 	(void) smb_smf_end_transaction(handle);
539 	smb_smf_scf_fini(handle);
540 	return (rc);
541 }
542 
543 /*
544  * smb_config_setnum
545  *
546  * Sets a numeric configuration iterm
547  */
548 int
549 smb_config_setnum(smb_cfg_id_t id, int64_t value)
550 {
551 	smb_scfhandle_t *handle;
552 	smb_cfg_param_t *cfg;
553 	int rc = SMBD_SMF_OK;
554 
555 	cfg = smb_config_getent(id);
556 	assert(cfg->sc_type == SCF_TYPE_INTEGER);
557 
558 	handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
559 	if (handle == NULL)
560 		return (SMBD_SMF_SYSTEM_ERR);
561 
562 	rc = smb_smf_create_service_pgroup(handle, SMBD_PG_NAME);
563 	if (rc == SMBD_SMF_OK)
564 		rc = smb_smf_start_transaction(handle);
565 
566 	if (rc != SMBD_SMF_OK) {
567 		smb_smf_scf_fini(handle);
568 		return (rc);
569 	}
570 
571 	rc = smb_smf_set_integer_property(handle, cfg->sc_name, value);
572 
573 	(void) smb_smf_end_transaction(handle);
574 	smb_smf_scf_fini(handle);
575 	return (rc);
576 }
577 
578 /*
579  * smb_config_setbool
580  *
581  * Sets a boolean configuration iterm
582  */
583 int
584 smb_config_setbool(smb_cfg_id_t id, boolean_t value)
585 {
586 	smb_scfhandle_t *handle;
587 	smb_cfg_param_t *cfg;
588 	int rc = SMBD_SMF_OK;
589 
590 	cfg = smb_config_getent(id);
591 	assert(cfg->sc_type == SCF_TYPE_BOOLEAN);
592 
593 	handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
594 	if (handle == NULL)
595 		return (SMBD_SMF_SYSTEM_ERR);
596 
597 	rc = smb_smf_create_service_pgroup(handle, SMBD_PG_NAME);
598 	if (rc == SMBD_SMF_OK)
599 		rc = smb_smf_start_transaction(handle);
600 
601 	if (rc != SMBD_SMF_OK) {
602 		smb_smf_scf_fini(handle);
603 		return (rc);
604 	}
605 
606 	rc = smb_smf_set_boolean_property(handle, cfg->sc_name, value);
607 
608 	(void) smb_smf_end_transaction(handle);
609 	smb_smf_scf_fini(handle);
610 	return (rc);
611 }
612 
613 /*
614  * smb_config_set
615  *
616  * This function sets the value of the specified config
617  * iterm regardless of its type in string format. This should
618  * be used when the config item type is not known by the caller.
619  */
620 int
621 smb_config_set(smb_cfg_id_t id, char *value)
622 {
623 	smb_cfg_param_t *cfg;
624 	int64_t cint;
625 
626 	cfg = smb_config_getent(id);
627 	switch (cfg->sc_type) {
628 	case SCF_TYPE_ASTRING:
629 		return (smb_config_setstr(id, value));
630 
631 	case SCF_TYPE_INTEGER:
632 		cint = atoi(value);
633 		return (smb_config_setnum(id, cint));
634 
635 	case SCF_TYPE_BOOLEAN:
636 		return (smb_config_setbool(id, strcasecmp(value, "true") == 0));
637 	}
638 
639 	return (SMBD_SMF_INVALID_ARG);
640 }
641 uint8_t
642 smb_config_get_fg_flag()
643 {
644 	uint8_t run_fg = 0; /* Default is to run in daemon mode */
645 	smb_scfhandle_t *handle = NULL;
646 
647 	handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
648 	if (handle == NULL) {
649 		return (run_fg);
650 	}
651 
652 	if (smb_smf_create_service_pgroup(handle,
653 	    SMBD_PG_NAME) != SMBD_SMF_OK) {
654 		smb_smf_scf_fini(handle);
655 		return (run_fg);
656 	}
657 
658 	if (smb_smf_get_boolean_property(handle, "run_fg", &run_fg) != 0) {
659 		smb_smf_scf_fini(handle);
660 		return (run_fg);
661 	}
662 
663 	smb_smf_scf_fini(handle);
664 
665 	return (run_fg);
666 }
667 
668 /*
669  * smb_config_get_localsid
670  *
671  * Returns value of the "config/machine_sid" parameter
672  * from the IDMAP SMF configuration repository.
673  *
674  */
675 char *
676 smb_config_get_localsid(void)
677 {
678 	return (smb_config_getenv_generic(MACHINE_SID, IDMAP_FMRI_PREFIX,
679 	    IDMAP_PG_NAME));
680 }
681 
682 /*
683  * smb_config_set_idmap_domain
684  *
685  * Set the "config/domain_name" parameter from IDMAP SMF repository.
686  */
687 int
688 smb_config_set_idmap_domain(char *value)
689 {
690 	return (smb_config_setenv_generic(IDMAP_FMRI_PREFIX, IDMAP_PG_NAME,
691 	    IDMAP_DOMAIN, value));
692 }
693 
694 /*
695  * smb_config_refresh_idmap
696  *
697  * Refresh IDMAP SMF service after making changes to its configuration.
698  */
699 int
700 smb_config_refresh_idmap(void)
701 {
702 	char instance[32];
703 
704 	(void) snprintf(instance, sizeof (instance), "%s:default",
705 	    IDMAP_FMRI_PREFIX);
706 	return (smf_refresh_instance(instance));
707 }
708 
709 int
710 smb_config_secmode_fromstr(char *secmode)
711 {
712 	if (secmode == NULL)
713 		return (SMB_SECMODE_WORKGRP);
714 
715 	if (strcasecmp(secmode, SMB_SECMODE_DOMAIN_STR) == 0)
716 		return (SMB_SECMODE_DOMAIN);
717 
718 	return (SMB_SECMODE_WORKGRP);
719 }
720 
721 char *
722 smb_config_secmode_tostr(int secmode)
723 {
724 	if (secmode == SMB_SECMODE_DOMAIN)
725 		return (SMB_SECMODE_DOMAIN_STR);
726 
727 	return (SMB_SECMODE_WORKGRP_STR);
728 }
729 
730 int
731 smb_config_get_secmode()
732 {
733 	char p[16];
734 
735 	(void) smb_config_getstr(SMB_CI_SECURITY, p, sizeof (p));
736 	return (smb_config_secmode_fromstr(p));
737 }
738 
739 int
740 smb_config_set_secmode(int secmode)
741 {
742 	char *p;
743 
744 	p = smb_config_secmode_tostr(secmode);
745 	return (smb_config_setstr(SMB_CI_SECURITY, p));
746 }
747 
748 static smb_cfg_param_t *
749 smb_config_getent(smb_cfg_id_t id)
750 {
751 	int i;
752 
753 	for (i = 0; i < SMB_CI_MAX; i++)
754 		if (smb_cfg_table[i].sc_id == id)
755 			return (&smb_cfg_table[id]);
756 
757 	assert(0);
758 	return (NULL);
759 }
760