/*
 * 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.
 */

/*
 * Disk & Indicator Monitor configuration file support routines
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <limits.h>
#include <pthread.h>

#include "disk_monitor.h"
#include "util.h"
#include "topo_gather.h"

extern log_class_t g_verbose;

const char *
hotplug_state_string(hotplug_state_t state)
{
	switch (state & ~HPS_FAULTED) {
	default:
	case HPS_UNKNOWN:
		return ("Unknown");
	case HPS_ABSENT:
		return ("Absent");
	case HPS_PRESENT:
		return ("Present");
	case HPS_CONFIGURED:
		return ("Configured");
	case HPS_UNCONFIGURED:
		return ("Unconfigured");
	}
}

void
conf_error_msg(conf_err_t err, char *buf, int buflen, void *arg)
{
	switch (err) {
	case E_MULTIPLE_IND_LISTS_DEFINED:
		(void) snprintf(buf, buflen, "Multiple Indicator lists "
		    "defined");
		break;
	case E_MULTIPLE_INDRULE_LISTS_DEFINED:
		(void) snprintf(buf, buflen, "Multiple Indicator rule lists "
		    "defined");
		break;
	case E_INVALID_STATE_CHANGE:
		(void) snprintf(buf, buflen, "Invalid state change");
		break;
	case E_IND_MULTIPLY_DEFINED:
		(void) snprintf(buf, buflen,
		    "Multiple Indicator definitions (name & state) detected");
		break;
	case E_IND_ACTION_REDUNDANT:
		(void) snprintf(buf, buflen, "Redundant Indicator actions "
		    "specified");
		break;
	case E_IND_ACTION_CONFLICT:
		(void) snprintf(buf, buflen, "Indicator action conflict (+/- "
		    "same Indicator) found");
		break;
	case E_IND_MISSING_FAULT_ON:
		(void) snprintf(buf, buflen, "Missing declaration of `+"
		    INDICATOR_FAULT_IDENTIFIER "'");
		break;
	case E_IND_MISSING_FAULT_OFF:
		(void) snprintf(buf, buflen, "Missing declaration of `-"
		    INDICATOR_FAULT_IDENTIFIER "'");
		break;
	case E_INDRULE_REFERENCES_NONEXISTENT_IND_ACTION:
		(void) snprintf(buf, buflen, "`%c%s': Undefined Indicator in "
		    BAY_IND_ACTION " property",
		    (((ind_action_t *)arg)->ind_state == INDICATOR_ON)
		    ? '+' : '-',
		    ((ind_action_t *)arg)->ind_name);
		break;
	case E_DUPLICATE_STATE_TRANSITION:
		(void) snprintf(buf, buflen, "Duplicate state transition "
		    "(%s -> %s)",
		    hotplug_state_string(((state_transition_t *)arg)->begin),
		    hotplug_state_string(((state_transition_t *)arg)->end));
		break;
	default:
		(void) snprintf(buf, buflen, "Unknown error");
		break;
	}
}

static int
string_to_integer(const char *prop, int *value)
{
	long val;

	errno = 0;

	val = strtol(prop, NULL, 0);

	if (val == 0 && errno != 0)
		return (-1);
	else if (val > INT_MAX || val < INT_MIN) {
		errno = ERANGE;
		return (-1);
	}

	if (value != NULL)
		*value = (int)val;

	return (0);
}

const char *
dm_prop_lookup(nvlist_t *props, const char *prop_name)
{
	char *str;

	if (nvlist_lookup_string(props, prop_name, &str) == 0)
		return ((const char *)str);
	else
		return (NULL);
}

int
dm_prop_lookup_int(nvlist_t *props, const char *prop_name, int *value)
{
	const char *prop = dm_prop_lookup(props, prop_name);

	if (prop == NULL)
		return (-1);

	return (string_to_integer(prop, value));
}

nvlist_t *
namevalpr_to_nvlist(namevalpr_t *nvprp)
{
	nvlist_t *nvlp = NULL;

	if (nvlist_alloc(&nvlp, NV_UNIQUE_NAME, 0) != 0) {
		return (NULL);
	}

	if (nvlist_add_string(nvlp, nvprp->name, nvprp->value) != 0) {
		nvlist_free(nvlp);
		return (NULL);
	}

	return (nvlp);
}

indicator_t *
new_indicator(ind_state_t lstate, char *namep, char *actionp)
{
	indicator_t *newindicator =
	    (indicator_t *)dmalloc(sizeof (indicator_t));
	newindicator->ind_state = lstate;
	newindicator->ind_name = namep ? dstrdup(namep) : NULL;
	newindicator->ind_instr_spec = actionp ? dstrdup(actionp) : NULL;
	newindicator->next = NULL;
	return (newindicator);
}

void
link_indicator(indicator_t **first, indicator_t *to_add)
{
	indicator_t *travptr;
	dm_assert(first != NULL);

	if (*first == NULL)
		*first = to_add;
	else {
		travptr = *first;
		while (travptr->next != NULL) {
			travptr = travptr->next;
		}
		travptr->next = to_add;
	}
}

void
ind_free(indicator_t *indp)
{
	indicator_t *nextp;

	while (indp != NULL) {
		nextp = indp->next;
		if (indp->ind_name)
			dstrfree(indp->ind_name);
		if (indp->ind_instr_spec)
			dstrfree(indp->ind_instr_spec);
		dfree(indp, sizeof (indicator_t));
		indp = nextp;
	}
}

ind_action_t *
new_indaction(ind_state_t state, char *namep)
{
	ind_action_t *lap = (ind_action_t *)dmalloc(sizeof (ind_action_t));
	lap->ind_state = state;
	lap->ind_name = namep ? dstrdup(namep) : NULL;
	lap->next = NULL;
	return (lap);
}

void
link_indaction(ind_action_t **first, ind_action_t *to_add)
{
	ind_action_t *travptr;
	dm_assert(first != NULL);

	if (*first == NULL)
		*first = to_add;
	else {
		travptr = *first;
		while (travptr->next != NULL) {
			travptr = travptr->next;
		}
		travptr->next = to_add;
	}
}

void
indaction_free(ind_action_t *lap)
{
	ind_action_t *nextp;

	/* Free the whole list */
	while (lap != NULL) {
		nextp = lap->next;
		if (lap->ind_name)
			dstrfree(lap->ind_name);
		dfree(lap, sizeof (ind_action_t));
		lap = nextp;
	}
}

indrule_t *
new_indrule(state_transition_t *st, ind_action_t *actionp)
{
	indrule_t *lrp = (indrule_t *)dmalloc(sizeof (indrule_t));
	if (st != NULL)
		lrp->strans = *st;
	lrp->action_list = actionp;
	lrp->next = NULL;
	return (lrp);
}

void
link_indrule(indrule_t **first, indrule_t *to_add)
{
	indrule_t *travptr;
	dm_assert(first != NULL);

	if (*first == NULL)
		*first = to_add;
	else {
		travptr = *first;
		while (travptr->next != NULL) {
			travptr = travptr->next;
		}
		travptr->next = to_add;
	}
}

void
indrule_free(indrule_t *lrp)
{
	indrule_t *nextp;

	/* Free the whole list */
	while (lrp != NULL) {
		nextp = lrp->next;
		if (lrp->action_list)
			indaction_free(lrp->action_list);
		dfree(lrp, sizeof (indrule_t));
		lrp = nextp;
	}
}

dm_fru_t *
new_dmfru(char *manu, char *modl, char *firmrev, char *serno, uint64_t capa)
{
	dm_fru_t *frup = (dm_fru_t *)dzmalloc(sizeof (dm_fru_t));

	bcopy(manu, frup->manuf, MIN(sizeof (frup->manuf), strlen(manu) + 1));
	bcopy(modl, frup->model, MIN(sizeof (frup->model), strlen(modl) + 1));
	bcopy(firmrev, frup->rev, MIN(sizeof (frup->rev), strlen(firmrev) + 1));
	bcopy(serno, frup->serial,
	    MIN(sizeof (frup->serial), strlen(serno) + 1));
	frup->size_in_bytes = capa;
	return (frup);
}

void
dmfru_free(dm_fru_t *frup)
{
	dfree(frup, sizeof (dm_fru_t));
}

diskmon_t *
new_diskmon(nvlist_t *app_props, indicator_t *indp, indrule_t *indrp,
    nvlist_t *nvlp)
{
	diskmon_t *dmp = (diskmon_t *)dmalloc(sizeof (diskmon_t));

	if (nvlp != NULL)
		dmp->props = nvlp;
	else
		(void) nvlist_alloc(&dmp->props, NV_UNIQUE_NAME, 0);

	if (app_props)
		dmp->app_props = app_props;
	else
		(void) nvlist_alloc(&dmp->app_props, NV_UNIQUE_NAME, 0);
	dmp->ind_list = indp;
	dmp->indrule_list = indrp;

	dm_assert(pthread_mutex_init(&dmp->manager_mutex, NULL) == 0);

	dmp->state = HPS_UNKNOWN;

	dmp->initial_configuration = B_TRUE;

	dm_assert(pthread_mutex_init(&dmp->fault_indicator_mutex, NULL) == 0);
	dmp->fault_indicator_state = INDICATOR_UNKNOWN;

	dmp->configured_yet = B_FALSE;
	dmp->state_change_count = 0;

	dm_assert(pthread_mutex_init(&dmp->fru_mutex, NULL) == 0);
	dmp->frup = NULL;

	dmp->next = NULL;
	return (dmp);
}

void
diskmon_free(diskmon_t *dmp)
{
	diskmon_t *nextp;

	/* Free the whole list */
	while (dmp != NULL) {
		nextp = dmp->next;

		nvlist_free(dmp->props);
		if (dmp->location)
			dstrfree(dmp->location);
		if (dmp->ind_list)
			ind_free(dmp->ind_list);
		if (dmp->indrule_list)
			indrule_free(dmp->indrule_list);
		nvlist_free(dmp->app_props);
		if (dmp->frup)
			dmfru_free(dmp->frup);
		dfree(dmp, sizeof (diskmon_t));

		dmp = nextp;
	}
}

static cfgdata_t *
new_cfgdata(namevalpr_t *nvp, diskmon_t *dmp)
{
	cfgdata_t *cdp = (cfgdata_t *)dzmalloc(sizeof (cfgdata_t));

	if (nvp != NULL)
		cdp->props = namevalpr_to_nvlist(nvp);
	else if (nvlist_alloc(&cdp->props, NV_UNIQUE_NAME, 0) != 0) {
		return (NULL);
	}

	if (dmp != NULL)
		cdp->disk_list = dmp;
	return (cdp);

}

static void
cfgdata_add_namevalpr(cfgdata_t *cfgp, namevalpr_t *nvp)
{
	if (cfgp->props == NULL) {
		(void) nvlist_alloc(&cfgp->props, NV_UNIQUE_NAME, 0);
	}
	(void) nvlist_add_string(cfgp->props, nvp->name, nvp->value);
}

void
cfgdata_add_diskmon(cfgdata_t *cfgp, diskmon_t *dmp)
{
	if (cfgp->disk_list == NULL) {
		cfgp->disk_list = dmp;
	} else {
		diskmon_t *disklist = cfgp->disk_list;

		while (disklist->next != NULL)
			disklist = disklist->next;

		disklist->next = dmp;
	}
}

static void
cfgdata_free(cfgdata_t *cdp)
{
	nvlist_free(cdp->props);
	diskmon_free(cdp->disk_list);
	dfree(cdp, sizeof (cfgdata_t));
}

conf_err_t
check_indactions(ind_action_t *indrp)
{
	char *buf;
	conf_err_t rv = E_NO_ERROR;
	nvlist_t *nvp = NULL;
	int len;

	(void) nvlist_alloc(&nvp, NV_UNIQUE_NAME, 0);

	/*
	 * Check indicator actions for conflicts
	 */
	while (indrp != NULL && rv == E_NO_ERROR) {
		len = strlen(indrp->ind_name) + 2;
		buf = dmalloc(len);
		(void) snprintf(buf, len, "%c%s",
		    indrp->ind_state == INDICATOR_ON ? '+' : '-',
		    indrp->ind_name);
		switch (nvlist_lookup_boolean(nvp, buf)) {
		case ENOENT:
			(void) nvlist_add_boolean(nvp, buf);
			break;
		case 0:
			rv = E_IND_ACTION_REDUNDANT;
			break;
		default:
			break;
		}

		/* Look for the opposite action.  If found, that's an error */
		(void) snprintf(buf, len, "%c%s",
		    indrp->ind_state == INDICATOR_ON ? '-' : '+',
		    indrp->ind_name);
		switch (nvlist_lookup_boolean(nvp, buf)) {
		case ENOENT:
			break;
		case 0:
			rv = E_IND_ACTION_CONFLICT;
			break;
		default:
			break;
		}
		dfree(buf, len);
		indrp = indrp->next;
	}

	nvlist_free(nvp);
	return (rv);
}

conf_err_t
check_inds(indicator_t *indp)
{
	char *buf;
	conf_err_t rv = E_NO_ERROR;
	nvlist_t *nvp = NULL;
	int len;
	boolean_t fault_on = B_FALSE, fault_off = B_FALSE;

	(void) nvlist_alloc(&nvp, NV_UNIQUE_NAME, 0);

	/*
	 * Check inds for multiple definitions (same identifier or same action)
	 */
	while (indp != NULL && rv == E_NO_ERROR) {
		len = strlen(indp->ind_name) + 2;
		buf = dmalloc(len);
		(void) snprintf(buf, len, "%c%s",
		    indp->ind_state == INDICATOR_ON ? '+' : '-',
		    indp->ind_name);

		/* Keep track of the +/-FAULT for checking later */
		if (strcasecmp(buf, "+" INDICATOR_FAULT_IDENTIFIER) == 0)
			fault_on = B_TRUE;
		else if (strcasecmp(buf, "-" INDICATOR_FAULT_IDENTIFIER) == 0)
			fault_off = B_TRUE;

		switch (nvlist_lookup_boolean(nvp, buf)) {
		case ENOENT:
			(void) nvlist_add_boolean(nvp, buf);
			break;
		case 0:
			rv = E_IND_MULTIPLY_DEFINED;
			break;
		default:
			break;
		}
		dfree(buf, len);
		indp = indp->next;
	}

	/*
	 * Make sure we have a -FAULT and +FAULT
	 */
	if (!fault_on)
		rv = E_IND_MISSING_FAULT_ON;
	else if (!fault_off)
		rv = E_IND_MISSING_FAULT_OFF;

	nvlist_free(nvp);
	return (rv);
}

conf_err_t
check_indrules(indrule_t *indrp, state_transition_t **offender)
{
	char buf[32];
	conf_err_t rv = E_NO_ERROR;
	nvlist_t *nvp = NULL;

	/*
	 * Ensure that no two rules have the same state transitions.
	 */

	(void) nvlist_alloc(&nvp, NV_UNIQUE_NAME, 0);

	while (indrp != NULL && rv == E_NO_ERROR) {
		(void) snprintf(buf, sizeof (buf), "%d-%d",
		    (int)indrp->strans.begin, (int)indrp->strans.end);
		switch (nvlist_lookup_boolean(nvp, buf)) {
		case 0:
			*offender = &indrp->strans;
			rv = E_DUPLICATE_STATE_TRANSITION;
			break;
		case ENOENT:
			(void) nvlist_add_boolean(nvp, buf);
			break;
		default:
			break;
		}
		indrp = indrp->next;
	}

	nvlist_free(nvp);
	return (rv);
}


conf_err_t
check_consistent_ind_indrules(indicator_t *indp, indrule_t *indrp,
    ind_action_t **offender)
{
	char *buf;
	conf_err_t rv = E_NO_ERROR;
	nvlist_t *nvp = NULL;
	ind_action_t *alp;
	int len;

	/*
	 * Ensure that every indicator action referenced in each ruleset
	 * exists in the indicator list given.
	 */

	(void) nvlist_alloc(&nvp, NV_UNIQUE_NAME, 0);

	while (indp != NULL) {
		len = strlen(indp->ind_name) + 2;
		buf = dmalloc(len);
		(void) snprintf(buf, len, "%c%s",
		    indp->ind_state == INDICATOR_ON ? '+' : '-',
		    indp->ind_name);
		(void) nvlist_add_boolean(nvp, buf);
		dfree(buf, len);
		indp = indp->next;
	}

	while (indrp != NULL && rv == E_NO_ERROR) {
		alp = indrp->action_list;
		while (alp != NULL && rv == E_NO_ERROR) {
			len = strlen(alp->ind_name) + 2;
			buf = dmalloc(len);
			(void) snprintf(buf, len, "%c%s",
			    alp->ind_state == INDICATOR_ON ? '+' : '-',
			    alp->ind_name);

			switch (nvlist_lookup_boolean(nvp, buf)) {
			case 0:		/* Normal case */
				break;
			case ENOENT:
				*offender = alp;
				rv =
				    E_INDRULE_REFERENCES_NONEXISTENT_IND_ACTION;
				break;
			default:
				break;
			}
			dfree(buf, len);
			alp = alp->next;
		}
		indrp = indrp->next;
	}

	nvlist_free(nvp);
	return (rv);
}

conf_err_t
check_state_transition(hotplug_state_t s1, hotplug_state_t s2)
{
	/*
	 * The following are valid transitions:
	 *
	 * HPS_ABSENT -> HPS_PRESENT
	 * HPS_ABSENT -> HPS_CONFIGURED
	 * HPS_PRESENT -> HPS_CONFIGURED
	 * HPS_PRESENT -> HPS_ABSENT
	 * HPS_CONFIGURED -> HPS_UNCONFIGURED
	 * HPS_CONFIGURED -> HPS_ABSENT
	 * HPS_UNCONFIGURED -> HPS_ABSENT
	 * HPS_UNCONFIGURED -> HPS_CONFIGURED
	 *
	 */
	if (s1 == HPS_ABSENT && s2 != HPS_PRESENT && s2 != HPS_CONFIGURED)
		return (E_INVALID_STATE_CHANGE);
	else if (s1 == HPS_PRESENT && (s2 != HPS_CONFIGURED &&
	    s2 != HPS_ABSENT))
		return (E_INVALID_STATE_CHANGE);
	else if (s1 == HPS_CONFIGURED && (s2 != HPS_UNCONFIGURED &&
	    s2 != HPS_ABSENT))
		return (E_INVALID_STATE_CHANGE);
	else if (s1 == HPS_UNCONFIGURED && (s2 != HPS_ABSENT &&
	    s2 != HPS_CONFIGURED))
		return (E_INVALID_STATE_CHANGE);
	else
		return (E_NO_ERROR);
}

static void
print_inds(indicator_t *indp, FILE *fp, char *prefix)
{
	char plusminus;

	(void) fprintf(fp, "%sindicators {\n", prefix);
	while (indp != NULL) {
		plusminus = (indp->ind_state == INDICATOR_ON) ? '+' : '-';
		(void) fprintf(fp, "%s\t%c%s = \"%s\"\n", prefix, plusminus,
		    indp->ind_name, indp->ind_instr_spec);
		indp = indp->next;
	}
	(void) fprintf(fp, "%s}\n", prefix);
}

static void
print_indrules(indrule_t *lrp, FILE *fp, char *prefix)
{
	char plusminus;
	ind_action_t *lap;

	(void) fprintf(fp, "%sindicator_rules {\n", prefix);
	while (lrp != NULL) {
		(void) fprintf(fp, "%s\t%12s -> %12s\t{ ", prefix,
		    hotplug_state_string(lrp->strans.begin),
		    hotplug_state_string(lrp->strans.end));
		lap = lrp->action_list;
		while (lap != NULL) {
			plusminus = (lap->ind_state == INDICATOR_ON)
			    ? '+' : '-';
			(void) fprintf(fp, "%c%s", plusminus, lap->ind_name);
			lap = lap->next;
			if (lap != NULL)
				(void) fprintf(fp, ", ");
		}
		(void) fprintf(fp, " }\n");
		lrp = lrp->next;
	}
	(void) fprintf(fp, "%s}\n", prefix);
}

static void
print_props(nvlist_t *nvlp, FILE *fp, char *prefix)
{
	nvpair_t *nvp = nvlist_next_nvpair(nvlp, NULL);
	char *name, *str;

	while (nvp != NULL) {
		dm_assert(nvpair_type(nvp) == DATA_TYPE_STRING);
		name = nvpair_name(nvp);
		(void) nvlist_lookup_string(nvlp, name, &str);
		(void) fprintf(fp, "%s%s = \"%s\"\n", prefix, name, str);
		nvp = nvlist_next_nvpair(nvlp, nvp);
	}
}

static void
print_ap(nvlist_t *dpp, FILE *fp, char *prefix)
{
	int len = strlen(prefix) + 2;
	char *buf = dmalloc(len);

	(void) snprintf(buf, len, "%s\t", prefix);

	(void) fprintf(fp, "%sap_props {\n", prefix);
	print_props(dpp, fp, buf);
	(void) fprintf(fp, "%s}\n", prefix);

	dfree(buf, len);
}

static void
print_disks(diskmon_t *dmp, FILE *fp, char *prefix)
{
	int len = strlen(prefix) + 2;
	char *buf = dmalloc(len);

	(void) snprintf(buf, len, "%s\t", prefix);

	while (dmp != NULL) {
		(void) fprintf(fp, "%sdisk \"%s\" {\n", prefix, dmp->location);
		if (dmp->props) {
			print_props(dmp->props, fp, buf);
		}
		if (dmp->app_props) {
			print_ap(dmp->app_props, fp, buf);
		}
		(void) fprintf(fp, "%s\n", prefix);
		print_inds(dmp->ind_list, fp, buf);
		(void) fprintf(fp, "%s\n", prefix);
		print_indrules(dmp->indrule_list, fp, buf);
		(void) fprintf(fp, "%s}\n", prefix);

		if (dmp->next != NULL)
			(void) fprintf(fp, "%s\n", prefix);

		dmp = dmp->next;
	}

	dfree(buf, len);
}

static void
print_cfgdata(cfgdata_t *cfgp, FILE *fp, char *prefix)
{
	/* First, print the properties, then the disks */

	print_props(cfgp->props, fp, prefix);
	(void) fprintf(fp, "%s\n", prefix);
	print_disks(cfgp->disk_list, fp, prefix);
}

int
config_init(void)
{
	if (init_configuration_from_topo() == 0) {
		config_data = new_cfgdata(NULL, NULL);
		return (0);
	}
	return (-1);
}

int
config_get(fmd_hdl_t *hdl, const fmd_prop_t *fmd_props)
{
	int err, i = 0;
	char *str = NULL;
	namevalpr_t nvp;
	uint64_t u64;
	boolean_t intfound = B_FALSE, strfound = B_FALSE;
#define	INT64_BUF_LEN 128
	char buf[INT64_BUF_LEN];

	u64 = fmd_prop_get_int32(hdl, GLOBAL_PROP_LOG_LEVEL);
	g_verbose = (int)u64;

	err = update_configuration_from_topo(hdl, NULL);

	/* Pull in the properties from the DE configuration file */
	while (fmd_props[i].fmdp_name != NULL) {

		nvp.name = (char *)fmd_props[i].fmdp_name;

		switch (fmd_props[i].fmdp_type) {
		case FMD_TYPE_UINT32:
		case FMD_TYPE_INT32:
			intfound = B_TRUE;
			u64 = fmd_prop_get_int32(hdl, fmd_props[i].fmdp_name);
			break;
		case FMD_TYPE_UINT64:
		case FMD_TYPE_INT64:
			intfound = B_TRUE;
			u64 = fmd_prop_get_int64(hdl, fmd_props[i].fmdp_name);
			break;
		case FMD_TYPE_STRING:
			strfound = B_TRUE;
			str = fmd_prop_get_string(hdl, fmd_props[i].fmdp_name);
			break;

		}

		if (intfound) {
			(void) snprintf(buf, INT64_BUF_LEN, "0x%llx", u64);
			nvp.value = buf;
			intfound = B_FALSE;
		} else if (strfound) {
			nvp.value = str;
		}

		log_msg(MM_CONF, "Adding property `%s' with value `%s'\n",
		    nvp.name, nvp.value);

		cfgdata_add_namevalpr(config_data, &nvp);

		if (strfound) {
			strfound = B_FALSE;
			fmd_prop_free_string(hdl, str);
		}


		i++;
	}

	if ((g_verbose & (MM_CONF|MM_OTHER)) == (MM_CONF|MM_OTHER))
		print_cfgdata(config_data, stderr, "");

	return (err);
}

void
config_fini(void)
{
	fini_configuration_from_topo();
	cfgdata_free(config_data);
	config_data = NULL;
}

nvlist_t *
dm_global_proplist(void)
{
	return (config_data->props);
}