/*

 * 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"

#include <strings.h>

#include <assert.h>

#include <fm/libtopo.h>

#include <topo_prop.h>

#include <topo_string.h>

#include <topo_alloc.h>

#include <topo_error.h>

#include <topo_method.h>

/*

 * Topology nodes are permitted to contain property information.

 * Property information is organized according to property grouping.

 * Each property group defines a name, a stability level for that name,

 * a stability level for all underlying property data (name, type, values),

 * a version for the property group definition and and a list of uniquely

 * defined properties.  Property group versions are incremented when one of

 * the following changes occurs:

 *	- a property name changes

 *	- a property type changes

 *	- a property definition is removed from the group

 * Compatible changes such as new property definitions in the group do

 * not require version changes.

 *

 * Each property defines a unique (within the group) name, a type and

 * a value.  Properties may be statically defined as int32, uint32, int64,

 * uint64, fmri, string or arrays of each type.  Properties may also be

 * dynamically exported via module registered methods.  For example, a module

 * may register a method to export an ASRU property that is dynamically

 * contructed when a call to topo_node_fmri() is invoked for a particular

 * topology node.

 *

 * Static properties are persistently attached to topology nodes during

 * enumeration by an enumeration module or as part of XML statements in a

 * toplogy map file using the topo_prop_set* family of routines.  Similarly,

 * property methods are registered during enumeration or as part of

 * statements in topololgy map files.  Set-up of property methods is performed

 * by calling topo_prop_method_register().

 *

 * All properties, whether statically persisted in a snapshot or dynamically

 * obtained, may be read via the topo_prop_get* family of interfaces.

 * Callers wishing to receive all property groups and properties for a given

 * node may use topo_prop_getall().  This routine returns a nested nvlist

 * of all groupings and property (name, type, value) sets.  Groupings

 * are defined by TOPO_PROP_GROUP (name, data stability, name stability and

 * version) and a nested nvlist of properties (TOPO_PROP_VAL).  Each property

 * value is defined by its name, type and value.

 */

static void topo_propval_destroy(topo_propval_t *);

static topo_pgroup_t *

pgroup_get(tnode_t *node, const char *pgname)

{

	topo_pgroup_t *pg;

	/*

	 * Check for an existing pgroup

	 */

	for (pg = topo_list_next(&node->tn_pgroups); pg != NULL;

	    pg = topo_list_next(pg)) {

		if (strcmp(pg->tpg_info->tpi_name, pgname) == 0) {

			return (pg);

		}

	}

	return (NULL);

}

static topo_propval_t *

propval_get(topo_pgroup_t *pg, const char *pname)

{

	topo_proplist_t *pvl;

	if (pg == NULL)

		return (NULL);

	for (pvl = topo_list_next(&pg->tpg_pvals); pvl != NULL;

	    pvl = topo_list_next(pvl)) {

		if (strcmp(pvl->tp_pval->tp_name, pname) == 0)

			return (pvl->tp_pval);

	}

	return (NULL);

}

static int

method_geterror(nvlist_t *nvl, int err, int *errp)

{

	if (nvl != NULL)

		nvlist_free(nvl);

	*errp = err;

	return (-1);

}

static int

prop_method_get(tnode_t *node, topo_propval_t *pv, topo_propmethod_t *pm,

    nvlist_t *pargs, int *err)

{

	int ret;

	nvlist_t *args, *nvl;

	char *name;

	topo_type_t type;

	if (topo_hdl_nvalloc(pv->tp_hdl, &args, NV_UNIQUE_NAME) < 0 ||

	    nvlist_add_nvlist(args, TOPO_PROP_ARGS, pm->tpm_args) != 0)

		return (method_geterror(NULL, ETOPO_PROP_NVL, err));

	if (pargs != NULL)

		if (nvlist_add_nvlist(args, TOPO_PROP_PARGS, pargs) != 0)

			return (method_geterror(args, ETOPO_PROP_NVL, err));

	if (topo_method_call(node, pm->tpm_name, pm->tpm_version,

		return (method_geterror(args, *err, err));

	nvlist_free(args);

	/* Verify the property contents */

	ret = nvlist_lookup_string(nvl, TOPO_PROP_VAL_NAME, &name);

	if (ret != 0 || strcmp(name, pv->tp_name) != 0)

		return (method_geterror(nvl, ETOPO_PROP_NAME, err));

	ret = nvlist_lookup_uint32(nvl, TOPO_PROP_VAL_TYPE, (uint32_t *)&type);

	if (ret != 0 || type != pv->tp_type)

		return (method_geterror(nvl, ETOPO_PROP_TYPE, err));

	/* Release the last value and re-assign to the new value */

	if (pv->tp_val != NULL)

		nvlist_free(pv->tp_val);

	pv->tp_val = nvl;

	return (0);

}

static topo_propval_t *

prop_get(tnode_t *node, const char *pgname, const char *pname, nvlist_t *pargs,

    int *err)

{

	topo_propval_t *pv = NULL;

	if ((pv = propval_get(pgroup_get(node, pgname), pname)) == NULL) {

		*err = ETOPO_PROP_NOENT;

		return (NULL);

	}

	if (pv->tp_method != NULL) {

		if (prop_method_get(node, pv, pv->tp_method, pargs, err) < 0)

			return (NULL);

	}

	return (pv);

}

static int

get_properror(tnode_t *node, int *errp, int err)

{

	topo_node_unlock(node);

	*errp = err;

	return (-1);

}

static int

prop_getval(tnode_t *node, const char *pgname, const char *pname, void *val,

    topo_type_t type, uint_t *nelems, int *err)

{

	int i, j, ret = 0;

	topo_hdl_t *thp = node->tn_hdl;

	topo_propval_t *pv;

	topo_node_lock(node);

	if ((pv = prop_get(node, pgname, pname, NULL, err))

	    == NULL)

		return (get_properror(node, err, *err));

	if (pv->tp_type != type)

		return (get_properror(node, err, ETOPO_PROP_TYPE));

	switch (type) {

		case TOPO_TYPE_INT32:

			ret = nvlist_lookup_int32(pv->tp_val, TOPO_PROP_VAL_VAL,

			    (int32_t *)val);

			break;

		case TOPO_TYPE_UINT32:

			ret = nvlist_lookup_uint32(pv->tp_val,

			    TOPO_PROP_VAL_VAL, (uint32_t *)val);

			break;

		case TOPO_TYPE_INT64:

			ret = nvlist_lookup_int64(pv->tp_val, TOPO_PROP_VAL_VAL,

			    (int64_t *)val);

			break;

		case TOPO_TYPE_UINT64:

			ret = nvlist_lookup_uint64(pv->tp_val,

			    TOPO_PROP_VAL_VAL, (uint64_t *)val);

			break;

		case TOPO_TYPE_STRING: {

			char *str;

			ret = nvlist_lookup_string(pv->tp_val,

			    TOPO_PROP_VAL_VAL, &str);

			if (ret == 0) {

				char *s2;

				if ((s2 = topo_hdl_strdup(thp, str)) == NULL)

					ret = -1;

				else

					*(char **)val = s2;

			}

			break;

		}

		case TOPO_TYPE_FMRI: {

			nvlist_t *nvl;

			ret = nvlist_lookup_nvlist(pv->tp_val,

			    TOPO_PROP_VAL_VAL, &nvl);

			if (ret == 0)

				ret = topo_hdl_nvdup(thp, nvl,

				    (nvlist_t **)val);

			break;

		}

		case TOPO_TYPE_INT32_ARRAY: {

			int32_t *a1, *a2;

			if ((ret = nvlist_lookup_int32_array(pv->tp_val,

			    TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)

				break;

			if ((a1 = topo_hdl_alloc(thp, sizeof (int32_t) *

			    *nelems)) == NULL) {

				ret = ETOPO_NOMEM;

				break;

			}

			for (i = 0; i < *nelems; ++i)

				a1[i] = a2[i];

			*(int32_t **)val = a1;

			break;

		}

		case TOPO_TYPE_UINT32_ARRAY: {

			uint32_t *a1, *a2;

			if ((ret = nvlist_lookup_uint32_array(pv->tp_val,

			    TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)

				break;

			if ((a1 = topo_hdl_alloc(thp, sizeof (uint32_t) *

			    *nelems)) == NULL) {

				ret = ETOPO_NOMEM;

				break;

			}

			for (i = 0; i < *nelems; ++i)

				a1[i] = a2[i];

			*(uint32_t **)val = a1;

			break;

		}

		case TOPO_TYPE_INT64_ARRAY: {

			int64_t *a1, *a2;

			if ((ret = nvlist_lookup_int64_array(pv->tp_val,

			    TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)

				break;

			if ((a1 = topo_hdl_alloc(thp, sizeof (int64_t) *

			    *nelems)) == NULL) {

				ret = ETOPO_NOMEM;

				break;

			}

			for (i = 0; i < *nelems; ++i)

				a1[i] = a2[i];

			*(int64_t **)val = a1;

			break;

		}

		case TOPO_TYPE_UINT64_ARRAY: {

			uint64_t *a1, *a2;

			if ((ret = nvlist_lookup_uint64_array(pv->tp_val,

			    TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)

				break;

			if ((a1 = topo_hdl_alloc(thp, sizeof (uint64_t) *

			    *nelems)) == NULL) {

				ret = ETOPO_NOMEM;

				break;

			}

			for (i = 0; i < *nelems; ++i)

				a1[i] = a2[i];

			*(uint64_t **)val = a1;

			break;

		}

		case TOPO_TYPE_STRING_ARRAY: {

			char **a1, **a2;

			if ((ret = nvlist_lookup_string_array(pv->tp_val,

			    TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)

				break;

			if ((a1 = topo_hdl_alloc(thp, sizeof (char *) *

			    *nelems)) == NULL) {

				ret = ETOPO_NOMEM;

				break;

			}

			for (i = 0; i < *nelems; ++i) {

				if ((a1[i] = topo_hdl_strdup(thp, a2[i]))

				    == NULL) {

					for (j = 0; j < i; ++j)

						topo_hdl_free(thp, a1[j],

						    sizeof (char *));

					topo_hdl_free(thp, a1,

					    sizeof (char *) * *nelems);

					break;

				}

			}

			*(char ***)val = a1;

			break;

		}

		case TOPO_TYPE_FMRI_ARRAY: {

			nvlist_t **a1, **a2;

			if ((ret = nvlist_lookup_nvlist_array(pv->tp_val,

			    TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)

				break;

			if ((a1 = topo_hdl_alloc(thp, sizeof (nvlist_t *) *

			    *nelems)) == NULL) {

				ret = ETOPO_NOMEM;

				break;

			}

			for (i = 0; i < *nelems; ++i) {

				if (topo_hdl_nvdup(thp, a2[i], &a1[i]) < 0) {

					for (j = 0; j < i; ++j)

						nvlist_free(a1[j]);

					topo_hdl_free(thp, a1,

					    sizeof (nvlist_t *) * *nelems);

					break;

				}

			}

			*(nvlist_t ***)val = a1;

			break;

		}

		default:

			ret = ETOPO_PROP_NOENT;

	}

	if (ret != 0)

		if (ret == ENOENT)

			return (get_properror(node, err, ETOPO_PROP_NOENT));

		else if (ret < ETOPO_UNKNOWN)

			return (get_properror(node, err, ETOPO_PROP_NVL));

		else

			return (get_properror(node, err, ret));

	topo_node_unlock(node);

	return (0);

}

int

topo_prop_get_int32(tnode_t *node, const char *pgname, const char *pname,

    int32_t *val, int *err)

{

	return (prop_getval(node, pgname, pname, (void *)val, TOPO_TYPE_INT32,

	    NULL, err));

}

int

topo_prop_get_uint32(tnode_t *node, const char *pgname, const char *pname,

    uint32_t *val, int *err)

{

	return (prop_getval(node, pgname, pname, (void *)val, TOPO_TYPE_UINT32,

	    NULL, err));

}

int

topo_prop_get_int64(tnode_t *node, const char *pgname, const char *pname,

    int64_t *val, int *err)

{

	return (prop_getval(node, pgname, pname, (void *)val, TOPO_TYPE_INT64,

	    NULL, err));

}

int

topo_prop_get_uint64(tnode_t *node, const char *pgname, const char *pname,

    uint64_t *val, int *err)

{

	return (prop_getval(node, pgname, pname, (void *)val, TOPO_TYPE_UINT64,

	    NULL, err));

}

int

topo_prop_get_string(tnode_t *node, const char *pgname, const char *pname,

    char **val, int *err)

{

	return (prop_getval(node, pgname, pname, (void *)val, TOPO_TYPE_STRING,

	    NULL, err));

}

int

topo_prop_get_fmri(tnode_t *node, const char *pgname, const char *pname,

    nvlist_t **val, int *err)

{

	return (prop_getval(node, pgname, pname, (void *)val, TOPO_TYPE_FMRI,

	    NULL, err));

}

int

topo_prop_get_int32_array(tnode_t *node, const char *pgname, const char *pname,

    int32_t **val, uint_t *nelem, int *err)

{

	return (prop_getval(node, pgname, pname, (void *)val,

	    TOPO_TYPE_INT32_ARRAY, nelem, err));

}

int

topo_prop_get_uint32_array(tnode_t *node, const char *pgname, const char *pname,

    uint32_t **val, uint_t *nelem, int *err)

{

	return (prop_getval(node, pgname, pname, (void *)val,

	    TOPO_TYPE_UINT32_ARRAY, nelem, err));

}

int

topo_prop_get_int64_array(tnode_t *node, const char *pgname, const char *pname,

    int64_t **val, uint_t *nelem, int *err)

{

	return (prop_getval(node, pgname, pname, (void *)val,

	    TOPO_TYPE_INT64_ARRAY, nelem, err));

}

int

topo_prop_get_uint64_array(tnode_t *node, const char *pgname, const char *pname,

    uint64_t **val, uint_t *nelem, int *err)

{

	return (prop_getval(node, pgname, pname, (void *)val,

	    TOPO_TYPE_UINT64_ARRAY, nelem, err));

}

int

topo_prop_get_string_array(tnode_t *node, const char *pgname, const char *pname,

    char ***val, uint_t *nelem, int *err)

{

	return (prop_getval(node, pgname, pname, (void *)val,

	    TOPO_TYPE_STRING_ARRAY, nelem, err));

}

int

topo_prop_get_fmri_array(tnode_t *node, const char *pgname, const char *pname,

    nvlist_t ***val, uint_t *nelem, int *err)

{

	return (prop_getval(node, pgname, pname, (void *)val,

	    TOPO_TYPE_FMRI_ARRAY, nelem, err));

}

static topo_propval_t *

set_seterror(tnode_t *node, topo_proplist_t *pvl, int *errp, int err)

{

	topo_hdl_t *thp = node->tn_hdl;

	topo_propval_t *pv;

	if (pvl != NULL) {

		pv = pvl->tp_pval;

		topo_propval_destroy(pv);

		topo_hdl_free(thp, pvl, sizeof (topo_proplist_t));

	}

	topo_node_unlock(node);

	*errp = err;