/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Routines for traversing and packing/unpacking the handle
 * returned from ri_init.
 */

#include <stdlib.h>
#include <strings.h>
#include "rsrc_info.h"
#include "rsrc_info_impl.h"

static int ap_list_pack(ri_ap_t *, char **, size_t *, int);
static int ap_list_unpack(char *, size_t, ri_ap_t **);
static int ap_pack(ri_ap_t *, char **, size_t *, int);
static int ap_unpack(char *, size_t, ri_ap_t *);
static int dev_list_pack(ri_dev_t *, char **, size_t *, int);
static int dev_list_unpack(char *, size_t, ri_dev_t **);
static int dev_pack(ri_dev_t *, char **, size_t *, int);
static int dev_unpack(char *, size_t, ri_dev_t *);
static int client_list_pack(ri_client_t *, char **, size_t *, int);
static int client_list_unpack(char *, size_t, ri_client_t **);
static int client_pack(ri_client_t *, char **, size_t *, int);
static int client_unpack(char *, size_t, ri_client_t *);
static int pack_add_byte_array(nvlist_t *, char *, nvlist_t *, int);
static int lookup_unpack_byte_array(nvlist_t *, char *, nvlist_t **);
static void ri_ap_free(ri_ap_t *);

void
ri_fini(ri_hdl_t *hdl)
{
	ri_ap_t		*ap;
	ri_client_t	*client;

	if (hdl == NULL)
		return;

	while ((ap = hdl->aps) != NULL) {
		hdl->aps = ap->next;
		ri_ap_free(ap);
	}
	while ((client = hdl->cpu_cap_clients) != NULL) {
		hdl->cpu_cap_clients = client->next;
		ri_client_free(client);
	}
	while ((client = hdl->mem_cap_clients) != NULL) {
		hdl->mem_cap_clients = client->next;
		ri_client_free(client);
	}
	free(hdl);
}

static void
ri_ap_free(ri_ap_t *ap)
{
	ri_dev_t	*dev;

	assert(ap != NULL);

	nvlist_free(ap->conf_props);

	while ((dev = ap->cpus) != NULL) {
		ap->cpus = dev->next;
		ri_dev_free(dev);
	}
	while ((dev = ap->mems) != NULL) {
		ap->mems = dev->next;
		ri_dev_free(dev);
	}
	while ((dev = ap->ios) != NULL) {
		ap->ios = dev->next;
		ri_dev_free(dev);
	}
	free(ap);
}

void
ri_dev_free(ri_dev_t *dev)
{
	ri_client_t	*client;

	assert(dev != NULL);

	nvlist_free(dev->conf_props);
	while ((client = dev->rcm_clients) != NULL) {
		dev->rcm_clients = client->next;
		ri_client_free(client);
	}
	free(dev);
}

void
ri_client_free(ri_client_t *client)
{
	assert(client != NULL);

	nvlist_free(client->usg_props);
	nvlist_free(client->v_props);
	free(client);
}

/*
 * Pack everything contained in the handle up inside out.
 */
int
ri_pack(ri_hdl_t *hdl, caddr_t *bufp, size_t *sizep, int encoding)
{
	nvlist_t	*nvl = NULL;
	char		*buf = NULL;
	size_t		size = 0;

	if (bufp == NULL || sizep == NULL)
		return (RI_INVAL);

	*sizep = 0;
	*bufp = NULL;

	/*
	 * Check the handle. If it is NULL, there
	 * is nothing to pack, so we are done.
	 */
	if (hdl == NULL) {
		return (RI_SUCCESS);
	}

	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
		dprintf((stderr, "nvlist_alloc fail\n", errno));
		goto fail;
	}

	if (nvlist_add_int32(nvl, RI_HDL_FLAGS, hdl->flags) != 0) {
		dprintf((stderr, "nvlist_add_int32 fail\n"));
		goto fail;
	}

	if (ap_list_pack(hdl->aps, &buf, &size, encoding) != 0 ||
	    nvlist_add_byte_array(nvl, RI_HDL_APS, (uchar_t *)buf, size) != 0) {
		goto fail;
	}

	s_free(buf);
	if (client_list_pack(hdl->cpu_cap_clients, &buf, &size,
	    encoding) != 0 ||
	    nvlist_add_byte_array(nvl, RI_HDL_CPU_CAPS, (uchar_t *)buf,
	    size) != 0) {
		goto fail;
	}

	s_free(buf);
	if (client_list_pack(hdl->mem_cap_clients, &buf, &size,
	    encoding) != 0 ||
	    nvlist_add_byte_array(nvl, RI_HDL_MEM_CAPS, (uchar_t *)buf,
	    size) != 0) {
		goto fail;
	}

	s_free(buf);
	if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
		dprintf((stderr, "nvlist_pack fail\n"));
		goto fail;
	}

	nvlist_free(nvl);
	*bufp = buf;
	*sizep = size;

	return (RI_SUCCESS);

fail:
	s_free(buf);
	nvlist_free(nvl);

	return (RI_FAILURE);
}

/*
 * Pack a list of attachment point handles.
 */
static int
ap_list_pack(ri_ap_t *aplist, char **bufp, size_t *sizep, int encoding)
{
	nvlist_t	*nvl = NULL;
	char		*buf = NULL;
	size_t		size;

	assert(bufp != NULL && sizep != NULL);

	*sizep = 0;
	*bufp = NULL;

	if (nvlist_alloc(&nvl, 0, 0) != 0) {
		dprintf((stderr, "nvlist_alloc fail\n"));
		return (-1);
	}

	while (aplist != NULL) {
		s_free(buf);
		if (ap_pack(aplist, &buf, &size, encoding) != 0)
			goto fail;

		if (nvlist_add_byte_array(nvl, RI_AP_T, (uchar_t *)buf,
		    size) != 0) {
			dprintf((stderr, "nvlist_add_byte_array fail "
			    "(%s)\n", RI_AP_T));
			goto fail;
		}
		aplist = aplist->next;
	}

	s_free(buf);
	if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
		dprintf((stderr, "nvlist_pack fail\n"));
		goto fail;
	}

	nvlist_free(nvl);
	*bufp = buf;
	*sizep = size;

	return (0);

fail:
	s_free(buf);
	nvlist_free(nvl);

	return (-1);
}

/*
 * Pack a list of ri_dev_t's.
 */
static int
dev_list_pack(ri_dev_t *devlist, char **bufp, size_t *sizep, int encoding)
{
	nvlist_t	*nvl = NULL;
	char		*buf = NULL;
	size_t		size = 0;

	assert(bufp != NULL && sizep != NULL);

	*sizep = 0;
	*bufp = NULL;

	if (nvlist_alloc(&nvl, 0, 0) != 0) {
		dprintf((stderr, "nvlist_alloc fail\n"));
		return (-1);
	}

	while (devlist != NULL) {
		s_free(buf);
		if (dev_pack(devlist, &buf, &size, encoding) != 0)
			goto fail;

		if (nvlist_add_byte_array(nvl, RI_DEV_T, (uchar_t *)buf,
		    size) != 0) {
			dprintf((stderr, "nvlist_add_byte_array fail "
			    "(%s)\n", RI_DEV_T));
			goto fail;
		}
		devlist = devlist->next;
	}

	s_free(buf);
	if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
		dprintf((stderr, "nvlist_pack fail\n"));
		goto fail;
	}

	nvlist_free(nvl);
	*bufp = buf;
	*sizep = size;

	return (0);

fail:
	s_free(buf);
	nvlist_free(nvl);

	return (-1);
}

/*
 * Pack a list of ri_client_t's.
 */
static int
client_list_pack(ri_client_t *client_list, char **bufp, size_t *sizep,
    int encoding)
{
	nvlist_t	*nvl = NULL;
	char		*buf = NULL;
	size_t		size = 0;

	assert(bufp != NULL && sizep != NULL);

	*sizep = 0;
	*bufp = NULL;

	if (nvlist_alloc(&nvl, 0, 0) != 0) {
		dprintf((stderr, "nvlist_alloc fail\n"));
		return (-1);
	}

	while (client_list != NULL) {
		s_free(buf);
		if (client_pack(client_list, &buf, &size, encoding) != 0)
			goto fail;

		if (nvlist_add_byte_array(nvl, RI_CLIENT_T, (uchar_t *)buf,
		    size) != 0) {
			dprintf((stderr, "nvlist_add_byte_array fail "
			    "(%s)\n", RI_CLIENT_T));
			goto fail;
		}
		client_list = client_list->next;
	}

	s_free(buf);
	if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
		dprintf((stderr, "nvlist_pack fail\n"));
		goto fail;
	}

	nvlist_free(nvl);
	*bufp = buf;
	*sizep = size;

	return (0);

fail:
	s_free(buf);
	nvlist_free(nvl);

	return (-1);
}

static int
ap_pack(ri_ap_t *ap, char **bufp, size_t *sizep, int encoding)
{
	nvlist_t	*nvl = NULL;
	char		*buf = NULL;
	size_t		size = 0;

	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
		dprintf((stderr, "nvlist_alloc fail\n"));
		return (-1);
	}

	if (pack_add_byte_array(ap->conf_props, RI_AP_PROPS, nvl,
	    encoding) != 0)
		goto fail;

	if (dev_list_pack(ap->cpus, &buf, &size, encoding) != 0)
		goto fail;

	if (nvlist_add_byte_array(nvl, RI_AP_CPUS, (uchar_t *)buf,
	    size) != 0) {
		dprintf((stderr, "nvlist_add_byte_array (%s)\n", RI_AP_CPUS));
		goto fail;
	}

	s_free(buf);
	if (dev_list_pack(ap->mems, &buf, &size, encoding) != 0)
		goto fail;

	if (nvlist_add_byte_array(nvl, RI_AP_MEMS, (uchar_t *)buf,
	    size) != 0) {
		dprintf((stderr, "nvlist_add_byte_array (%s)n", RI_AP_MEMS));
		goto fail;
	}

	s_free(buf);
	if (dev_list_pack(ap->ios, &buf, &size, encoding) != 0)
		goto fail;

	if (nvlist_add_byte_array(nvl, RI_AP_IOS, (uchar_t *)buf,
	    size) != 0) {
		dprintf((stderr, "nvlist_add_byte_array (%s)n", RI_AP_IOS));
		goto fail;
	}

	s_free(buf);
	if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
		dprintf((stderr, "nvlist_pack fail\n"));
		goto fail;
	}

	nvlist_free(nvl);
	*bufp = buf;
	*sizep = size;

	return (0);

fail:
	s_free(buf);
	nvlist_free(nvl);

	return (-1);
}

static int
dev_pack(ri_dev_t *dev, char **bufp, size_t *sizep, int encoding)
{
	nvlist_t	*nvl = NULL;
	char		*buf = NULL;
	size_t		size = 0;

	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
		dprintf((stderr, "nvlist_alloc fail\n"));
		return (-1);
	}

	if (pack_add_byte_array(dev->conf_props, RI_DEV_PROPS, nvl,
	    encoding) != 0)
		goto fail;

	if (client_list_pack(dev->rcm_clients, &buf, &size, encoding) != 0)
		goto fail;

	if (nvlist_add_byte_array(nvl, RI_DEV_CLIENTS, (uchar_t *)buf,
	    size) != 0) {
		dprintf((stderr, "nvlist_add_byte_array (%s)n",
		    RI_DEV_CLIENTS));
		goto fail;
	}

	s_free(buf);
	if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
		dprintf((stderr, "nvlist_pack fail\n"));
		goto fail;
	}

	nvlist_free(nvl);
	*bufp = buf;
	*sizep = size;

	return (0);

fail:
	s_free(buf);
	nvlist_free(nvl);

	return (-1);
}

static int
client_pack(ri_client_t *client, char **bufp, size_t *sizep, int encoding)
{
	nvlist_t	*nvl = NULL;
	char		*buf = NULL;
	size_t		size = 0;

	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
		dprintf((stderr, "nvlist_alloc fail\n"));
		return (-1);
	}

	if (pack_add_byte_array(client->usg_props, RI_CLIENT_USAGE_PROPS,
	    nvl, encoding) != 0) {
		goto fail;
	}

	/*
	 * This will only be present if RI_VERBOSE was specified
	 * in the call to ri_init.
	 */
	if (client->v_props != NULL && pack_add_byte_array(client->v_props,
	    RI_CLIENT_VERB_PROPS, nvl, encoding) != 0) {
		goto fail;
	}

	if (nvlist_pack(nvl, &buf, &size, encoding, 0) != 0) {
		dprintf((stderr, "nvlist_pack fail\n"));
		goto fail;
	}

	nvlist_free(nvl);
	*bufp = buf;
	*sizep = size;

	return (0);

fail:
	s_free(buf);
	nvlist_free(nvl);

	return (-1);
}

/*
 * Pack nvlist_t and add as byte array to another nvlist_t.
 */
static int
pack_add_byte_array(nvlist_t *nvl_packme, char *name, nvlist_t *nvl,
    int encoding)
{
	char	*buf = NULL;
	size_t	size = 0;

	if (nvlist_pack(nvl_packme, &buf, &size, encoding, 0) != 0) {
		dprintf((stderr, "nvlist_pack fail (%s)\n", name));
		s_free(buf);
		return (-1);
	}

	if (nvlist_add_byte_array(nvl, name, (uchar_t *)buf, size) != 0) {
		dprintf((stderr, "nvlist_add_byte_array fail (%s)\n", name));
		return (-1);
	}

	s_free(buf);
	return (0);
}

/*
 * Unpack buf into ri_hdl_t.
 */
int
ri_unpack(caddr_t buf, size_t size, ri_hdl_t **hdlp)
{
	ri_hdl_t	*ri_hdl = NULL;
	nvlist_t	*nvl = NULL;

	if (hdlp == NULL)
		return (RI_INVAL);

	*hdlp = NULL;
	if ((ri_hdl = calloc(1, sizeof (*ri_hdl))) == NULL) {
		dprintf((stderr, "calloc: %s\n", strerror(errno)));
		return (RI_FAILURE);
	}

	if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
		dprintf((stderr, "nvlist_unpack fail\n"));
		goto fail;
	}

	if (nvlist_lookup_int32(nvl, RI_HDL_FLAGS, &ri_hdl->flags) != 0) {
		dprintf((stderr, "nvlist_lookup_int32 fail (%s)\n",
		    RI_HDL_FLAGS));
		goto fail;
	}

	buf = NULL;
	size = 0;
	if (nvlist_lookup_byte_array(nvl, RI_HDL_APS, (uchar_t **)&buf,
	    (uint_t *)&size) != 0) {
		dprintf((stderr, "nvlist_lookup_int32 fail (%s)\n",
		    RI_HDL_APS));
		goto fail;
	}

	if (ap_list_unpack(buf, size, &ri_hdl->aps) != 0)
		goto fail;

	buf = NULL;
	size = 0;
	if (nvlist_lookup_byte_array(nvl, RI_HDL_CPU_CAPS, (uchar_t **)&buf,
	    (uint_t *)&size) != 0) {
		dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
		    RI_HDL_CPU_CAPS));
		goto fail;
	}

	if (client_list_unpack(buf, size, &ri_hdl->cpu_cap_clients) != 0)
		goto fail;

	buf = NULL;
	size = 0;
	if (nvlist_lookup_byte_array(nvl, RI_HDL_MEM_CAPS, (uchar_t **)&buf,
	    (uint_t *)&size) != 0) {
		dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
		    RI_HDL_MEM_CAPS));
		goto fail;
	}

	if (client_list_unpack(buf, size, &ri_hdl->mem_cap_clients) != 0)
		goto fail;

	*hdlp = ri_hdl;

	return (0);

fail:
	free(ri_hdl);
	nvlist_free(nvl);

	return (-1);
}

static int
ap_list_unpack(char *buf, size_t size, ri_ap_t **aps)
{
	nvpair_t	*nvp = NULL;
	nvlist_t	*nvl;
	ri_ap_t		*aplist = NULL;
	ri_ap_t		*prev = NULL;
	ri_ap_t		*tmp = NULL;

	if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
		dprintf((stderr, "nvlist_unpack fail\n"));
		return (-1);
	}

	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
		assert(strcmp(nvpair_name(nvp), RI_AP_T) == 0 &&
		    nvpair_type(nvp) == DATA_TYPE_BYTE_ARRAY);

		if ((tmp = calloc(1, sizeof (*tmp))) == NULL) {
			dprintf((stderr, "calloc: %s\n", strerror(errno)));
			goto fail;
		}

		buf = NULL;
		size = 0;
		if (nvpair_value_byte_array(nvp, (uchar_t **)&buf,
		    (uint_t *)&size) != 0) {
			dprintf((stderr, "nvpair_value_byte_array fail\n"));
			goto fail;
		}

		if (ap_unpack(buf, size, tmp) != 0)
			goto fail;

		if (aplist == NULL) {
			prev = aplist = tmp;
		} else {
			prev->next = tmp;
			prev = tmp;
		}
	}

	nvlist_free(nvl);
	*aps = aplist;

	return (0);

fail:
	nvlist_free(nvl);
	if (aplist != NULL) {
		while ((tmp = aplist) != NULL) {
			aplist = aplist->next;
			ri_ap_free(tmp);
		}
	}

	return (-1);
}

static int
dev_list_unpack(char *buf, size_t size, ri_dev_t **devs)
{
	nvpair_t	*nvp = NULL;
	nvlist_t	*nvl;
	ri_dev_t	*devlist = NULL;
	ri_dev_t	*prev = NULL;
	ri_dev_t	*tmp = NULL;

	if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
		dprintf((stderr, "nvlist_unpack fail\n"));
		return (-1);
	}

	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
		assert(strcmp(nvpair_name(nvp), RI_DEV_T) == 0 &&
		    nvpair_type(nvp) == DATA_TYPE_BYTE_ARRAY);

		if ((tmp = calloc(1, sizeof (*tmp))) == NULL) {
			dprintf((stderr, "calloc: %s\n", strerror(errno)));
			goto fail;
		}

		if (nvpair_value_byte_array(nvp, (uchar_t **)&buf,
		    (uint_t *)&size) != 0) {
			dprintf((stderr, "nvpair_value_byte_array fail\n"));
			goto fail;
		}

		if (dev_unpack(buf, size, tmp) != 0)
			goto fail;

		if (devlist == NULL) {
			prev = devlist = tmp;
		} else {
			prev->next = tmp;
			prev = tmp;
		}
	}

	nvlist_free(nvl);
	*devs = devlist;

	return (0);

fail:
	nvlist_free(nvl);
	if (devlist != NULL) {
		while ((tmp = devlist) != NULL) {
			devlist = devlist->next;
			ri_dev_free(tmp);
		}
	}

	return (-1);
}

static int
client_list_unpack(char *buf, size_t size, ri_client_t **clients)
{
	nvpair_t	*nvp = NULL;
	nvlist_t	*nvl;
	ri_client_t	*client_list = NULL;
	ri_client_t	*prev = NULL;
	ri_client_t	*tmp = NULL;

	if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
		dprintf((stderr, "nvlist_unpack fail\n"));
		return (-1);
	}

	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
		assert(strcmp(nvpair_name(nvp), RI_CLIENT_T) == 0);
		assert(nvpair_type(nvp) == DATA_TYPE_BYTE_ARRAY);

		if ((tmp = calloc(1, sizeof (*tmp))) == NULL) {
			dprintf((stderr, "calloc: %s\n", strerror(errno)));
			goto fail;
		}

		buf = NULL;
		size = 0;
		if (nvpair_value_byte_array(nvp, (uchar_t **)&buf,
		    (uint_t *)&size) != 0) {
			dprintf((stderr, "nvpair_value_byte_array fail\n"));
			goto fail;
		}

		if (client_unpack(buf, size, tmp) != 0)
			goto fail;

		if (client_list == NULL) {
			prev = client_list = tmp;
		} else {
			prev->next = tmp;
			prev = tmp;
		}
	}

	nvlist_free(nvl);
	*clients = client_list;

	return (0);

fail:
	nvlist_free(nvl);
	if (client_list != NULL) {
		while ((tmp = client_list) != NULL) {
			client_list = client_list->next;
			ri_client_free(tmp);
		}
	}

	return (-1);
}

static int
client_unpack(char *buf, size_t size, ri_client_t *client)
{
	nvlist_t	*nvl;

	if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
		dprintf((stderr, "nvlist_unpack fail\n"));
		return (-1);
	}

	if (lookup_unpack_byte_array(nvl, RI_CLIENT_USAGE_PROPS,
	    &client->usg_props) != 0) {
		nvlist_free(nvl);
		return (-1);
	}

#ifdef DEBUG
	nvlist_print(stderr, client->usg_props);
#endif /* DEBUG */

	/*
	 * Verbose properties for RCM clients only present if
	 * RI_VERBOSE was specified for ri_init.
	 */
	buf = NULL;
	size = 0;
	if (nvlist_lookup_byte_array(nvl, RI_CLIENT_VERB_PROPS,
	    (uchar_t **)&buf, (uint_t *)&size) == 0) {
		if (nvlist_unpack(buf, size, &client->v_props, 0) != 0) {
			dprintf((stderr, "nvlist_unpack fail (%s)\n",
			    RI_CLIENT_VERB_PROPS));
			nvlist_free(nvl);
			return (-1);
		}
	}

	nvlist_free(nvl);

	return (0);
}

static int
dev_unpack(char *buf, size_t size, ri_dev_t *dev)
{
	nvlist_t	*nvl;

	if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
		dprintf((stderr, "nvlist_unpack fail\n"));
		return (-1);
	}

	if (lookup_unpack_byte_array(nvl, RI_DEV_PROPS,
	    &dev->conf_props) != 0) {
		nvlist_free(nvl);
		return (-1);
	}

#ifdef DEBUG
	nvlist_print(stderr, dev->conf_props);
#endif /* DEBUG */

	if (nvlist_lookup_byte_array(nvl, RI_DEV_CLIENTS, (uchar_t **)&buf,
	    (uint_t *)&size) != 0) {
		dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
		    RI_DEV_CLIENTS));
		nvlist_free(nvl);
		return (-1);
	}

	if (client_list_unpack(buf, size, &dev->rcm_clients) != 0) {
		nvlist_free(nvl);
		return (-1);
	}

	nvlist_free(nvl);

	return (0);
}

static int
ap_unpack(char *buf, size_t size, ri_ap_t *ap)
{
	nvlist_t	*nvl;

	if (nvlist_unpack(buf, size, &nvl, 0) != 0) {
		dprintf((stderr, "nvlist_unpack fail\n"));
		return (-1);
	}

	if (lookup_unpack_byte_array(nvl, RI_AP_PROPS, &ap->conf_props) != 0) {
		nvlist_free(nvl);
		return (-1);
	}

#ifdef DEBUG
	nvlist_print(stderr, ap->conf_props);
#endif /* DEBUG */

	if (nvlist_lookup_byte_array(nvl, RI_AP_CPUS, (uchar_t **)&buf,
	    (uint_t *)&size) != 0) {
		dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
		    RI_AP_CPUS));
		nvlist_free(nvl);
		return (-1);
	}

	if (dev_list_unpack(buf, size, &ap->cpus) != 0) {
		nvlist_free(nvl);
		return (-1);
	}

	if (nvlist_lookup_byte_array(nvl, RI_AP_MEMS, (uchar_t **)&buf,
	    (uint_t *)&size) != 0) {
		dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
		    RI_AP_MEMS));
		nvlist_free(nvl);
		return (-1);
	}

	if (dev_list_unpack(buf, size, &ap->mems) != 0) {
		nvlist_free(nvl);
		return (-1);
	}

	if (nvlist_lookup_byte_array(nvl, RI_AP_IOS, (uchar_t **)&buf,
	    (uint_t *)&size) != 0) {
		dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
		    RI_AP_IOS));
		nvlist_free(nvl);
		return (-1);
	}

	if (dev_list_unpack(buf, size, &ap->ios) != 0) {
		nvlist_free(nvl);
		return (-1);
	}

	nvlist_free(nvl);

	return (0);
}

/*
 * Lookup byte array in old nvlist_t and unpack into new nvlist_t.
 */
static int
lookup_unpack_byte_array(nvlist_t *old_nvl, char *name, nvlist_t **new_nvl)
{
	char	*buf = NULL;
	size_t	size = 0;

	if (nvlist_lookup_byte_array(old_nvl, name, (uchar_t **)&buf,
	    (uint_t *)&size) != 0) {
		dprintf((stderr, "nvlist_lookup_byte_array fail (%s)\n",
		    name));
		return (-1);
	}

	if (nvlist_unpack(buf, size, new_nvl, 0) != 0) {
		dprintf((stderr, "nvlist_unpack fail (%s)\n", name));
		return (-1);
	}

	return (0);
}

ri_ap_t *
ri_ap_next(ri_hdl_t *hdl, ri_ap_t *ap)
{
	if (hdl == NULL) {
		errno = EINVAL;
		return (NULL);
	}
	return ((ap == NULL) ? hdl->aps : ap->next);
}

nvlist_t *
ri_ap_conf_props(ri_ap_t *ap)
{
	if (ap == NULL) {
		errno = EINVAL;
		return (NULL);
	}
	return (ap->conf_props);
}

ri_dev_t *
ri_cpu_next(ri_ap_t *ap, ri_dev_t *cpu)
{
	if (ap == NULL) {
		errno = EINVAL;
		return (NULL);
	}
	return ((cpu == NULL) ? ap->cpus : cpu->next);
}

ri_dev_t *
ri_mem_next(ri_ap_t *ap, ri_dev_t *mem)
{
	if (ap == NULL) {
		errno = EINVAL;
		return (NULL);
	}
	return ((mem == NULL) ? ap->mems : mem->next);
}

ri_dev_t *
ri_io_next(ri_ap_t *ap, ri_dev_t *io)
{
	if (ap == NULL) {
		errno = EINVAL;
		return (NULL);
	}
	return ((io == NULL) ? ap->ios : io->next);
}

ri_client_t *
ri_client_next(ri_dev_t *dev, ri_client_t *rcm_client)
{
	if (dev == NULL) {
		errno = EINVAL;
		return (NULL);
	}
	return ((rcm_client == NULL) ? dev->rcm_clients : rcm_client->next);
}

nvlist_t *
ri_dev_conf_props(ri_dev_t *dev)
{
	if (dev == NULL) {
		errno = EINVAL;
		return (NULL);
	}
	return (dev->conf_props);
}

nvlist_t *
ri_client_usage_props(ri_client_t *rcm_client)
{
	if (rcm_client == NULL) {
		errno = EINVAL;
		return (NULL);
	}
	return (rcm_client->usg_props);
}

nvlist_t *
ri_client_verbose_props(ri_client_t *rcm_client)
{
	if (rcm_client == NULL) {
		errno = EINVAL;
		return (NULL);
	}
	return (rcm_client->v_props);
}

ri_client_t *
ri_cpu_cap_client_next(ri_hdl_t *hdl, ri_client_t *rcm_client)
{
	if (hdl == NULL) {
		errno = EINVAL;
		return (NULL);
	}
	return ((rcm_client == NULL) ? hdl->cpu_cap_clients : rcm_client->next);
}

ri_client_t *
ri_mem_cap_client_next(ri_hdl_t *hdl, ri_client_t *rcm_client)
{
	if (hdl == NULL) {
		errno = EINVAL;
		return (NULL);
	}
	return ((rcm_client == NULL) ? hdl->mem_cap_clients : rcm_client->next);
}