libsmb/common/smb_cfg.c

	smb_cfg.c revision da6c28aaf62fa55f0fdb8004aa40f88f23bf53f0
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * CIFS configuration management library
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <synch.h>
#include <string.h>
#include <strings.h>
#include <syslog.h>
#include <netdb.h>
#include <ctype.h>
#include <sys/types.h>
#include <libscf.h>
#include <smbsrv/libsmb.h>

typedef struct smb_cfg_param {
    char *sc_pg;
    char *sc_name;
    int sc_type;
    char *sc_value;
    uint32_t sc_flags;
} smb_cfg_param_t;

/*
 * config parameter flags
 */
#define SMB_CF_NOTINIT      0x00    /* Not initialized yet */
#define SMB_CF_DEFINED      0x01    /* Defined/read from env */
#define SMB_CF_MODIFIED     0x02    /* Has been modified */
#define SMB_CF_SYSTEM       0x04    /* system; not part of cifs config */

#define SMB_CL_NONE 0
#define SMB_CL_READ 1
#define SMB_CL_WRITE    2

/* idmap SMF fmri and Property Group */
#define IDMAP_FMRI_PREFIX       "system/idmap"
#define MACHINE_SID         "machine_sid"
#define MAPPING_DOMAIN          "mapping_domain"
#define GLOBAL_CATALOG          "global_catalog"
#define IDMAP_PG_NAME           "config"

#define SMB_SECMODE_WORKGRP_STR     "workgroup"
#define SMB_SECMODE_DOMAIN_STR      "domain"

#define SMB_ENC_LEN 1024
#define SMB_DEC_LEN 256

static char *b64_data =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

static rwlock_t smb_cfg_rwlk;
static int lock_type = SMB_CL_NONE;

/*
 * IMPORTANT: any changes to the order of this table's entries
 * need to be reflected in smb_cfg_id_t enum in libsmb.h
 */
static smb_cfg_param_t smb_cfg_table[] =
{
    /* Redirector configuration, User space */
    {SMBD_PG_NAME, SMB_CD_RDR_IPCMODE, SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},
    {SMBD_PROTECTED_PG_NAME, SMB_CD_RDR_IPCUSER,
        SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},
    {SMBD_PROTECTED_PG_NAME, SMB_CD_RDR_IPCPWD,
        SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},

    /* Oplock configuration, Kernel Only */
    {SMBD_PG_NAME, SMB_CD_OPLOCK_ENABLE,
        SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_OPLOCK_TIMEOUT,
        SCF_TYPE_INTEGER, 0, SMB_CF_NOTINIT},

    /* Autohome configuration */
    {SMBD_PG_NAME, SMB_CD_AUTOHOME_MAP,
        SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},

    /* Domain/PDC configuration */
    {SMBD_PG_NAME, SMB_CD_DOMAIN_SID, SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_DOMAIN_MEMB, SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_DOMAIN_NAME, SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_DOMAIN_SRV, SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},

    /* WINS configuration */
    {SMBD_PG_NAME, SMB_CD_WINS_SRV1, SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_WINS_SRV2, SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_WINS_EXCL, SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},

    /* RPC services configuration */
    {SMBD_PG_NAME, SMB_CD_SRVSVC_SHRSET_ENABLE,
        SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_LOGR_ENABLE, SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_MLRPC_KALIVE,
        SCF_TYPE_INTEGER, 0, SMB_CF_NOTINIT},

    /* Kmod specific configuration */
    {SMBD_PG_NAME, SMB_CD_MAX_BUFSIZE, SCF_TYPE_INTEGER, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_MAX_WORKERS, SCF_TYPE_INTEGER, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_MAX_CONNECTIONS,
        SCF_TYPE_INTEGER, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_KEEPALIVE, SCF_TYPE_INTEGER, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_RESTRICT_ANON,
        SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},

    {SMBD_PG_NAME, SMB_CD_SIGNING_ENABLE,
        SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_SIGNING_REQD,
        SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_SIGNING_CHECK,
        SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},

    /* Kmod tuning configuration */
    {SMBD_PG_NAME, SMB_CD_FLUSH_REQUIRED,
        SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_SYNC_ENABLE, SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_DIRSYMLINK_DISABLE,
        SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_ANNONCE_QUOTA,
        SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},

    /* SMBd configuration */
    {SMBD_PG_NAME, SMB_CD_SECURITY, SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_NBSCOPE, SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_SYS_CMNT, SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_LM_LEVEL, SCF_TYPE_INTEGER, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_MSDCS_DISABLE,
        SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},

    /* ADS Configuration */
    {SMBD_PG_NAME, SMB_CD_ADS_ENABLE, SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},
    {SMBD_PROTECTED_PG_NAME, SMB_CD_ADS_USER,
        SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},
    {SMBD_PROTECTED_PG_NAME, SMB_CD_ADS_PASSWD,
        SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_ADS_DOMAIN, SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_ADS_USER_CONTAINER,
        SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_ADS_SITE, SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_ADS_IPLOOKUP,
        SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},

    /* Dynamic DNS */
    {SMBD_PG_NAME, SMB_CD_DYNDNS_ENABLE,
        SCF_TYPE_BOOLEAN, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_DYNDNS_RETRY_COUNT,
        SCF_TYPE_INTEGER, 0, SMB_CF_NOTINIT},
    {SMBD_PG_NAME, SMB_CD_DYNDNS_RETRY_SEC,
        SCF_TYPE_INTEGER, 0, SMB_CF_NOTINIT},

    {SMBD_PROTECTED_PG_NAME, SMB_CD_MACHINE_PASSWD,
        SCF_TYPE_ASTRING, 0, SMB_CF_NOTINIT}
    /* SMB_CI_MAX */
};

static boolean_t smb_is_base64(unsigned char c);
static char *smb_base64_encode(char *str_to_encode);
static char *smb_base64_decode(char *encoded_str);
static int smb_config_update(smb_cfg_param_t *cfg, char *value);
static int smb_config_save_all();
static int smb_config_save(char *pgname);

static boolean_t
smb_is_base64(unsigned char c)
{
    return (isalnum(c) || (c == '+') || (c == '/'));
}

/*
 * smb_base64_encode
 *
 * Encode a string using base64 algorithm.
 * Caller should free the returned buffer when done.
 */
static char *
smb_base64_encode(char *str_to_encode)
{
    int ret_cnt = 0;
    int i = 0, j = 0;
    char arr_3[3], arr_4[4];
    int len = strlen(str_to_encode);
    char *ret = malloc(SMB_ENC_LEN);

    if (ret == NULL) {
        return (NULL);
    }

    while (len--) {
        arr_3[i++] = *(str_to_encode++);
        if (i == 3) {
            arr_4[0] = (arr_3[0] & 0xfc) >> 2;
            arr_4[1] = ((arr_3[0] & 0x03) << 4) +
                ((arr_3[1] & 0xf0) >> 4);
            arr_4[2] = ((arr_3[1] & 0x0f) << 2) +
                ((arr_3[2] & 0xc0) >> 6);
            arr_4[3] = arr_3[2] & 0x3f;

            for (i = 0; i < 4; i++)
                ret[ret_cnt++] = b64_data[arr_4[i]];
            i = 0;
        }
    }

    if (i) {
        for (j = i; j < 3; j++)
            arr_3[j] = '\0';

        arr_4[0] = (arr_3[0] & 0xfc) >> 2;
        arr_4[1] = ((arr_3[0] & 0x03) << 4) +
            ((arr_3[1] & 0xf0) >> 4);
        arr_4[2] = ((arr_3[1] & 0x0f) << 2) +
            ((arr_3[2] & 0xc0) >> 6);
        arr_4[3] = arr_3[2] & 0x3f;

        for (j = 0; j < (i + 1); j++)
            ret[ret_cnt++] = b64_data[arr_4[j]];

        while (i++ < 3)
            ret[ret_cnt++] = '=';
    }

    ret[ret_cnt++] = '\0';
    return (ret);
}

/*
 * smb_base64_decode
 *
 * Decode using base64 algorithm.
 * Caller should free the returned buffer when done.
 */
static char *
smb_base64_decode(char *encoded_str)
{
    int len = strlen(encoded_str);
    int i = 0, j = 0;
    int en_ind = 0;
    char arr_4[4], arr_3[3];
    int ret_cnt = 0;
    char *ret = malloc(SMB_DEC_LEN);
    char *p;

    if (ret == NULL) {
        return (NULL);
    }

    while (len-- && (encoded_str[en_ind] != '=') &&
        smb_is_base64(encoded_str[en_ind])) {
        arr_4[i++] = encoded_str[en_ind];
        en_ind++;
        if (i == 4) {
            for (i = 0; i < 4; i++) {
                if ((p = strchr(b64_data, arr_4[i])) == NULL)
                    return (NULL);

                arr_4[i] = (int)(p - b64_data);
            }

            arr_3[0] = (arr_4[0] << 2) +
                ((arr_4[1] & 0x30) >> 4);
            arr_3[1] = ((arr_4[1] & 0xf) << 4) +
                ((arr_4[2] & 0x3c) >> 2);
            arr_3[2] = ((arr_4[2] & 0x3) << 6) +
                arr_4[3];

            for (i = 0; i < 3; i++)
                ret[ret_cnt++] = arr_3[i];

            i = 0;
        }
    }

    if (i) {
        for (j = i; j < 4; j++)
            arr_4[j] = 0;

        for (j = 0; j < 4; j++) {
            if ((p = strchr(b64_data, arr_4[j])) == NULL)
                return (NULL);

            arr_4[j] = (int)(p - b64_data);
        }
        arr_3[0] = (arr_4[0] << 2) +
            ((arr_4[1] & 0x30) >> 4);
        arr_3[1] = ((arr_4[1] & 0xf) << 4) +
            ((arr_4[2] & 0x3c) >> 2);
        arr_3[2] = ((arr_4[2] & 0x3) << 6) +
            arr_4[3];
        for (j = 0; j < (i - 1); j++)
            ret[ret_cnt++] = arr_3[j];
    }

    ret[ret_cnt++] = '\0';
    return (ret);
}

/*
 * Basically commit the transaction.
 */
static int
smb_config_saveenv(smb_scfhandle_t *handle)
{
    int ret = 0;

    ret = smb_smf_end_transaction(handle);

    smb_smf_scf_fini(handle);
    return (ret);
}

/*
 * smb_config_getenv
 *
 * Get the property value from SMF.
 */
char *
smb_config_getenv(smb_cfg_id_t id)
{
    smb_scfhandle_t *handle;
    char *value;

    if ((value = malloc(MAX_VALUE_BUFLEN * sizeof (char))) == NULL)
        return (NULL);

    handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
    if (handle == NULL) {
        free(value);
        return (NULL);
    }

    (void) smb_smf_create_service_pgroup(handle, smb_cfg_table[id].sc_pg);

    if (smb_smf_get_property(handle, smb_cfg_table[id].sc_type,
        smb_cfg_table[id].sc_name, value,
        sizeof (char) * MAX_VALUE_BUFLEN) != 0) {
        smb_smf_scf_fini(handle);
        free(value);
        return (NULL);
    }

    smb_smf_scf_fini(handle);
    return (value);
}

/*
 * smb_config_getenv_dec
 *
 * For protected property, the value obtained from SMF will be decoded.
 * The decoded property value will be returned.
 *
 * This function should only be called by smb_config_load to populate
 * the SMB config cache.
 */
static char *
smb_config_getenv_dec(smb_cfg_id_t id)
{
    smb_scfhandle_t *handle;
    char *value;
    char *dec;

    if ((value = malloc(MAX_VALUE_BUFLEN * sizeof (char))) == NULL)
        return (NULL);

    handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
    if (handle == NULL) {
        free(value);
        return (NULL);
    }

    (void) smb_smf_create_service_pgroup(handle, smb_cfg_table[id].sc_pg);

    if (smb_smf_get_property(handle, smb_cfg_table[id].sc_type,
        smb_cfg_table[id].sc_name, value,
        sizeof (char) * MAX_VALUE_BUFLEN) != 0) {
        smb_smf_scf_fini(handle);
        free(value);
        return (NULL);
    }
    smb_smf_scf_fini(handle);
    if (strcmp(smb_cfg_table[id].sc_pg, SMBD_PROTECTED_PG_NAME))
        return (value);

    if (!value)
        return (NULL);

    if (*value == '\0') {
        free(value);
        return (NULL);
    }

    dec = smb_base64_decode(value);
    free(value);
    return (dec);
}

static char *
smb_config_getenv_generic(char *name, char *svc_fmri_prefix, char *svc_propgrp)
{
    smb_scfhandle_t *handle;
    char *value;

    if ((value = malloc(MAX_VALUE_BUFLEN * sizeof (char))) == NULL)
        return (NULL);

    handle = smb_smf_scf_init(svc_fmri_prefix);
    if (handle == NULL) {
        free(value);
        return (NULL);
    }

    (void) smb_smf_create_service_pgroup(handle, svc_propgrp);

    if (smb_smf_get_string_property(handle, name, value,
        sizeof (char) * MAX_VALUE_BUFLEN) != 0) {
        smb_smf_scf_fini(handle);
        free(value);
        return (NULL);
    }

    smb_smf_scf_fini(handle);
    return (value);

}

int
smb_config_setenv_generic(char *svc_fmri_prefix, char *svc_propgrp,
    char *name, char *value)
{
    smb_scfhandle_t *handle = NULL;
    int rc = 0;


    handle = smb_smf_scf_init(svc_fmri_prefix);
    if (handle == NULL) {
        return (1);
    }

    (void) smb_smf_create_service_pgroup(handle, svc_propgrp);

    if (smb_smf_start_transaction(handle) != SMBD_SMF_OK) {
        smb_smf_scf_fini(handle);
        return (1);
    }

    if (smb_smf_set_string_property(handle, name, value) != SMBD_SMF_OK)
        rc = 1;

    if (smb_smf_end_transaction(handle) != SMBD_SMF_OK)
        rc = 1;

    smb_smf_scf_fini(handle);
    return (rc);
}

/*
 * smb_config_setenv
 *
 * For protected properties, the value will be encoded using base64
 * algorithm. The encoded string will be stored in SMF.
 */
int
smb_config_setenv(smb_cfg_id_t id, char *value)
{
    smb_scfhandle_t *handle = NULL;
    char *enc = NULL;
    int is_protected = 0;

    if ((id >= SMB_CI_MAX) || (id < 0)) {
        return (1);
    }

    handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
    if (handle == NULL) {
        return (1);
    }

    (void) smb_smf_create_service_pgroup(handle, smb_cfg_table[id].sc_pg);

    if (smb_smf_start_transaction(handle) != SMBD_SMF_OK) {
        smb_smf_scf_fini(handle);
        return (1);
    }

    if (strcmp(smb_cfg_table[id].sc_pg, SMBD_PROTECTED_PG_NAME) == 0) {
        if ((value == NULL) || (*value == '\0')) {
            (void) smb_smf_end_transaction(handle);
            smb_smf_scf_fini(handle);
            return (1);
        }

        if ((enc = smb_base64_encode(value)) == NULL) {
            (void) smb_smf_end_transaction(handle);
            smb_smf_scf_fini(handle);
            return (1);
        }

        is_protected = 1;
    }

    if (smb_smf_set_property(handle, smb_cfg_table[id].sc_type,
        smb_cfg_table[id].sc_name, is_protected ? enc : value)
        != SMBD_SMF_OK) {
        if (enc)
            free(enc);
        (void) smb_smf_end_transaction(handle);
        smb_smf_scf_fini(handle);
        return (1);
    }

    if (enc)
        free(enc);

    if (smb_smf_end_transaction(handle) != SMBD_SMF_OK) {
        smb_smf_scf_fini(handle);
        return (1);
    }

    smb_smf_scf_fini(handle);
    return (0);
}

static void
smb_config_setenv_trans(smb_scfhandle_t *handle, int type,
    char *name, char *value)
{
    if (smb_smf_set_property(handle, type, name, value) != SMBD_SMF_OK) {
        syslog(LOG_ERR, "Failed to save service property %s", name);
    }
}

/*
 * smb_config_setenv_trans_protected
 *
 * This function should only be called to set protected properties
 * in SMF. The argument 'value' will be encoded using base64 algorithm.
 * The encoded string will be stored in SMF.
 */
static void
smb_config_setenv_trans_protected(smb_scfhandle_t *handle, char *name,
    char *value)
{
    char *enc;

    if ((value == NULL) || (*value == '\0'))
        return;

    if ((enc = smb_base64_encode(value)) == NULL)
        return;

    if (smb_smf_set_string_property(handle, name, enc) != SMBD_SMF_OK) {
        syslog(LOG_ERR, "Failed to save service protected property"
            " %s", name);
    }

    free(enc);
}

int
smb_config_unsetenv(smb_cfg_id_t id)
{
    smb_scfhandle_t *handle = NULL;
    int ret = 1;

    handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
    if (handle == NULL) {
        return (ret);
    }

    (void) smb_smf_create_service_pgroup(handle, smb_cfg_table[id].sc_pg);
    if (smb_smf_start_transaction(handle) != SMBD_SMF_OK) {
        smb_smf_scf_fini(handle);
        return (ret);
    }
    ret = smb_smf_delete_property(handle, smb_cfg_table[id].sc_name);
    (void) smb_smf_end_transaction(handle);

    smb_smf_scf_fini(handle);
    return (ret);
}

static int
smb_config_unsetenv_trans(smb_scfhandle_t *handle, char *name)
{
    return (smb_smf_delete_property(handle, name));
}

/*
 * smb_config_load
 *
 * Loads all the CIFS configuration parameters and sets up the
 * config table.
 */
int
smb_config_load()
{
    smb_cfg_id_t id;
    smb_cfg_param_t *cfg;
    char *value;

    (void) rw_rdlock(&smb_cfg_rwlk);
    for (id = 0; id < SMB_CI_MAX; id++) {
        value = smb_config_getenv_dec(id);
        cfg = &smb_cfg_table[id];
        /*
         * enval == 0 could mean two things, either the
         * config param is not defined, or it has been
         * removed. If the variable has already been defined
         * and now enval is 0, it should be removed, otherwise
         * we don't need to do anything in this case.
         */
        if ((cfg->sc_flags & SMB_CF_DEFINED) || value) {
            if (smb_config_update(cfg, value) != 0) {
                (void) rw_unlock(&smb_cfg_rwlk);
                if (value)
                    free(value);
                return (1);
            }
        }
        if (value) {
            free(value);
        }
    }

    (void) rw_unlock(&smb_cfg_rwlk);

    return (0);
}

/*
 * smb_config_get
 *
 * Returns value of the specified config param.
 * The return value is a string pointer to the locally
 * allocated memory if the config param is defined
 * otherwise it would be NULL.
 *
 * This function MUST be called after a smb_config_rd/wrlock
 * function. Caller MUST NOT modify the returned buffer directly.
 */
char *
smb_config_get(smb_cfg_id_t id)
{
    if (id < SMB_CI_MAX)
        return (smb_cfg_table[id].sc_value);

    return (0);
}

/*
 * smb_config_getstr
 *
 * Returns value of the specified config param.
 * The returned pointer never will be NULL if the given
 * 'id' is valid. If the config param is not defined its
 * default value will be returned.
 *
 * This function MUST be called after a smb_config_rd/wrlock
 * function. Caller MUST NOT modify the returned buffer directly.
 */
char *
smb_config_getstr(smb_cfg_id_t id)
{
    smb_cfg_param_t *cfg;

    if (id < SMB_CI_MAX) {
        cfg = &smb_cfg_table[id];
        if (cfg->sc_value)
            return (cfg->sc_value);
    }

    return (NULL);
}

/*
 * smb_config_getnum
 *
 * Returns the value of a numeric config param.
 * If the config param is not defined it'll return the
 * default value.
 *
 * This function MUST be called after a smb_config_rd/wrlock
 * function.
 */
uint32_t
smb_config_getnum(smb_cfg_id_t id)
{
    smb_cfg_param_t *cfg;
    char *strval = NULL;

    if (id < SMB_CI_MAX) {
        cfg = &smb_cfg_table[id];
        if (cfg->sc_value)
            strval = cfg->sc_value;

        if (strval)
            return (strtol(strval, 0, 10));
    }

    return (0);
}

/*
 * smb_config_getyorn
 *
 * Returns the value of a yes/no config param.
 * Returns 1 is config is set to "yes", otherwise 0.
 *
 * This function MUST be called after a smb_config_rd/wrlock
 * function.
 */
int
smb_config_getyorn(smb_cfg_id_t id)
{
    char *val;

    val = smb_config_get(id);
    if (val) {
        if (strcasecmp(val, "true") == 0)
            return (1);
    }

    return (0);
}

/*
 * smb_config_set
 *
 * Set/update the specified config param with the given
 * value. If the value is NULL the config param will be
 * unset as if it is not defined.
 *
 * This function MUST be called after a smb_config_wrlock
 * function.
 */
int
smb_config_set(smb_cfg_id_t id, char *value)
{
    smb_cfg_param_t *cfg;
    int rc = 0;

    if (id < SMB_CI_MAX) {
        cfg = &smb_cfg_table[id];
        rc = smb_config_update(cfg, value);
        if (rc == 0)
            cfg->sc_flags |= SMB_CF_MODIFIED;
        return (rc);
    }

    return (1);
}

/*
 * smb_config_setnum
 *
 * Set/update the specified config param with the given
 * value. This is used for numeric config params. The given
 * number will be converted to string before setting the
 * config param.
 *
 * This function MUST be called after a smb_config_wrlock
 * function.
 */
int
smb_config_setnum(smb_cfg_id_t id, uint32_t num)
{
    smb_cfg_param_t *cfg;
    char value[32];
    int rc = 0;

    if (id < SMB_CI_MAX) {
        cfg = &smb_cfg_table[id];
        (void) snprintf(value, sizeof (value), "%u", num);
        rc = smb_config_update(cfg, value);
        if (rc == 0)
            cfg->sc_flags |= SMB_CF_MODIFIED;
        return (rc);
    }

    return (1);
}

/*
 * smb_config_rdlock
 *
 * Lock the config table for read access.
 * This function MUST be called before any kind of
 * read access to the config table i.e. all flavors of
 * smb_config_get function
 */
void
smb_config_rdlock()
{
    (void) rw_rdlock(&smb_cfg_rwlk);
    lock_type = SMB_CL_READ;
}

/*
 * smb_config_wrlock
 *
 * Lock the config table for write access.
 * This function MUST be called before any kind of
 * write access to the config table i.e. all flavors of
 * smb_config_set function
 */
void
smb_config_wrlock()
{
    (void) rw_wrlock(&smb_cfg_rwlk);
    lock_type = SMB_CL_WRITE;
}

/*
 * smb_config_wrlock
 *
 * Unlock the config table.
 * If the config table has been locked for write access
 * smb_config_save_all() will be called to save the changes
 * before unlocking the table.
 *
 * This function MUST be called after smb_config_rd/wrlock
 */
void
smb_config_unlock()
{
    if (lock_type == SMB_CL_WRITE)
        (void) smb_config_save_all();
    (void) rw_unlock(&smb_cfg_rwlk);
}

/*
 * smb_config_save_all
 *
 * Save all modified parameters to SMF.
 */
static int
smb_config_save_all()
{
    int rc;

    if ((rc = smb_config_save(SMBD_PG_NAME)) != 0)
        return (rc);

    return (smb_config_save(SMBD_PROTECTED_PG_NAME));
}

/*
 * smb_config_save
 *
 * Scan the config table and call smb_config_setenv/smb_config_unsetenv
 * for params in the specified property group that has been modified.
 * When the scan is finished, smb_config_saveenv() will be called to
 * make the changes persistent.
 */
static int
smb_config_save(char *pgname)
{
    smb_cfg_id_t id;
    smb_cfg_param_t *cfg;
    smb_scfhandle_t *handle = NULL;
    int dorefresh = 0;

    handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
    if (handle == NULL) {
        syslog(LOG_ERR, "smbd: cannot save configuration");
        return (1);
    }

    (void) smb_smf_create_service_pgroup(handle, pgname);
    if (smb_smf_start_transaction(handle) != SMBD_SMF_OK) {
        syslog(LOG_ERR, "smbd: cannot save configuration");
        return (1);
    }

    for (id = 0; id < SMB_CI_MAX; id++) {
        cfg = &smb_cfg_table[id];
        if (strcmp(cfg->sc_pg, pgname))
            continue;

        if (cfg->sc_flags & SMB_CF_MODIFIED) {
            if (cfg->sc_value) {
                if (strcmp(pgname, SMBD_PG_NAME) == 0)
                    smb_config_setenv_trans(handle,
                        cfg->sc_type, cfg->sc_name,
                        cfg->sc_value);
                else
                    smb_config_setenv_trans_protected(
                        handle, cfg->sc_name,
                        cfg->sc_value);
            } else {
                (void) smb_config_unsetenv_trans(handle,
                    cfg->sc_name);
            }
            cfg->sc_flags &= ~SMB_CF_MODIFIED;
            dorefresh = 1;
        }
    }

    if (smb_config_saveenv(handle) != 0) {
        syslog(LOG_ERR, "smbd: cannot save configuration");
        return (1);
    }
    if (dorefresh)
        (void) smf_refresh_instance(SMBD_DEFAULT_INSTANCE_FMRI);
    return (0);
}

/*
 * smb_config_update
 *
 * Updates the specified config param with the given value.
 * This function is called both on (re)load and set.
 */
static int
smb_config_update(smb_cfg_param_t *cfg, char *value)
{
    char *curval;
    int rc = 0;
    int len;

    if (value) {
        len = strlen(value);
        if (cfg->sc_value) {
            curval = (char *)realloc(cfg->sc_value,
                (len + 1));
        } else {
            curval = (char *)malloc(len + 1);
        }

        if (curval) {
            cfg->sc_value = curval;
            (void) strcpy(cfg->sc_value, value);
            cfg->sc_flags |= SMB_CF_DEFINED;
        } else {
            rc = 1;
        }
    } else if (cfg->sc_value) {
        free(cfg->sc_value);
        cfg->sc_value = NULL;
        cfg->sc_flags &= ~SMB_CF_DEFINED;
    }

    return (rc);
}

uint8_t
smb_config_get_fg_flag()
{
    uint8_t run_fg = 0; /* Default is to run in daemon mode */
    smb_scfhandle_t *handle = NULL;

    handle = smb_smf_scf_init(SMBD_FMRI_PREFIX);
    if (handle == NULL) {
        return (run_fg);
    }

    if (smb_smf_create_service_pgroup(handle,
        SMBD_PG_NAME) != SMBD_SMF_OK) {
        smb_smf_scf_fini(handle);
        return (run_fg);
    }

    if (smb_smf_get_boolean_property(handle, "run_fg", &run_fg) != 0) {
        smb_smf_scf_fini(handle);
        return (run_fg);
    }

    smb_smf_scf_fini(handle);

    return (run_fg);
}

/*
 * smb_config_get_localsid
 *
 * Returns value of the "config/machine_sid" parameter
 * from the IDMAP SMF configuration repository.
 *
 */
char *
smb_config_get_localsid(void)
{
    return (smb_config_getenv_generic(MACHINE_SID, IDMAP_FMRI_PREFIX,
        IDMAP_PG_NAME));
}

/*
 * smb_config_set_idmap_domain
 *
 * Set the "config/mapping_domain" parameter from IDMAP SMF repository.
 */
int
smb_config_set_idmap_domain(char *value)
{
    return (smb_config_setenv_generic(IDMAP_FMRI_PREFIX, IDMAP_PG_NAME,
        MAPPING_DOMAIN, value));
}

/*
 * smb_config_set_idmap_gc
 *
 * Set the "config/global_catalog" parameter from IDMAP SMF repository.
 */
int
smb_config_set_idmap_gc(char *value)
{
    return (smb_config_setenv_generic(IDMAP_FMRI_PREFIX, IDMAP_PG_NAME,
        GLOBAL_CATALOG, value));
}

/*
 * smb_config_refresh_idmap
 *
 * Refresh IDMAP SMF service after making changes to its configuration.
 */
int
smb_config_refresh_idmap(void)
{
    char instance[32];

    (void) snprintf(instance, sizeof (instance), "%s:default",
        IDMAP_FMRI_PREFIX);
    return (smf_refresh_instance(instance));
}

int
smb_config_secmode_fromstr(char *secmode)
{
    if (secmode == NULL)
        return (SMB_SECMODE_WORKGRP);

    if (strcasecmp(secmode, SMB_SECMODE_DOMAIN_STR) == 0)
        return (SMB_SECMODE_DOMAIN);

    return (SMB_SECMODE_WORKGRP);
}

char *
smb_config_secmode_tostr(int secmode)
{
    if (secmode == SMB_SECMODE_DOMAIN)
        return (SMB_SECMODE_DOMAIN_STR);

    return (SMB_SECMODE_WORKGRP_STR);
}

int
smb_config_get_secmode()
{
    char *p;

    p = smb_config_getstr(SMB_CI_SECURITY);
    return (smb_config_secmode_fromstr(p));
}

int
smb_config_set_secmode(int secmode)
{
    char *p;

    p = smb_config_secmode_tostr(secmode);
    return (smb_config_set(SMB_CI_SECURITY, p));
}