path: root/usr/src/lib/libpicl/picl.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

/*
 * This module implements the PICL Interface used by PICL clients
 * to access services of the PICL daemon
 *
 * Locking Strategy
 * A single reader/writer lock (icl_lock) protects the access to the interface
 * to the picl daemon, and the reference count, refcnt, variable.
 * A reader lock is obtained to send a request to the daemon.
 * A writer lock is obtained to initialize, reinitialize, or shutdown
 * the interface.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <alloca.h>
#include <fcntl.h>
#include <libintl.h>
#include <errno.h>
#include <sys/mman.h>
#include <door.h>
#include <sys/door.h>
#include <sys/time.h>
#include <assert.h>
#include <synch.h>
#include <limits.h>
#include <picl.h>
#include "picl2door.h"

/*
 * Module variables
 */
static	int		door_handle = -1;
static	uint32_t	refcnt = 0;
static	rwlock_t	picl_lock = DEFAULTRWLOCK;

static	char 		*picl_errmsg[] = {
	"No error",
	"General system failure",
	"Daemon not responding",
	"Unknown PICL service",
	"Session not initialized",
	"Invalid arguments",
	"Argument too big",
	"Property not found",
	"Not a table property handle",
	"Not a node handle",
	"Not a property handle",
	"End of property list",
	"Property already exists",
	"Property not writable",
	"Insufficient permissions",
	"Invalid handle",
	"Stale handle",
	"Unsupported version",
	"Wait timed out",
	"Attempting to destroy before delete",
	"PICL Tree is busy",
	"Already has a parent",
	"Property name is reserved",
	"Invalid reference value",
	"Continue tree walk",
	"Terminate tree walk",
	"Node not found",
	"Not enough space available",
	"Property not readable",
	"Property value unavailable"
};

#define	N_ERRORS 		(sizeof (picl_errmsg)/sizeof (picl_errmsg[0]))
#define	SEND_REQ_TRYCOUNT	1

/*
 * This function sends the client request to the daemon using a door call.
 * If door_handle is -1, it returns PICL_NOTINITIALIZED.
 * If the door_call fails, it returns PICL_NORESPONSE. Otherwise, it
 * checks the response from the daemon for error. If an error is returned
 * this function returns the error code returned and unmaps any
 * memory mapped by the door call. For successful results, the caller is
 * responsible to unmap the mapped memory after retrieving the results.
 *
 * This function does not attempt to reinitialize the interface if the
 * initial door_call fails. It is called from handshake() , shutdown()
 * and trysend_req() routines.
 */
static int
post_req(door_arg_t *dargp, void *data_ptr, size_t data_size,
    door_desc_t *desc_ptr, uint_t desc_num, void *rbuf, size_t rsize)
{
	int		err;
	picl_service_t	*ret;
	int		req_cnum;

	req_cnum = ((picl_service_t *)data_ptr)->in.cnum;
	dargp->data_ptr = data_ptr;
	dargp->data_size = data_size;
	dargp->desc_ptr = desc_ptr;
	dargp->desc_num = desc_num;
	dargp->rbuf = rbuf;
	dargp->rsize = rsize;

	if (door_call(door_handle, dargp) < 0)
		return (PICL_NORESPONSE);

	/*LINTED*/
	ret = (picl_service_t *)dargp->rbuf;
	if (ret->in.cnum == req_cnum)
		return (PICL_SUCCESS);
	else if ((ret->in.cnum == PICL_CNUM_ERROR) &&
	    (ret->ret_error.in_cnum == req_cnum))
		err = ret->ret_error.errnum;
	else
	    err = PICL_UNKNOWNSERVICE;
	if (dargp->rbuf != rbuf)
		(void) munmap(dargp->rbuf, dargp->rsize);
	return (err);
}

/*
 * This function posts an INIT message to the daemon to
 * verify communication channel.
 */
static int
handshake(void)
{
	int		err;
	door_arg_t	darg;
	picl_reqinit_t	req;
	picl_retinit_t	outargs;

	req.cnum = PICL_CNUM_INIT;
	req.clrev = PICL_VERSION_1;

	if ((err = post_req(&darg, &req, sizeof (picl_reqinit_t), NULL,
	    0, &outargs, sizeof (picl_retinit_t))) != PICL_SUCCESS)
		return (err);

	if (darg.rbuf != (char *)&outargs)
		(void) munmap(darg.rbuf, darg.rsize);
	return (PICL_SUCCESS);
}

/*
 * This function calls post_req() to make door_call and reinitializes
 * the interface is post_req() fails.
 */
static int
trysend_req(door_arg_t *dargp, void *data_ptr, size_t data_size,
    door_desc_t *desc_ptr, uint_t desc_num, void *rbuf, size_t rsize,
	unsigned int trycount)
{
	int	err;
	int	write_locked;

	write_locked = 0;
	(void) rw_rdlock(&picl_lock);
	if (refcnt == 0) {
		(void) rw_unlock(&picl_lock);	/* read unlock */
		return (PICL_NOTINITIALIZED);
	}

	while ((err = post_req(dargp, data_ptr, data_size, desc_ptr, desc_num,
	    rbuf, rsize)) == PICL_NORESPONSE) {
		if (trycount == 0)	/* no more retry */
			break;

		if (write_locked == 1) {	/* close and open door */
			(void) close(door_handle);
			if ((door_handle = open(PICLD_DOOR, O_RDONLY)) < 0) {
				err = PICL_NORESPONSE;
				break;
			}
			--trycount;
			continue;
		}
		/*
		 * Upgrade read to a write lock
		 */
		(void) rw_unlock(&picl_lock);
		(void) rw_wrlock(&picl_lock);

		/*
		 * if picl_shutdown happens during lock upgrade
		 */
		if (refcnt == 0) {
			err =  PICL_NOTINITIALIZED;
			break;
		}
		write_locked = 1;
		continue;
	}
	(void) rw_unlock(&picl_lock);	/* read or write unlock */
	return (err);
}

/*
 * Initialize the PICL interface
 * Increment the reference count.
 */
int
picl_initialize(void)
{
	int	err;

	(void) rw_wrlock(&picl_lock);
	if (refcnt > 0) {		/* previously initialized */
		err = handshake();
		if (err == PICL_SUCCESS) {
			++refcnt;
			(void) rw_unlock(&picl_lock);	/* write unlock */
			return (err);
		}
		if (err != PICL_NORESPONSE) {
			(void) rw_unlock(&picl_lock);	/* write unlock */
			return (err);
		}
		(void) close(door_handle);	/* close bad door */
	}

	/*
	 * Open picld door and initialize door_handle
	 */
	if ((door_handle = open(PICLD_DOOR, O_RDONLY)) < 0) {
		(void) rw_unlock(&picl_lock); /* write unlock */
		return (PICL_NORESPONSE);
	}

	err = handshake();
	if (err != PICL_SUCCESS)
		(void) close(door_handle);
	else
		++refcnt;
	(void) rw_unlock(&picl_lock);	/* write unlock */
	return (err);
}

/*
 * Shutdown the PICL interface
 * Decrement the reference count and close the door_handle if refcnt is zero
 */
int
picl_shutdown(void)
{
	int		err;
	door_arg_t	darg;
	picl_reqfini_t	req_fini;
	picl_retfini_t	outargs;

	(void) rw_wrlock(&picl_lock);	/* write lock */
	if (refcnt == 0) {
		(void) rw_unlock(&picl_lock);	/* write unlock */
		return (PICL_NOTINITIALIZED);
	}
	req_fini.cnum = PICL_CNUM_FINI;
	err = post_req(&darg, &req_fini, sizeof (picl_reqfini_t),
	    NULL, 0, &outargs, sizeof (picl_retfini_t));
	--refcnt;
	if (refcnt == 0)
		(void) close(door_handle);
	(void) rw_unlock(&picl_lock);	/* write unlock */
	if (err != PICL_SUCCESS)
		return (err);
	if (darg.rbuf != (char *)&outargs)
		(void) munmap(darg.rbuf, darg.rsize);
	return (PICL_SUCCESS);
}

/*
 * This function waits for the specified number of seconds for a PICL
 * tree refresh.
 */
int
picl_wait(unsigned int secs)
{
	door_arg_t	darg;
	picl_reqwait_t	req_wait;
	picl_retwait_t	outargs;
	picl_service_t	*ret;
	int		err;

	req_wait.cnum = PICL_CNUM_WAIT;
	req_wait.secs = secs;
	err = trysend_req(&darg, &req_wait, sizeof (picl_reqwait_t),
	    NULL, 0, &outargs, sizeof (picl_retwait_t), SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);

	/*LINTED*/
	ret = (picl_service_t *)darg.rbuf;
	err = ret->ret_wait.retcode;
	if (darg.rbuf != (char *)&outargs)
		(void) munmap(darg.rbuf, darg.rsize);
	return (err);
}

/*
 * This function copies the handle of the root node of the PICL tree into
 * the buffer <rooth>
 */
int
picl_get_root(picl_nodehdl_t *rooth)
{
	door_arg_t	darg;
	picl_reqroot_t	req_root;
	picl_retroot_t	outargs;
	picl_service_t	*ret;
	int	err;

	req_root.cnum = PICL_CNUM_GETROOT;
	err = trysend_req(&darg, &req_root, sizeof (picl_reqroot_t), NULL,
	    0, &outargs, sizeof (picl_retroot_t), SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);
	/*LINTED*/
	ret = (picl_service_t *)darg.rbuf;
	*rooth = ret->ret_root.rnode;
	if (darg.rbuf != (char *)&outargs)
		(void) munmap(darg.rbuf, darg.rsize);
	return (PICL_SUCCESS);
}

/*
 * This function copies the value of the property specified by its handle
 * into the buffer <valbuf>.
 */
int
picl_get_propval(picl_prophdl_t proph, void *valbuf, size_t nbytes)
{
	door_arg_t		darg;
	picl_reqattrval_t	req_attrval;
	picl_service_t		*ret;
	picl_retattrval_t	*outargs;
	int			err;

	req_attrval.cnum = PICL_CNUM_GETATTRVAL;
	req_attrval.attr = proph;
	req_attrval.bufsize = (uint32_t)nbytes;
	if ((size_t)req_attrval.bufsize != nbytes)
		return (PICL_VALUETOOBIG);
	outargs = alloca(sizeof (picl_retattrval_t) + nbytes);

	err = trysend_req(&darg, &req_attrval, sizeof (picl_reqattrval_t),
	    NULL, 0, outargs, sizeof (picl_retattrval_t) + nbytes,
	    SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);

	/*LINTED*/
	ret = (picl_service_t *)darg.rbuf;
	if (ret->ret_attrval.nbytes > (uint32_t)nbytes)
		err = PICL_VALUETOOBIG;
	else
		(void) memcpy(valbuf, ret->ret_attrval.ret_buf,
		    (size_t)ret->ret_attrval.nbytes);
	if (darg.rbuf != (char *)outargs)
		(void) munmap(darg.rbuf, darg.rsize);
	return (err);
}

/*
 * This function copies the value of the property specified by its
 * name into the buffer <valbuf>
 */
int
picl_get_propval_by_name(picl_nodehdl_t nodeh, const char *propname,
    void *valbuf, size_t nbytes)
{
	door_arg_t		darg;
	picl_reqattrvalbyname_t	req_attrvalbyname;
	picl_service_t		*ret;
	picl_retattrvalbyname_t	*outargs;
	int			err;

	req_attrvalbyname.cnum = PICL_CNUM_GETATTRVALBYNAME;
	req_attrvalbyname.nodeh = nodeh;
	(void) strcpy(req_attrvalbyname.propname, propname);
	req_attrvalbyname.bufsize = (uint32_t)nbytes;
	if ((size_t)req_attrvalbyname.bufsize != nbytes)
		return (PICL_VALUETOOBIG);
	outargs = alloca(sizeof (picl_retattrvalbyname_t) + nbytes);

	err = trysend_req(&darg, &req_attrvalbyname,
	    sizeof (picl_reqattrvalbyname_t), NULL, 0, outargs,
	    sizeof (picl_retattrvalbyname_t) + nbytes, SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);

	/*LINTED*/
	ret = (picl_service_t *)darg.rbuf;
	if (ret->ret_attrvalbyname.nbytes > (uint32_t)nbytes)
		err = PICL_VALUETOOBIG;
	else
		(void) memcpy(valbuf, ret->ret_attrvalbyname.ret_buf,
		    (size_t)ret->ret_attrvalbyname.nbytes);
	if (darg.rbuf != (char *)outargs)
		(void) munmap(darg.rbuf, darg.rsize);
	return (err);
}

/*
 * This function sets the value of the property specified by its
 * handle with the value specified in <valbuf>.
 */
int
picl_set_propval(picl_prophdl_t proph, void *valbuf, size_t nbytes)
{
	door_arg_t		darg;
	picl_reqsetattrval_t	ret_setattrval;
	picl_reqsetattrval_t	*inargs;
	int			err;

	if (nbytes >= (size_t)PICL_PROPSIZE_MAX)
		return (PICL_VALUETOOBIG);

	inargs = alloca(sizeof (picl_reqsetattrval_t) + nbytes);
	inargs->cnum = PICL_CNUM_SETATTRVAL;
	inargs->attr = proph;
	inargs->bufsize = (uint32_t)nbytes;
	if ((size_t)inargs->bufsize != nbytes)
		return (PICL_VALUETOOBIG);
	(void) memcpy(inargs->valbuf, valbuf, nbytes);

	err = trysend_req(&darg, inargs, sizeof (picl_reqsetattrval_t) +
	    nbytes, NULL, 0, &ret_setattrval,
	    sizeof (picl_retsetattrval_t), SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);

	if (darg.rbuf != (char *)&ret_setattrval)
		(void) munmap(darg.rbuf, darg.rsize);
	return (PICL_SUCCESS);
}

/*
 * This function sets the value of the property specified by its
 * name with the value given in <valbuf>
 */
int
picl_set_propval_by_name(picl_nodehdl_t nodeh, const char *propname,
    void *valbuf, size_t nbytes)
{
	door_arg_t			darg;
	picl_retsetattrvalbyname_t	ret_setattrvalbyname;
	picl_reqsetattrvalbyname_t	*inargs;
	int				err;

	if (nbytes >= (size_t)PICL_PROPSIZE_MAX)
		return (PICL_VALUETOOBIG);

	inargs = alloca(sizeof (picl_reqsetattrvalbyname_t) + nbytes);
	inargs->cnum = PICL_CNUM_SETATTRVALBYNAME;
	inargs->nodeh = nodeh;
	(void) strcpy(inargs->propname, propname);
	inargs->bufsize = (uint32_t)nbytes;
	if ((size_t)inargs->bufsize != nbytes)
		return (PICL_VALUETOOBIG);
	(void) memcpy(inargs->valbuf, valbuf, nbytes);

	err = trysend_req(&darg, inargs,
	    sizeof (picl_reqsetattrvalbyname_t) + nbytes, NULL, 0,
	    &ret_setattrvalbyname, sizeof (picl_retsetattrvalbyname_t),
	    SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);

	if (darg.rbuf != (char *)&ret_setattrvalbyname)
		(void) munmap(darg.rbuf, darg.rsize);
	return (PICL_SUCCESS);
}

/*
 * This function copies the information of the specified property
 * into <pinfo>
 */
int
picl_get_propinfo(picl_prophdl_t proph, picl_propinfo_t *pinfo)
{
	door_arg_t		darg;
	picl_reqattrinfo_t	req_attrinfo;
	picl_service_t		*ret;
	picl_retattrinfo_t	outargs;
	int			err;

	req_attrinfo.cnum = PICL_CNUM_GETATTRINFO;
	req_attrinfo.attr = proph;

	err = trysend_req(&darg, &req_attrinfo,
	    sizeof (picl_reqattrinfo_t), NULL, 0, &outargs,
	    sizeof (picl_retattrinfo_t), SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);

	/*LINTED*/
	ret = (picl_service_t *)darg.rbuf;
	pinfo->type = ret->ret_attrinfo.type;
	pinfo->accessmode = ret->ret_attrinfo.accessmode;
	pinfo->size = (size_t)ret->ret_attrinfo.size;
	(void) strcpy(pinfo->name, ret->ret_attrinfo.name);
	if (darg.rbuf != (char *)&outargs)
		(void) munmap(darg.rbuf, darg.rsize);
	return (PICL_SUCCESS);
}

/*
 * This function copies the handle of the first property of a node into
 * <proph>
 */
int
picl_get_first_prop(picl_nodehdl_t nodeh, picl_prophdl_t *proph)
{
	door_arg_t		darg;
	picl_reqfirstattr_t	req_firstattr;
	picl_service_t		*ret;
	picl_retfirstattr_t	outargs;
	int			err;

	req_firstattr.cnum = PICL_CNUM_GETFIRSTATTR;
	req_firstattr.nodeh = nodeh;

	err = trysend_req(&darg, &req_firstattr,
	    sizeof (picl_reqfirstattr_t), NULL, 0, &outargs,
	    sizeof (picl_retfirstattr_t), SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);

	/*LINTED*/
	ret = (picl_service_t *)darg.rbuf;
	*proph = ret->ret_firstattr.attr;
	if (darg.rbuf != (char *)&outargs)
		(void) munmap(darg.rbuf, darg.rsize);
	return (PICL_SUCCESS);
}

/*
 * This function copies the handle of the next property in list
 * into <nextprop>.
 */
int
picl_get_next_prop(picl_prophdl_t proph, picl_prophdl_t *nextprop)
{
	door_arg_t		darg;
	picl_reqnextattr_t	req_nextattr;
	picl_service_t		*ret;
	picl_retnextattr_t	outargs;
	int			err;


	req_nextattr.cnum = PICL_CNUM_GETNEXTATTR;
	req_nextattr.attr = proph;

	err = trysend_req(&darg, &req_nextattr,
	    sizeof (picl_reqnextattr_t), NULL, 0,  &outargs,
	    sizeof (picl_retnextattr_t), SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);

	/*LINTED*/
	ret = (picl_service_t *)darg.rbuf;
	*nextprop = ret->ret_nextattr.nextattr;
	if (darg.rbuf != (char *)&outargs)
		(void) munmap(darg.rbuf, darg.rsize);
	return (PICL_SUCCESS);
}

/*
 * This function copies the handle of the property specified by its
 * name into <proph>.
 */
int
picl_get_prop_by_name(picl_nodehdl_t nodeh, const char *name,
    picl_prophdl_t *proph)
{
	door_arg_t		darg;
	picl_reqattrbyname_t	req_attrbyname;
	picl_service_t		*ret;
	picl_retattrbyname_t	outargs;
	int			err;

	req_attrbyname.cnum = PICL_CNUM_GETATTRBYNAME;
	req_attrbyname.nodeh = nodeh;
	(void) strcpy(req_attrbyname.propname, name);

	err = trysend_req(&darg, &req_attrbyname,
	    sizeof (picl_reqattrbyname_t), NULL, 0, &outargs,
	    sizeof (picl_retattrbyname_t), SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);

	/*LINTED*/
	ret = (picl_service_t *)darg.rbuf;
	*proph = ret->ret_attrbyname.attr;
	if (darg.rbuf != (char *)&outargs)
		(void) munmap(darg.rbuf, darg.rsize);
	return (PICL_SUCCESS);
}

/*
 * This function copies the handle of the next property on the same
 * row of the table into <rowproph>.
 * When proph is the table handle, the handle of the property that is
 * in first row and first column is copied.
 */
int
picl_get_next_by_row(picl_prophdl_t proph, picl_prophdl_t *rowproph)
{
	door_arg_t		darg;
	picl_reqattrbyrow_t	req_attrbyrow;
	picl_service_t		*ret;
	picl_retattrbyrow_t	outargs;
	int			err;

	req_attrbyrow.cnum = PICL_CNUM_GETATTRBYROW;
	req_attrbyrow.attr = proph;

	err = trysend_req(&darg, &req_attrbyrow,
	    sizeof (picl_reqattrbyrow_t), NULL, 0, &outargs,
	    sizeof (picl_retattrbyrow_t), SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);

	/*LINTED*/
	ret = (picl_service_t *)darg.rbuf;
	*rowproph = ret->ret_attrbyrow.rowattr;
	if (darg.rbuf != (char *)&outargs)
		(void) munmap(darg.rbuf, darg.rsize);
	return (PICL_SUCCESS);
}

/*
 * This function copies the handle of the next property on the same
 * column of the table into <colproph>.
 * When proph is the table handle, the handle of the property that is
 * in the first row and first column is copied.
 */
int
picl_get_next_by_col(picl_prophdl_t proph, picl_prophdl_t *colproph)
{
	door_arg_t		darg;
	picl_reqattrbycol_t	req_attrbycol;
	picl_service_t		*ret;
	picl_retattrbycol_t	outargs;
	int			err;

	req_attrbycol.cnum = PICL_CNUM_GETATTRBYCOL;
	req_attrbycol.attr = proph;

	err = trysend_req(&darg, (char *)&req_attrbycol,
	    sizeof (picl_reqattrbycol_t), NULL, 0, (char *)&outargs,
	    sizeof (picl_retattrbycol_t), SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);

	/*LINTED*/
	ret = (picl_service_t *)darg.rbuf;
	*colproph = ret->ret_attrbycol.colattr;
	if (darg.rbuf != (char *)&outargs)
		(void) munmap(darg.rbuf, darg.rsize);
	return (PICL_SUCCESS);
}

/*
 * This function returns the picl error messages corresponding to the
 * error number.
 */
char *
picl_strerror(int err)
{
	if ((err < N_ERRORS) && (err >= 0)) {
		return (gettext(picl_errmsg[err]));
	}
	return ((char *)NULL);
}

/*
 * recursively visit all nodes
 */
static int
do_walk(picl_nodehdl_t rooth, const char *classname,
    void *c_args, int (*callback_fn)(picl_nodehdl_t hdl, void *args))
{
	int		err;
	picl_nodehdl_t	chdh;
	char		classval[PICL_CLASSNAMELEN_MAX];

	err = picl_get_propval_by_name(rooth, PICL_PROP_CHILD, &chdh,
	    sizeof (chdh));
	while (err == PICL_SUCCESS) {
		err = picl_get_propval_by_name(chdh, PICL_PROP_CLASSNAME,
		    classval, sizeof (classval));
		if (err != PICL_SUCCESS)
			return (err);

		if ((classname == NULL) || (strcmp(classname, classval) == 0)) {
			err = callback_fn(chdh, c_args);
			if (err != PICL_WALK_CONTINUE)
				return (err);
		}

		if ((err = do_walk(chdh, classname, c_args, callback_fn)) !=
		    PICL_WALK_CONTINUE)
			return (err);

		err = picl_get_propval_by_name(chdh, PICL_PROP_PEER, &chdh,
		    sizeof (chdh));
	}
	if (err == PICL_PROPNOTFOUND)	/* end of a branch */
		return (PICL_WALK_CONTINUE);
	return (err);

}

/*
 * This function walks the tree by class and invokes the callback
 * function on class name matches.
 */
int
picl_walk_tree_by_class(picl_nodehdl_t rooth, const char *classname,
    void *c_args, int (*callback_fn)(picl_nodehdl_t hdl, void *args))
{
	int		err;

	if (callback_fn == NULL)
		return (PICL_INVALIDARG);
	err = do_walk(rooth, classname, c_args, callback_fn);
	if ((err == PICL_WALK_CONTINUE) || (err == PICL_WALK_TERMINATE))
		return (PICL_SUCCESS);
	return (err);
}

/*
 * This function gets propinfo and prop handle of the named property
 */
int
picl_get_propinfo_by_name(picl_nodehdl_t nodeh, const char *prop_name,
    picl_propinfo_t *pinfo, picl_prophdl_t *proph)
{
	int		err;
	picl_prophdl_t	tmpproph;
	picl_propinfo_t	tmppinfo;

	err = picl_get_prop_by_name(nodeh, prop_name, &tmpproph);
	if (err != PICL_SUCCESS)
		return (err);

	err = picl_get_propinfo(tmpproph, &tmppinfo);
	if (err != PICL_SUCCESS)
		return (err);

	*proph = tmpproph;
	*pinfo = tmppinfo;
	return (PICL_SUCCESS);
}

int
picl_get_node_by_path(const char *piclpath, picl_nodehdl_t *nodeh)
{
	door_arg_t		darg;
	picl_reqnodebypath_t	req;
	picl_retnodebypath_t	out;
	picl_service_t		*ret;
	int	err;

	req.cnum = PICL_CNUM_NODEBYPATH;
	req.psize = PATH_MAX;
	if (strlen(piclpath) >= PATH_MAX)
		return (PICL_VALUETOOBIG);
	(void) strncpy(req.pathbuf, piclpath, PATH_MAX);

	err = trysend_req(&darg, &req, sizeof (req), NULL, 0, &out,
	    sizeof (out), SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);

	/*LINTED*/
	ret = (picl_service_t *)darg.rbuf;
	*nodeh = ret->ret_nodebypath.nodeh;
	if (darg.rbuf != (char *)&out)
		(void) munmap(darg.rbuf, darg.rsize);
	return (err);
}

int
picl_find_node(picl_nodehdl_t rooth, char *pname, picl_prop_type_t ptype,
    void *pval, size_t valsize, picl_nodehdl_t *retnodeh)
{
	door_arg_t		darg;
	picl_reqfindnode_t	*req;
	picl_service_t		*ret;
	picl_retfindnode_t	out;
	int			err;

	req = alloca(sizeof (picl_reqfindnode_t) + valsize);
	req->cnum = PICL_CNUM_FINDNODE;
	req->nodeh = rooth;
	if (strlen(pname) >= PICL_PROPNAMELEN_MAX)
		return (PICL_VALUETOOBIG);
	(void) strncpy(req->propname, pname, PICL_PROPNAMELEN_MAX);
	req->ptype = ptype;
	req->valsize = (uint32_t)valsize;
	if ((size_t)req->valsize != valsize)
		return (PICL_VALUETOOBIG);
	(void) memcpy(req->valbuf, pval, valsize);

	err = trysend_req(&darg, req, sizeof (picl_reqfindnode_t) + valsize,
	    NULL, 0, &out, sizeof (out), SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);

	/*LINTED*/
	ret = (picl_service_t *)darg.rbuf;
	*retnodeh = ret->ret_findnode.rnodeh;
	if (darg.rbuf != (char *)&out)
		(void) munmap(darg.rbuf, darg.rsize);
	return (err);
}

int
picl_get_frutree_parent(picl_nodehdl_t devh, picl_nodehdl_t *fruh)
{
	door_arg_t		darg;
	picl_reqfruparent_t	req;
	picl_retfruparent_t	out;
	picl_service_t		*ret;
	int			err;

	req.cnum = PICL_CNUM_FRUTREEPARENT;
	req.devh = devh;

	err = trysend_req(&darg, &req, sizeof (req), NULL, 0, &out,
	    sizeof (out), SEND_REQ_TRYCOUNT);
	if (err != PICL_SUCCESS)
		return (err);

	/*LINTED*/
	ret = (picl_service_t *)darg.rbuf;
	*fruh = ret->ret_fruparent.fruh;
	if (darg.rbuf != (char *)&out)
		(void) munmap(darg.rbuf, darg.rsize);
	return (err);
}