xref: /titanic_44/usr/src/cmd/nscd/nscd_config.c (revision 33f5ff17089e3a43e6e730bf80384c233123dbd9)

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

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>		/* gettext */
#include <dlfcn.h>
#include <string.h>
#include <sys/varargs.h>
#include <errno.h>
#include "nscd_db.h"
#include "nscd_config.h"
#include "nscd_cfgdef.h"
#include "nscd_log.h"

typedef struct {
	rwlock_t	*global;
	rwlock_t	*alldb;
	rwlock_t	*nswdb;
} nscd_cfg_lock_t;

static rwlock_t		cfg_paramDB_rwlock = DEFAULTRWLOCK;
static nscd_db_t	*cfg_paramDB = NULL;

static	nscd_cfg_global_data_t 	*nscd_cfg_global_current;
static	nscd_cfg_nsw_db_data_t	*nscd_cfg_nsw_db_data_current;
static	nscd_cfg_nsw_db_data_t	*nscd_cfg_nsw_alldb_current;
static	rwlock_t		*nscd_cfg_global_rwlock;
static	rwlock_t		*nscd_cfg_nsw_db_data_rwlock;
static	rwlock_t		*nscd_cfg_nsw_alldb_rwlock;

extern	int			_nscd_cfg_num_nsw_src_all;
extern	nscd_cfg_id_t		*_nscd_cfg_nsw_src_all;

nscd_cfg_error_t *
_nscd_cfg_make_error(
	nscd_rc_t	rc,
	char		*msg)
{

	nscd_cfg_error_t	*ret;
	int			size, msglen;

	msglen = (msg != NULL ? strlen(msg) + 1 : 0);

	size = sizeof (nscd_cfg_error_t) + msglen;

	ret = calloc(1, size);
	if (ret == NULL)
		return (NULL);

	ret->rc = rc;
	if (msg != NULL) {
		ret->msg = (char *)ret +
		    sizeof (nscd_cfg_error_t);
		(void) memcpy(ret->msg, msg, msglen);
	}

	return (ret);
}

static nscd_rc_t
_nscd_cfg_get_list(
	nscd_cfg_list_t		**list,
	nscd_cfg_list_type_t	type)
{
	char			*me = "_nscd_cfg_get_list";
	int			i, num, size;
	nscd_cfg_id_t		*l;
	nscd_cfg_list_t 	*ret;
	nscd_cfg_param_desc_t	*pl;
	nscd_cfg_stat_desc_t	*sl;
	void			*p;

	if (list == NULL) {
		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "invalid argument: list = %p\n", list);

		return (NSCD_INVALID_ARGUMENT);
	}
	*list = NULL;

	switch (type) {
	case NSCD_CFG_LIST_NSW_DB:

		num = _nscd_cfg_num_nsw_db;
		l = &_nscd_cfg_nsw_db[0];
		break;

	case NSCD_CFG_LIST_NSW_SRC:

		num = _nscd_cfg_num_nsw_src_all;
		l = _nscd_cfg_nsw_src_all;
		break;

	case NSCD_CFG_LIST_PARAM:

		num = _nscd_cfg_num_param;
		pl = &_nscd_cfg_param_desc[0];
		break;

	case NSCD_CFG_LIST_STAT:

		num = _nscd_cfg_num_stat;
		sl = &_nscd_cfg_stat_desc[0];
		break;

	default:
		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "invalid argument: type (%d)\n", type);

		return (NSCD_INVALID_ARGUMENT);
	}

	size =  sizeof (nscd_cfg_list_t) + sizeof (nscd_cfg_id_t *) * (num + 1);

	ret = calloc(1, size);
	if (ret == NULL)
		return (NSCD_NO_MEMORY);

	ret->num = num;
	p = (char *)ret + sizeof (nscd_cfg_list_t);
	ret->list = (nscd_cfg_id_t **)p;

	if (type == NSCD_CFG_LIST_PARAM) {
		for (i = 0; i <= num; i++)
			ret->list[i] = (nscd_cfg_id_t *)&pl[i];
	} else if (type == NSCD_CFG_LIST_STAT) {
		for (i = 0; i <= num; i++)
			ret->list[i] = (nscd_cfg_id_t *)&sl[i];
	} else {
		for (i = 0; i <= num; i++)
			ret->list[i] = &l[i];
	}

	*list = ret;

	return (NSCD_SUCCESS);
}

nscd_rc_t
_nscd_cfg_get_param_desc_list(
	nscd_cfg_param_desc_list_t **list)
{
	return (_nscd_cfg_get_list((nscd_cfg_list_t **)list,
	    NSCD_CFG_LIST_PARAM));
}

/*
 * FUNCTION: _nscd_cfg_create_paramDB
 *
 * Create the internal config parameter database
 */
static nscd_db_t *
_nscd_cfg_create_paramDB()
{

	nscd_db_t	*ret;

	(void) rw_wrlock(&cfg_paramDB_rwlock);

	ret = _nscd_alloc_db(NSCD_DB_SIZE_MEDIUM);

	if (ret != NULL)
		cfg_paramDB = ret;

	(void) rw_unlock(&cfg_paramDB_rwlock);

	return (ret);
}

/*
 * FUNCTION: _nscd_cfg_add_index_entry
 *
 * Add a config index entry (a name to index mapping)
 * to the internal configuration database.
 */
static nscd_rc_t
_nscd_cfg_add_index_entry(
	char			*name,
	int			index,
	nscd_cfg_list_type_t	type)
{
	int		*idx;
	int		size;
	int		dbe_type;
	nscd_db_entry_t	*db_entry;

	if (name == NULL)
		return (NSCD_INVALID_ARGUMENT);

	if (type == NSCD_CFG_LIST_NSW_DB)
		dbe_type = NSCD_DATA_CFG_NSW_DB_INDEX;
	else if (type == NSCD_CFG_LIST_NSW_SRC)
		dbe_type = NSCD_DATA_CFG_NSW_SRC_INDEX;
	else if (type == NSCD_CFG_LIST_PARAM)
		dbe_type = NSCD_DATA_CFG_PARAM_INDEX;
	else if (type == NSCD_CFG_LIST_STAT)
		dbe_type = NSCD_DATA_CFG_STAT_INDEX;

	size = sizeof (int);

	db_entry = _nscd_alloc_db_entry(dbe_type, (const char *)name,
	    size, 1, 1);
	if (db_entry == NULL)
		return (NSCD_NO_MEMORY);

	idx = (int *)*(db_entry->data_array);
	*idx = index;

	(void) rw_wrlock(&cfg_paramDB_rwlock);
	(void) _nscd_add_db_entry(cfg_paramDB, name, db_entry,
	    NSCD_ADD_DB_ENTRY_FIRST);
	(void) rw_unlock(&cfg_paramDB_rwlock);

	return (NSCD_SUCCESS);
}

/*
 * FUNCTION: _nscd_cfg_get_index
 *
 * Get the index of a config data item by searching the internal config
 * database. Do not free the returned data.
 */
static int
_nscd_cfg_get_index(
	char			*name,
	nscd_cfg_list_type_t	type)
{
	int			index = -1, dbe_type;
	const nscd_db_entry_t	*db_entry;

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

	if (type == NSCD_CFG_LIST_NSW_DB)
		dbe_type = NSCD_DATA_CFG_NSW_DB_INDEX;
	else if (type == NSCD_CFG_LIST_NSW_SRC)
		dbe_type = NSCD_DATA_CFG_NSW_SRC_INDEX;
	else if (type == NSCD_CFG_LIST_PARAM)
		dbe_type = NSCD_DATA_CFG_PARAM_INDEX;
	else if (type == NSCD_CFG_LIST_STAT)
		dbe_type = NSCD_DATA_CFG_STAT_INDEX;
	else
		return (-1);

	db_entry = _nscd_get_db_entry(cfg_paramDB, dbe_type,
	    (const char *)name, NSCD_GET_FIRST_DB_ENTRY, 0);

	if (db_entry != NULL)
		index = *(int *)*(db_entry->data_array);

	return (index);
}

static nscd_rc_t
_nscd_cfg_verify_group_info(
	nscd_cfg_group_info_t	*g_info,
	nscd_cfg_param_desc_t	*gdesc)
{

	char			*me = "_nscd_cfg_verify_group_info";
	void			*vp;
	nscd_cfg_group_info_t	*gi;

	if (_nscd_cfg_flag_is_set(gdesc->pflag, NSCD_CFG_PFLAG_GLOBAL)) {
		vp = (char *)&nscd_cfg_global_default +
		    gdesc->g_offset;
		gi = (nscd_cfg_group_info_t *)vp;
	} else {
		vp = (char *)&nscd_cfg_nsw_db_data_default +
		    gdesc->g_offset;
		gi = (nscd_cfg_group_info_t *)vp;

	}

	if (g_info->num_param == gi->num_param &&
	    _nscd_cfg_bitmap_is_equal(g_info->bitmap, gi->bitmap))
		return (NSCD_SUCCESS);

	_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
	(me, "ERROR: group (%s) info mismatched: group info "
	    "(%d, %#6.4x) not equal to that of default configuration data "
	    "(%d, %#6.4x)\n", gdesc->id.name, g_info->num_param,
	    _nscd_cfg_bitmap_value(g_info->bitmap), gi->num_param,
	    _nscd_cfg_bitmap_value(gi->bitmap));

	return (NSCD_CFG_PARAM_DESC_ERROR);

}


static nscd_rc_t
_nscd_cfg_init_nsw()
{
	char			*me = "_nscd_cfg_init_nsw";
	int			i, j, idx, rc, num;
	nscd_cfg_id_t		*id;
	nscd_cfg_list_type_t	type[2] = { NSCD_CFG_LIST_NSW_DB,
					NSCD_CFG_LIST_NSW_SRC };

	nscd_cfg_id_t		*list[2] = { _nscd_cfg_nsw_db, NULL};

	list[1] = _nscd_cfg_nsw_src_all;

	for (j = 0; j < 2; j++) {

		if (j == 0)
			num = _nscd_cfg_num_nsw_db + 1;
		else
			num = _nscd_cfg_num_nsw_src_all;

		for (i = 0; i < num; i++) {

			/*
			 * _nscd_cfg_nsw_alldb is the id for the
			 * special ALLDB (defaults for all db)
			 */
			if (j == 0 && i == _nscd_cfg_num_nsw_db) {
				id = &_nscd_cfg_nsw_alldb;
				idx = NSCD_CFG_NSW_ALLDB_INDEX;
			} else {
				id = &(list[j])[i];
				id->index = idx = i;
			}

			if (id->name == NULL)
				continue;

			if ((rc = _nscd_cfg_add_index_entry(id->name,
			    idx, type[j])) != NSCD_SUCCESS) {

				_NSCD_LOG(NSCD_LOG_CONFIG,
				    NSCD_LOG_LEVEL_ERROR)
				(me, "unable to add index entry for "
				"nsswitch entry %s\n", id->name);

				_nscd_free_db(cfg_paramDB);
				return (rc);
			}
		}
	}

	return (NSCD_SUCCESS);
}

static nscd_rc_t
_nscd_cfg_init_param()
{
	char			*me = "_nscd_cfg_init_param";
	int			i, gi, fn = 0;
	nscd_cfg_id_t		*id;
	nscd_cfg_param_desc_t	*desc, *gdesc = NULL;
	nscd_cfg_group_info_t	g_info;
	nscd_cfg_list_type_t	type = NSCD_CFG_LIST_PARAM;
	nscd_rc_t		rc;
	void			*nfunc, *vfunc;

	if (_nscd_cfg_create_paramDB() == NULL)
		return (NSCD_NO_MEMORY);

	desc = &_nscd_cfg_param_desc[0];

	/*
	 * need to loop to the last (+1) param description
	 * which is a fake group and which marks the end
	 * of list. It is used to signal the end of the
	 * previous group so that the proper data will be
	 * set for that group
	 */
	for (i = 0; i < _nscd_cfg_num_param + 1; i++, desc++) {

		id = (nscd_cfg_id_t *)desc;

		if (_nscd_cfg_flag_is_set(desc->pflag,
		    NSCD_CFG_PFLAG_GROUP)) {

			if (gdesc != NULL) {
				g_info.num_param = fn;
				gdesc->p_fn = fn;

				if ((rc = _nscd_cfg_verify_group_info(
				    &g_info, gdesc)) != NSCD_SUCCESS)
					return (rc);
			}

			gi = i;
			fn = 0;
			gdesc = desc;
			g_info.bitmap = NSCD_CFG_BITMAP_ZERO;

			/*
			 * set the notify/verify functions
			 */
			nfunc = (void *)gdesc->notify;
			vfunc = (void *)gdesc->verify;
		} else {
			if (i == 0) {

				_NSCD_LOG(NSCD_LOG_CONFIG,
				    NSCD_LOG_LEVEL_ERROR)
				(me, "ERROR: first parameter "
				"description is not for a group\n");

				return (NSCD_CFG_PARAM_DESC_ERROR);
			}

			/*
			 * set bitmap: the rightmost bit represents
			 * the first member (index = 0) in the group,
			 * the next bit is for the second member
			 * (index = 1), and so on
			 */
			_nscd_cfg_bitmap_set_nth(g_info.bitmap, fn);

			desc->p_fn = fn++;

			/*
			 * set the notify/verify functions
			 */
			if (desc->notify == NSCD_CFG_FUNC_NOTIFY_AS_GROUP) {
				(void) memcpy(&desc->notify, &nfunc,
				    sizeof (void *));
			}
			if (desc->verify == NSCD_CFG_FUNC_VERIFY_AS_GROUP) {
				(void) memcpy(&desc->verify, &vfunc,
				    sizeof (void *));
			}
		}

		/* if end of list reached, we are done */
		if (i == _nscd_cfg_num_param)
			break;

		desc->g_index = gi;

		id->index = i;

		if ((rc = _nscd_cfg_add_index_entry(id->name,
		    i, type)) != NSCD_SUCCESS) {

			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
			(me, "unable to add index entry for parameter "
			"%s\n", id->name);

			_nscd_free_db(cfg_paramDB);
			return (rc);
		} else {
			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
			(me, "index entry for parameter "
			"%s added\n", id->name);
		}
	}

	return (_nscd_cfg_init_nsw());
}

static nscd_rc_t
_nscd_cfg_init_stat()
{
	char			*me = "_nscd_cfg_init_stat";
	int			i, gi, fn = 0;
	nscd_cfg_id_t		*id;
	nscd_cfg_stat_desc_t	*desc, *gdesc = NULL;
	nscd_cfg_group_info_t	g_info;
	nscd_cfg_list_type_t	type = NSCD_CFG_LIST_STAT;
	nscd_rc_t		rc;
	void			*gsfunc;

	desc = &_nscd_cfg_stat_desc[0];

	/*
	 * need to loop to the last (+1) stat description
	 * which is a fake group and which marks the end
	 * of list. It is used to signal the end of the
	 * previous group so that the proper data will be
	 * set for that group
	 */
	for (i = 0; i < _nscd_cfg_num_stat + 1; i++, desc++) {

		id = (nscd_cfg_id_t *)desc;

		if (_nscd_cfg_flag_is_set(desc->sflag,
		    NSCD_CFG_SFLAG_GROUP)) {

			if (gdesc != NULL) {
				g_info.num_param = fn;
				gdesc->s_fn = fn;

				if (g_info.num_param !=
				    gdesc->gi.num_param ||
				    !_nscd_cfg_bitmap_is_equal(
				    g_info.bitmap, gdesc->gi.bitmap)) {

					_NSCD_LOG(NSCD_LOG_CONFIG,
					    NSCD_LOG_LEVEL_ERROR)
					(me, "ERROR: group (%s) "
					    "info mismatched: "
					    "group info (%d, %#6.4x) not "
					    "equal to the predefined one "
					    "(%d, %#6.4x)\n", gdesc->id.name,
					    g_info.num_param,
					    _nscd_cfg_bitmap_value(
					    g_info.bitmap),
					    gdesc->gi.num_param,
					    _nscd_cfg_bitmap_value(
					    gdesc->gi.bitmap));

					exit(1);
					return (NSCD_CFG_STAT_DESC_ERROR);
				}
			}

			gi = i;
			fn = 0;
			gdesc = desc;
			g_info.bitmap = NSCD_CFG_BITMAP_ZERO;

			/*
			 * set the get_stat function
			 */
			gsfunc = (void *)gdesc->get_stat;
		} else {
			if (i == 0) {

				_NSCD_LOG(NSCD_LOG_CONFIG,
				    NSCD_LOG_LEVEL_ERROR)
				(me, "ERROR: first stat "
				    "description is not for a group\n");

				return (NSCD_CFG_STAT_DESC_ERROR);
			}

			/*
			 * set bitmap: the rightmost bit represents
			 * the first member (index = 0) in the group,
			 * the next bit is for the second member
			 * (index = 1), and so on
			 */
			_nscd_cfg_bitmap_set_nth(g_info.bitmap, fn);

			desc->s_fn = fn++;

			/*
			 * set the get_stat function
			 */
			if (desc->get_stat == NSCD_CFG_FUNC_GET_STAT_AS_GROUP) {
				(void) memcpy(&desc->get_stat, &gsfunc,
				    sizeof (void *));
			}
		}

		/* if end of list reached, we are done */
		if (i == _nscd_cfg_num_stat)
			break;

		desc->g_index = gi;

		id->index = i;

		if ((rc = _nscd_cfg_add_index_entry(id->name,
		    i, type)) != NSCD_SUCCESS) {

			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
			(me, "unable to add index entry for stat "
			"description %s\n", id->name);

			_nscd_free_db(cfg_paramDB);
			return (rc);
		} else {
			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
			(me, "index entry for stat description "
			"%s added\n", id->name);
		}
	}

	return (NSCD_SUCCESS);
}

static nscd_rc_t
_nscd_cfg_copy_vlen_data(
	void			*data,
	void			**new_data_p,
	nscd_cfg_param_desc_t	*desc,
	int			*data_len,
	nscd_bool_t		in)
{
	int			len, dlen;
	nscd_cfg_vlen_data_t	*v = NULL;

	*new_data_p = NULL;
	*data_len = 0;

	/* it is OK if there is nothing to copy */
	if (data == NULL)
		return (NSCD_SUCCESS);

	/*
	 * if copy to the config store we need to allocate space
	 * for the extra vlen header
	 */
	if (desc->type == NSCD_CFG_DATA_STRING) {
		len = dlen = strlen((char *)data) + 1;
		if (in == nscd_true)
			len += sizeof (nscd_cfg_vlen_data_t);
	} else {
		/*
		 * should not be here, since for now
		 * only string variable length data
		 * is supported
		 */
		*new_data_p = NULL;
		return (NSCD_CFG_PARAM_DESC_ERROR);
	}

	v = calloc(1, len);
	if (v == NULL) {
		*new_data_p = NULL;
		return (NSCD_NO_MEMORY);
	}

	/*
	 * if copy to the config store, set up
	 * the extra vlen header in which the
	 * pointer to, and length of, the real
	 * data are kept. The pointer to the real
	 * data, not the vlen header, is returned.
	 */
	if (in == nscd_true) {
		v->ptr = (char *)v + sizeof (nscd_cfg_vlen_data_t);
		v->len = dlen;
		(void) memcpy(v->ptr, data, dlen);
		*new_data_p = v->ptr;
	} else {
		(void) memcpy(v, data, dlen);
		*new_data_p = v;
	}
	*data_len = dlen;

	return (NSCD_SUCCESS);
}

static void
_nscd_cfg_free_vlen_data_int(
	void	*data)
{
	nscd_cfg_vlen_data_t	*v = NULL;
	void			*p;

	if (data == NULL)
		return;

	p = (char *)data - sizeof (nscd_cfg_vlen_data_t);
	v = (nscd_cfg_vlen_data_t *)p;
	if (v->ptr == data)
		free(v);
}

static nscd_rc_t
_nscd_cfg_set_vlen_data_int(
	void		*src,
	void		*dest,
	nscd_bool_t	global)
{
	int			i, offset, dlen = 0;
	void			*s, *d, *new;
	void			*cptr;
	nscd_rc_t		rc;
	nscd_cfg_param_desc_t	*desc;

	desc = &_nscd_cfg_param_desc[0];
	for (i = 0; i < _nscd_cfg_num_param; i++, desc++) {

		if (global == nscd_true &&
		    _nscd_cfg_flag_is_not_set(desc->pflag,
		    NSCD_CFG_PFLAG_GLOBAL))
			continue;
		else if (global != nscd_true &&
		    _nscd_cfg_flag_is_set(desc->pflag,
		    NSCD_CFG_PFLAG_GLOBAL))
			continue;

		if (_nscd_cfg_flag_is_set(desc->pflag,
		    NSCD_CFG_PFLAG_VLEN_DATA)) {

			offset = desc->g_offset + desc->p_offset;

			s = (char *)src + offset;
			cptr = *(char **)s;

			rc = _nscd_cfg_copy_vlen_data(cptr, &new,
			    desc, &dlen, nscd_true);
			if (rc != NSCD_SUCCESS)
				return (rc);

			d = (char *)dest + offset;
			/* free the old vlen data */
			if (*(char **)d == NULL)
				_nscd_cfg_free_vlen_data_int(*(char **)d);

			*(char **)d = new;
		}
	}

	return (NSCD_SUCCESS);
}

static void *
_nscd_cfg_locate_vlen_data(
	void	*cfg_data,
	int	*len)
{
	void	*ptr, *ret;

	ptr = *(char **)cfg_data;
	ret = ptr;
	if (ret == NULL) {
		*len = 0;
		return (NULL);
	}
	ptr = (char *)ptr - sizeof (nscd_cfg_vlen_data_t);
	*len = ((nscd_cfg_vlen_data_t *)ptr)->len;

	return (ret);
}

static void
_nscd_cfg_lock(
	nscd_bool_t	is_read,
	nscd_cfg_lock_t	*cfglock)
{

	int	(*lockfunc)(rwlock_t *);

	if (cfglock == NULL)
		return;

	if (is_read == nscd_true)
		lockfunc = rw_rdlock;
	else
		lockfunc = rw_wrlock;

	if (cfglock->global != NULL) {

		(lockfunc)(cfglock->global);
		return;
	}

	if (cfglock->alldb != NULL)
		(lockfunc)(cfglock->alldb);

	if (cfglock->nswdb != NULL)
		(lockfunc)(cfglock->nswdb);
}

static void
_nscd_cfg_unlock(
	nscd_cfg_lock_t	*cfglock)
{
	if (cfglock == NULL)
		return;

	if (cfglock->global != NULL) {

		(void) rw_unlock(cfglock->global);
		free(cfglock);
		return;
	}

	if (cfglock->nswdb != NULL)
		(void) rw_unlock(cfglock->nswdb);

	if (cfglock->alldb != NULL)
		(void) rw_unlock(cfglock->alldb);

	free(cfglock);
}

/*
 * If vlen_data_addr is given, it will be set to the
 * address of the pointer pointing to the vlen data.
 * 'cfglock' will be set to point to the reader/writer
 * lock(s) protecting the (group) configuration data.
 */
static nscd_rc_t
_nscd_cfg_locate_cfg_data(
	void			**cfg_data,
	nscd_bool_t		is_read,
	nscd_cfg_param_desc_t	*desc,
	nscd_cfg_id_t		*nswdb,
	nscd_bool_t		get_group,
	void			**vlen_data_addr,
	int			*len,
	nscd_cfg_lock_t		**cfglock)
{
	int		offset;

	*cfg_data = NULL;
	if (len != NULL)
		*len = 0;
	if (vlen_data_addr != NULL)
		*vlen_data_addr = NULL;

	if (cfglock != NULL) {
		*cfglock = calloc(1, sizeof (nscd_cfg_lock_t));
		if (*cfglock == NULL)
			return (NSCD_NO_MEMORY);
	}

	/* assume if nswdb is NULL, the param is a global one */
	if (nswdb == NULL) {

		offset = desc->g_offset;
		if (get_group != nscd_true)
			offset += desc->p_offset;
		*cfg_data = (char *)nscd_cfg_global_current + offset;

		if (cfglock != NULL)
			(*cfglock)->global = nscd_cfg_global_rwlock;

	} else if (nswdb->index == NSCD_CFG_NSW_ALLDB_INDEX) {

		offset = desc->g_offset;
		if (get_group != nscd_true)
			offset += desc->p_offset;
		*cfg_data = (char *)nscd_cfg_nsw_alldb_current +
		    offset;

		if (cfglock != NULL)
			(*cfglock)->alldb = nscd_cfg_nsw_alldb_rwlock;

	} else {

		offset = nswdb->index *
		    (sizeof (nscd_cfg_nsw_db_data_t)) + desc->g_offset;
		if (get_group != nscd_true)
			offset += desc->p_offset;
		*cfg_data = (char *)nscd_cfg_nsw_db_data_current +
		    offset;

		if (cfglock != NULL) {
			(*cfglock)->nswdb =
			    &nscd_cfg_nsw_db_data_rwlock[nswdb->index];

			(*cfglock)->alldb = nscd_cfg_nsw_alldb_rwlock;
		}
	}

	/* lock the config data */
	if (cfglock != NULL)
		_nscd_cfg_lock(is_read, *cfglock);

	if (get_group != nscd_true &&
	    _nscd_cfg_flag_is_not_set(desc->pflag,
	    NSCD_CFG_PFLAG_GROUP) &&
	    (_nscd_cfg_flag_is_set(desc->pflag,
	    NSCD_CFG_PFLAG_VLEN_DATA))) {
		if (vlen_data_addr != NULL)
			*vlen_data_addr = *cfg_data;
		*cfg_data = _nscd_cfg_locate_vlen_data(*cfg_data, len);
		return (NSCD_SUCCESS);
	}

	if (len != NULL) {
		if (get_group == nscd_true)
			*len = desc->g_size;
		else
			*len = desc->p_size;
	}

	return (NSCD_SUCCESS);
}

/*
 * perform the preliminary (range) check on 'data' based on the
 * datatype (desc->datatype) of the config parameter
 */
nscd_rc_t
_nscd_cfg_prelim_check(
	nscd_cfg_param_desc_t	*desc,
	void			*data,
	nscd_cfg_error_t	**errorp)
{

	char			*me = "_nscd_cfg_prelim_check";
	char			msg[NSCD_CFG_MAX_ERR_MSG_LEN];
	nscd_cfg_str_check_t	*sc;
	nscd_cfg_int_check_t	*ic;
	nscd_cfg_bitmap_check_t	*bmc;
	nscd_rc_t		rc = NSCD_CFG_PRELIM_CHECK_FAILED;

	if ((nscd_cfg_str_check_t *)desc->p_check == NULL)
		return (NSCD_SUCCESS);

	switch (desc->type) {

	case NSCD_CFG_DATA_STRING:

		sc = (nscd_cfg_str_check_t *)desc->p_check;
		if (sc->must_not_null == nscd_true && data == NULL) {

			if (errorp == NULL)
				break;

			(void) snprintf(msg, sizeof (msg),
			    gettext("data must be specified for %s"),
			    desc->id.name);

			break;
		}

		if (data == NULL) {
			rc = NSCD_SUCCESS;
			break;
		}

		if (sc->maxlen != 0 &&
		    strlen((char *)data) > sc->maxlen) {

			if (errorp == NULL)
				break;

			(void) snprintf(msg, sizeof (msg),
			    gettext("length of data (%s) for %s larger "
			    "than %d"),
			    (char *)data, desc->id.name, sc->maxlen);
			break;
		}

		rc = NSCD_SUCCESS;

		break;

	case NSCD_CFG_DATA_INTEGER:

		ic = (nscd_cfg_int_check_t *)desc->p_check;
		if (*(int *)data > ic->max ||
		    *(int *)data < ic->min) {

			if (errorp == NULL)
				break;

			(void) snprintf(msg, sizeof (msg),
			    gettext("data (%d) for %s out of range "
			    "(%d - %d)"),
			    *(int *)data, desc->id.name,
			    ic->min, ic->max);

			break;
		}

		rc = NSCD_SUCCESS;

		break;

	case NSCD_CFG_DATA_BITMAP:

		bmc = (nscd_cfg_bitmap_check_t *)desc->p_check;
		if (_nscd_cfg_bitmap_value(*(nscd_cfg_bitmap_t *)data) &
		    ~(bmc->valid_bits)) {

			if (errorp == NULL)
				break;

			(void) snprintf(msg, sizeof (msg),
			    gettext("data (%#6.4x) for %s contain bit "
			    "not in 0x%x"),
			    _nscd_cfg_bitmap_value(
			    *(nscd_cfg_bitmap_t *)data),
			    desc->id.name,
			    _nscd_cfg_bitmap_value(bmc->valid_bits));
			break;
		}

		rc = NSCD_SUCCESS;

		break;
	}

	if (rc != NSCD_SUCCESS && errorp != NULL) {
		*errorp = _nscd_cfg_make_error(rc, msg);

		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
		(me, "invalid argument: %s\n", (*errorp)->msg);
	}

	return (rc);
}

static nscd_rc_t
_nscd_cfg_notify_i(
	nscd_cfg_param_desc_t	*desc,
	nscd_cfg_id_t		*nswdb,
	int			*skip,
	nscd_cfg_error_t	**errorp)
{

	char			*me = "_nscd_cfg_notify_i";
	int			i, num, skip_bk;
	void			*cfg_data, *cdata;
	void			*cookie = NULL;
	nscd_rc_t		rc;
	nscd_cfg_flag_t		dflag, dflag1;
	nscd_cfg_bitmap_t	bitmap_c, bitmap_s, *bitmap_addr;
	nscd_cfg_group_info_t	*gi;

	if (errorp != NULL)
		*errorp = NULL;

	if (skip == NULL)
		skip = &skip_bk;

	*skip = 0;

	if (_nscd_cfg_flag_is_not_set(desc->pflag,
	    NSCD_CFG_PFLAG_GROUP)) {

		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "ERROR: expect parameter description for group, "
		    "but receive parameter description is for %s\n",
		    desc->id.name);

		return (NSCD_CFG_PARAM_DESC_ERROR);
	}

	/*
	 * Set data flag going with data to be sent to the
	 * verify/notify routines. Allowing the config flag
	 * be exipandable, set the bits one by one.
	 */
	dflag = NSCD_CFG_FLAG_ZERO;
	dflag = _nscd_cfg_flag_set(dflag, NSCD_CFG_DFLAG_STATIC_DATA);
	dflag = _nscd_cfg_flag_set(dflag, NSCD_CFG_DFLAG_INIT);
	dflag = _nscd_cfg_flag_set(dflag, NSCD_CFG_DFLAG_GROUP);
	if (_nscd_cfg_flag_is_set(desc->pflag,
	    NSCD_CFG_PFLAG_INIT_SET_ALL_DB))
		dflag = _nscd_cfg_flag_set(dflag,
		    NSCD_CFG_DFLAG_SET_ALL_DB);

	/* get to the group data in the config store */
	rc = _nscd_cfg_locate_cfg_data(&cfg_data, nscd_true,
	    desc, nswdb, nscd_true, NULL, NULL, NULL);
	if (rc != NSCD_SUCCESS)
		goto error;

	/*
	 * the static bitmap associated with the group
	 * may be replaced before sending to the components,
	 * so save the bitmap for later use
	 */
	gi = _nscd_cfg_get_gi(cfg_data);
	bitmap_c = gi->bitmap;
	bitmap_addr = &(gi->bitmap);

	/*
	 * the elements in this group will all be handled
	 * so the caller can skip them
	 */
	*skip = desc->p_fn;

	if (_nscd_cfg_flag_is_set(desc->pflag,
	    NSCD_CFG_PFLAG_INIT_SEND_WHOLE_GROUP))
		/* send the entire group just once */
		num = 1;

	else { /* send individual members one by one */

		num = desc->p_fn;

		/*
		 * skip the first desc which is for the group
		 * and get to the desc for the first member
		 */
		desc++;

		dflag = _nscd_cfg_flag_unset(dflag,
		    NSCD_CFG_DFLAG_GROUP);
	}

	dflag1 = dflag;
	for (i = 0; i < num; i++, desc++) {

		dflag = dflag1;

		if (_nscd_cfg_flag_is_set(desc->pflag,
		    NSCD_CFG_PFLAG_SEND_BIT_SELECTED)) {

			/* set the bitmap to select just this member */
			bitmap_s = NSCD_CFG_BITMAP_ZERO;
			_nscd_cfg_bitmap_set_nth(bitmap_s, i);
			/* replace the bitmap in the cfg data */
			_nscd_cfg_bitmap_set(bitmap_addr, bitmap_s);

			/*
			 * send the whole group but with only one
			 * member selected
			 */
			cdata = cfg_data;

			dflag = _nscd_cfg_flag_set(dflag,
			    NSCD_CFG_DFLAG_GROUP);
			dflag = _nscd_cfg_flag_set(dflag,
			    NSCD_CFG_DFLAG_BIT_SELECTED);
		} else {
			/*
			 * send param data or group data:
			 * param data - non-xero desc->p_offset
			 * group data - zero desc->p_offset
			 */
			cdata = (char *)cfg_data + desc->p_offset;

			/*
			 * if variable length data, need to send pointer
			 * to the data (not the address of the pointer)
			 */
			if (_nscd_cfg_flag_is_set(desc->pflag,
			    NSCD_CFG_PFLAG_VLEN_DATA))
				cdata = *(char **)cdata;
		}

		if (desc->verify != NULL) {
			dflag = _nscd_cfg_flag_set(dflag,
			    NSCD_CFG_DFLAG_VERIFY);
			rc = desc->verify(cdata, desc, nswdb,
			    dflag, errorp, &cookie);
			if (rc != NSCD_SUCCESS)
				goto error;
		}

		if (desc->notify != NULL) {
			dflag = _nscd_cfg_flag_set(dflag,
			    NSCD_CFG_DFLAG_NOTIFY);

			rc = desc->notify(cfg_data, desc, nswdb,
			    dflag, errorp, cookie);
			if (rc != NSCD_SUCCESS)
				goto error;
		}
	}

	rc = NSCD_SUCCESS;

	/* restore the bitmap in the cfg data */
	_nscd_cfg_bitmap_set(bitmap_addr, bitmap_c);

	error:

	return (rc);

}

static nscd_rc_t
_nscd_cfg_notify_init(
	nscd_cfg_error_t	**errorp)
{
	int			i, j, skip;
	nscd_rc_t		rc;
	nscd_cfg_id_t		*nswdb = NULL;
	nscd_cfg_param_desc_t	*desc;

	if (errorp != NULL)
		*errorp = NULL;

	for (i = 0; i < _nscd_cfg_num_param; i++) {

		desc = &_nscd_cfg_param_desc[i];

		if (_nscd_cfg_flag_is_set(desc->pflag,
		    NSCD_CFG_PFLAG_GLOBAL)) { /* global cfg data */

			rc = _nscd_cfg_notify_i(desc, NULL, &skip, errorp);
		} else {

			/*
			 * if use defaults for all nsswitch database,
			 * send the config data to verify/notify once
			 */
			if (_nscd_cfg_flag_is_set(desc->pflag,
			    NSCD_CFG_PFLAG_INIT_SET_ALL_DB)) {

				nswdb = &_nscd_cfg_nsw_alldb;

				rc = _nscd_cfg_notify_i(desc, nswdb,
				    &skip, errorp);
			} else { /* send data once for each nsw db */

				for (j = 0; j < _nscd_cfg_num_nsw_db; j++) {

					nswdb = &_nscd_cfg_nsw_db[j];

					rc = _nscd_cfg_notify_i(desc,
					    nswdb, &skip, errorp);

					if (rc != NSCD_SUCCESS)
						break;
				}
			}
		}

		if (rc != NSCD_SUCCESS)
			return (rc);

		i += skip;
	}

	return (NSCD_SUCCESS);
}

nscd_rc_t
_nscd_cfg_init(
	nscd_cfg_error_t		**errorp)
{

	int				i, j, datalen;
	int				dbi = 0, dbj = 0;
	char				*dest, *src;
	char				*dbni = NULL, *dbnj = NULL;
	nscd_rc_t			rc;
	nscd_cfg_nsw_spc_default_t	*spc;

	if (errorp != NULL)
		*errorp = NULL;

	rc = _nscd_cfg_init_param();
	if (rc != NSCD_SUCCESS)
		return (rc);

	rc = _nscd_cfg_init_stat();
	if (rc != NSCD_SUCCESS)
		return (rc);

	nscd_cfg_global_current = calloc(1,
	    sizeof (nscd_cfg_global_data_t));
	if (nscd_cfg_global_current == NULL)
		return (NSCD_NO_MEMORY);

	nscd_cfg_nsw_alldb_current = calloc(1,
	    sizeof (nscd_cfg_nsw_db_data_t));
	if (nscd_cfg_nsw_alldb_current == NULL)
		return (NSCD_NO_MEMORY);

	nscd_cfg_nsw_db_data_current = calloc(_nscd_cfg_num_nsw_db,
	    sizeof (nscd_cfg_nsw_db_data_t));
	if (nscd_cfg_nsw_db_data_current == NULL)
		return (NSCD_NO_MEMORY);

	nscd_cfg_global_rwlock = calloc(1, sizeof (rwlock_t));
	if (nscd_cfg_global_rwlock == NULL)
		return (NSCD_NO_MEMORY);
	(void) rwlock_init(nscd_cfg_global_rwlock, NULL, NULL);

	*nscd_cfg_global_current = nscd_cfg_global_default;

	rc = _nscd_cfg_set_vlen_data_int(&nscd_cfg_global_default,
	    nscd_cfg_global_current, nscd_true);
	if (rc != NSCD_SUCCESS)
		return (rc);

	nscd_cfg_nsw_db_data_rwlock = calloc(_nscd_cfg_num_nsw_db,
	    sizeof (rwlock_t));
	if (nscd_cfg_nsw_db_data_rwlock == NULL)
		return (NSCD_NO_MEMORY);

	/* set per switch db config to the default for all db's */
	for (i = 0; i < _nscd_cfg_num_nsw_db; i++) {

		nscd_cfg_nsw_db_data_current[i] =
		    nscd_cfg_nsw_db_data_default;

		(void) rwlock_init(&nscd_cfg_nsw_db_data_rwlock[i],
		    NULL, NULL);
	}

	/* add db specific defaults */
	for (i = 0; i < _nscd_cfg_num_nsw_default; i++) {

		if (_nscd_cfg_nsw_spc_default[i].data == NULL)
			continue;

		if (_nscd_cfg_nsw_spc_default[i].db != dbni) {
			for (j = 0; j < _nscd_cfg_num_nsw_db; j++) {

				if (strcmp(_nscd_cfg_nsw_db[j].name,
				    _nscd_cfg_nsw_spc_default[i].db) != 0)
					continue;

				dbi = _nscd_cfg_nsw_db[j].index;
				dbni = _nscd_cfg_nsw_db[j].name;
				break;
			}
		}

		dest = (char *)&nscd_cfg_nsw_db_data_current[dbi] +
		    _nscd_cfg_nsw_spc_default[i].group_off +
		    _nscd_cfg_nsw_spc_default[i].param_off;

		src = _nscd_cfg_nsw_spc_default[i].data;
		datalen = _nscd_cfg_nsw_spc_default[i].data_len;

		(void) memcpy(dest, src, datalen);
	}

	/* add db specific defaults via links */
	for (i = 0; i < _nscd_cfg_num_link_default; i++) {

		if (_nscd_cfg_nsw_link_default[i].data == NULL)
			continue;

		spc = _nscd_cfg_nsw_link_default[i].data;

		if (_nscd_cfg_nsw_link_default[i].db != dbni) {
			for (j = 0; j < _nscd_cfg_num_nsw_db; j++) {

				if (strcmp(_nscd_cfg_nsw_db[j].name,
				    _nscd_cfg_nsw_link_default[i].db) != 0)
					continue;

				dbi = _nscd_cfg_nsw_db[j].index;
				dbni = _nscd_cfg_nsw_db[j].name;
				break;
			}
		}

		dest = (char *)&nscd_cfg_nsw_db_data_current[dbi] +
		    _nscd_cfg_nsw_link_default[i].group_off +
		    _nscd_cfg_nsw_link_default[i].param_off;

		if (_nscd_cfg_nsw_db[j].name != dbnj) {
			for (j = 0; j < _nscd_cfg_num_nsw_db; j++) {

				if (strcmp(spc->db,
				    _nscd_cfg_nsw_db[j].name) != 0)
					continue;

				dbnj = _nscd_cfg_nsw_db[j].name;
				dbj = _nscd_cfg_nsw_db[j].index;
				break;
			}
		}

		src = (char *)&nscd_cfg_nsw_db_data_current[dbj] +
		    spc->group_off + spc->param_off;
		datalen = spc->data_len;

		(void) memcpy(dest, src, datalen);
	}

	/* fix up variable length fields */
	for (i = 0; i < _nscd_cfg_num_nsw_db; i++) {

		rc = _nscd_cfg_set_vlen_data_int(
		    &nscd_cfg_nsw_db_data_current[i],
		    &nscd_cfg_nsw_db_data_current[i], nscd_false);
		if (rc != NSCD_SUCCESS)
			return (rc);
	}

	nscd_cfg_nsw_alldb_rwlock = calloc(1, sizeof (rwlock_t));
	if (nscd_cfg_nsw_alldb_rwlock == NULL)
		return (NSCD_NO_MEMORY);

	(void) rwlock_init(nscd_cfg_nsw_alldb_rwlock, NULL, NULL);

	rc = _nscd_cfg_set_vlen_data_int(
	    &nscd_cfg_nsw_db_data_default,
	    nscd_cfg_nsw_alldb_current, nscd_false);
	if (rc != NSCD_SUCCESS)
		return (rc);

	/*
	 * notify and send the configuration data to
	 * the nscd components
	 */
	rc = _nscd_cfg_notify_init(errorp);
	if (rc != NSCD_SUCCESS)
		return (rc);

	return (NSCD_SUCCESS);
}

static nscd_rc_t
_nscd_cfg_get_handle_common(
	nscd_cfg_list_type_t	type,
	char			*name,
	char			*nswdb_name,
	nscd_cfg_handle_t	**handle,
	nscd_cfg_error_t	**errorp)
{

	int			i, is_global;
	char			*desc_str;
	nscd_cfg_handle_t	*h;
	nscd_cfg_param_desc_t	*pdesc;
	nscd_cfg_stat_desc_t	*sdesc;
	char			*me = "_nscd_cfg_get_handle_common";
	char			msg[NSCD_CFG_MAX_ERR_MSG_LEN];
	nscd_rc_t		rc = NSCD_INVALID_ARGUMENT;

	if (handle == NULL) {

		(void) snprintf(msg, sizeof (msg),
		    gettext("address of handle not specified"));
		if (errorp)
			*errorp = _nscd_cfg_make_error(rc, msg);

		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
		(me, "invalid argument: %s\n", msg);

		return (rc);
	}

	*handle = NULL;

	if (name == NULL) {

		(void) snprintf(msg, sizeof (msg),
		    gettext("name not specified"));
		if (errorp)
			*errorp = _nscd_cfg_make_error(rc, msg);

		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
		(me, "invalid argument: %s\n");

		return (rc);
	}

	h = calloc(1, sizeof (nscd_cfg_handle_t));
	if (h == NULL)
		return (NSCD_NO_MEMORY);
	h->type = type;

	if (type == NSCD_CFG_LIST_PARAM)
		desc_str = gettext("configuration parameter");
	else
		desc_str = gettext("statistics");

	/* get param or stat descriptor */
	i = _nscd_cfg_get_index(name, type);
	if (i != -1) {

		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
		(me, "%s: index of %s is %d\n", desc_str, name, i);

		if (type == NSCD_CFG_LIST_PARAM) {
			pdesc = &_nscd_cfg_param_desc[i];
			(void) memcpy(&h->desc, &pdesc, sizeof (pdesc));
			is_global = _nscd_cfg_flag_is_set(
			    pdesc->pflag, NSCD_CFG_PFLAG_GLOBAL);

			/* hidden params are not exposed */
			if (_nscd_cfg_flag_is_set(
			    pdesc->pflag, NSCD_CFG_PFLAG_HIDDEN))
				i = -1;

			if (_nscd_cfg_flag_is_set(pdesc->pflag,
			    NSCD_CFG_PFLAG_OBSOLETE)) {
				_NSCD_LOG(NSCD_LOG_CONFIG,
				    NSCD_LOG_LEVEL_WARNING)
				(me, gettext("%s: %s is obsolete and "
				    "will be ignored\n"),
				    desc_str, name);
			}
		} else {
			sdesc = &_nscd_cfg_stat_desc[i];
			(void) memcpy(&h->desc, &sdesc, sizeof (sdesc));
			is_global = _nscd_cfg_flag_is_set(
			    sdesc->sflag, NSCD_CFG_SFLAG_GLOBAL);
		}
	}

	if (i == -1) {

		(void) snprintf(msg, sizeof (msg),
		    gettext("%s: unknown name \"%s\""), desc_str, name);
		if (errorp)
			*errorp = _nscd_cfg_make_error(rc, msg);

		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "%s\n", msg);

		free(h);
		return (rc);
	}

	/*
	 * if the param/stat is not a global one, we need to
	 * know which nsswitch database we are dealing with
	 */
	if (is_global == 0) {
		if (nswdb_name == NULL) {

			(void) snprintf(msg, sizeof (msg),
			gettext("%s: switch database name not specified"),
			    desc_str);
			if (errorp)
				*errorp = _nscd_cfg_make_error(rc, msg);

			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
			(me, "%s for non-global param or stat %s\n",
			    msg, name);

			free(h);
			return (rc);
		}
	} else {

		if (nswdb_name != NULL) {

			(void) snprintf(msg, sizeof (msg),
			    gettext("%s: switch database specified for "
			    "global data"), desc_str);
			if (errorp)
				*errorp = _nscd_cfg_make_error(rc, msg);

			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
			(me, "%s %s\n", msg, name);

			free(h);
			return (rc);
		}

		*handle = h;
		return (NSCD_SUCCESS);
	}

	/* get nsw DB id */
	i = _nscd_cfg_get_index(nswdb_name, NSCD_CFG_LIST_NSW_DB);
	if (i != -1) {

		if (i == NSCD_CFG_NSW_ALLDB_INDEX)
			h->nswdb = &_nscd_cfg_nsw_alldb;
		else
			h->nswdb = &_nscd_cfg_nsw_db[i];

		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
		(me, "%s: index of %s is %d\n",
		    desc_str, nswdb_name, i);
	} else {

		(void) snprintf(msg, sizeof (msg),
		    gettext("%s: unknown switch database name \"%s\""),
		    desc_str, nswdb_name);
		if (errorp)
			*errorp = _nscd_cfg_make_error(rc, msg);

		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "%s\n", msg);

		free(h);
		return (NSCD_CFG_UNSUPPORTED_SWITCH_DB);
	}

	*handle = h;

	return (NSCD_SUCCESS);
}

nscd_rc_t
_nscd_cfg_get_handle(
	char			*param_name,
	char			*nswdb_name,
	nscd_cfg_handle_t	**handle,
	nscd_cfg_error_t	**errorp)
{

	return (_nscd_cfg_get_handle_common(NSCD_CFG_LIST_PARAM,
	    param_name, nswdb_name, handle, errorp));
}

nscd_rc_t
_nscd_cfg_get_stat_handle(
	char			*stat_name,
	char			*nswdb_name,
	nscd_cfg_handle_t	**handle,
	nscd_cfg_error_t	**errorp)
{

	return (_nscd_cfg_get_handle_common(NSCD_CFG_LIST_STAT,
	    stat_name, nswdb_name, handle, errorp));
}

void
_nscd_cfg_free_handle(
	nscd_cfg_handle_t	*handle)
{

	free(handle);

}

static void
_nscd_cfg_free_vlen_data_group(
	nscd_cfg_param_desc_t	*gdesc,
	void			*group_data,
	nscd_bool_t		in)
{
	int			num;
	void			*dest, *ptr;
	nscd_cfg_param_desc_t	*desc;

	desc = gdesc;

	num = ((nscd_cfg_group_info_t *)group_data)->num_param;

	while (num-- > 0) {

		desc++;

		/* skip fixed length data */
		if (_nscd_cfg_flag_is_not_set(desc->pflag,
		    NSCD_CFG_PFLAG_VLEN_DATA))
			continue;

		dest = (char *)group_data + desc->p_offset;
		ptr = *(char **)dest;
		if (ptr == NULL)
			continue;
		if (in == nscd_true)
			_nscd_cfg_free_vlen_data_int(ptr);
		else
			free(ptr);
	}
}

void
_nscd_cfg_free_param_data(
	void			*data)
{

	if (data == NULL)
		return;

	free(data);
}

void
_nscd_cfg_free_group_data(
	nscd_cfg_handle_t	*handle,
	void			*data)
{

	nscd_cfg_param_desc_t	*desc;
	nscd_cfg_group_info_t	*gi;

	if (handle == NULL || data == NULL)
		return;

	desc = _nscd_cfg_get_desc(handle);
	gi = (nscd_cfg_group_info_t *)data;
	if (desc->p_fn != gi->num_param)
		return;

	_nscd_cfg_free_vlen_data_group(desc, data, nscd_false);

	free(data);
}

void
_nscd_cfg_free_error(
	nscd_cfg_error_t	*error)
{

	if (error == NULL)
		return;

	free(error);
}

static nscd_rc_t
_nscd_cfg_copy_param_data(
	nscd_cfg_param_desc_t	*desc,
	void			*dest,
	void			*pdata,
	nscd_bool_t		in,
	nscd_bool_t		set_addr)
{

	char			*me = "_nscd_cfg_copy_param_data";
	void			*tmp;
	int			dlen;
	nscd_rc_t		rc = NSCD_SUCCESS;

	if (desc == NULL || dest == NULL) {
		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "input desc == %p, dest == %p\n", desc, dest);
		return (NSCD_INVALID_ARGUMENT);
	}

	/* fixed length data */
	if (_nscd_cfg_flag_is_not_set(desc->pflag,
	    NSCD_CFG_PFLAG_VLEN_DATA)) {
		(void) memcpy(dest, pdata, desc->p_size);
		goto done;
	}


	/* variable length data from this point on */

	/* make a copy of the variable length data */
	rc = _nscd_cfg_copy_vlen_data(pdata, &tmp, desc, &dlen, in);
	if (rc != NSCD_SUCCESS)
		goto done;

	if (in == nscd_true) { /* data to internal */

		/* free the variable length data in the config store */
		if (*(char **)dest != NULL)
			_nscd_cfg_free_vlen_data_int(*(char **)dest);
	}

	if (set_addr == nscd_true) {
		/*
		 * set the addr of the vlen data
		 */
		*(char **)dest = tmp;
	} else {
		/*
		 * copy the data content (not address)
		 */
		(void) memcpy(dest, tmp, dlen);
	}

	done:

	return (rc);
}

static nscd_rc_t
_nscd_cfg_copy_group_data_in(
	nscd_cfg_param_desc_t	*gdesc,
	nscd_cfg_group_info_t	*gi,
	void			*group_dest,
	void			*group_src)
{
	int			i, num;
	nscd_cfg_param_desc_t	*desc;
	void			*src, *dest;

	i = 0;
	num = gi->num_param;
	desc = gdesc;

	while (num-- > 0) {

		desc++;

		/* if member not selected by bitmap, skip */
		if (_nscd_cfg_bitmap_is_not_set(gi->bitmap, i++))
			continue;

		src = (char *)group_src + desc->p_offset;
		dest = (char *)group_dest + desc->p_offset;

		/*
		 * if variable length data, free and replace the old
		 * with the new
		 */
		if (_nscd_cfg_flag_is_set(desc->pflag,
		    NSCD_CFG_PFLAG_VLEN_DATA)) {
			_nscd_cfg_free_vlen_data_int(*(char **)dest);
			*(char **)dest = *(char **)src;
			*(char **)src = NULL;
		} else {
			/*
			 * fixed length data, just copy it
			 */
			(void) memcpy(dest, src, desc->p_size);
		}
	}

	return (NSCD_SUCCESS);
}

static nscd_rc_t
_nscd_cfg_copy_group_data_out(
	nscd_cfg_param_desc_t	*gdesc,
	void			*group_dest,
	void			*group_src)
{

	char			*me = "_nscd_cfg_copy_group_data_out";
	void			*src, *dest;
	int			dlen;
	int			num;
	nscd_cfg_group_info_t	*gi;
	nscd_rc_t		rc = NSCD_SUCCESS;
	nscd_cfg_param_desc_t	*desc;

	if (group_dest == NULL) {
		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "input group_dest = NULL\n");
		return (NSCD_INVALID_ARGUMENT);
	}

	gi = _nscd_cfg_get_gi(group_src);
	num = gi->num_param;
	desc = gdesc;

	while (num-- > 0) {

		desc++;

		dest = (char *)group_dest + desc->p_offset;
		src = (char *)group_src + desc->p_offset;

		/*
		 * if variable length data, get the real
		 * address and length of the data
		 */
		if (_nscd_cfg_flag_is_set(desc->pflag,
		    NSCD_CFG_PFLAG_VLEN_DATA)) {
			src = _nscd_cfg_locate_vlen_data(src, &dlen);
			if (dlen == NULL)
				continue;
		}

		/*
		 * The nscd_true asks _nscd_cfg_copy_param_data
		 * to set addr of the vlen data in 'dest' rather
		 * than copying the data content
		 */
		rc = _nscd_cfg_copy_param_data(desc, dest, src,
		    nscd_false, nscd_true);
		if (rc != NSCD_SUCCESS) {
			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
			(me, "unable to copy param data for %s\n",
			    desc->id.name);

			_nscd_cfg_free_vlen_data_group(gdesc,
			    group_dest, nscd_false);

			free(group_dest);

			return (rc);
		}
	}

	/*
	 * set group bitmap
	 */
	(void) memcpy(group_dest, group_src,
	    sizeof (nscd_cfg_group_info_t));

	return (rc);
}


/*
 * group_cfg is needed always; group_src may be NULL if
 * param_index not zero and pdata not NULL; group_cfg and
 * pdata should not be both non-NULL
 */
static nscd_rc_t
_nscd_cfg_copy_group_data_merge(
	nscd_cfg_param_desc_t	*gdesc,
	void			**group_dest,
	void			*group_src,
	void			*group_cfg,
	int			param_index,
	void			*pdata)
{

	char			*me = "_nscd_cfg_copy_group_data_merge";
	void			*src, *dest, *tmp_dest = NULL;
	int			num, i = 0;
	nscd_cfg_group_info_t	*gi;
	nscd_rc_t		rc = NSCD_SUCCESS;
	nscd_cfg_param_desc_t	*desc;
	nscd_cfg_bitmap_t	bitmap;

	if (group_dest == NULL) {
		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "input **group_dest == NULL\n");
		return (NSCD_INVALID_ARGUMENT);
	}

	if (group_cfg == NULL) {
		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "input **group_cfg == NULL\n");
		return (NSCD_INVALID_ARGUMENT);
	}

	if (param_index != NULL && pdata == NULL) {
		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "param_index != NULL but pdata == %p\n", pdata);
		return (NSCD_INVALID_ARGUMENT);
	}

	tmp_dest = calloc(1, gdesc->g_size);
	if (tmp_dest == NULL)
		return (NSCD_NO_MEMORY);

	if (group_src != NULL)
		gi = _nscd_cfg_get_gi(group_src);
	else {
		gi = _nscd_cfg_get_gi(group_cfg);
		bitmap = NSCD_CFG_BITMAP_ZERO;
	}

	num = gi->num_param;
	desc = gdesc;

	while (num-- > 0) {

		desc++;

		dest = (char *)tmp_dest + desc->p_offset;

		/*
		 * if member not selected by bitmap in group_src,
		 * get the member data in group_cfg
		 */
		if (_nscd_cfg_bitmap_is_not_set(gi->bitmap, i++) ||
		    group_src == NULL) {
			src = (char *)group_cfg + desc->p_offset;
		} else
			src = (char *)group_src + desc->p_offset;

		if (desc->id.index == param_index) {

			/* use the param data in pdata if provided */
			src = pdata;
			_nscd_cfg_bitmap_set_nth(bitmap, i);
		}

		/*
		 * if variable length data, get to the data
		 * instead of pointer to the data
		 */
		if (_nscd_cfg_flag_is_set(desc->pflag,
		    NSCD_CFG_PFLAG_VLEN_DATA))
			src = *(char **)src;

		/*
		 * nscd_true asks _nscd_cfg_copy_param_data to
		 * set addr of the vlen data in 'dest' rather
		 * than copying the data content
		 */
		rc = _nscd_cfg_copy_param_data(desc, dest, src,
		    nscd_true, nscd_true);
		if (rc != NSCD_SUCCESS) {
			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
			(me, "unable to copy param data for %s\n",
			    desc->id.name);

			_nscd_cfg_free_vlen_data_group(gdesc,
			    tmp_dest, nscd_true);

			free(tmp_dest);

			return (rc);
		}
	}

	*group_dest = tmp_dest;

	/*
	 * set bitmap: if input is group data, use the one
	 * given; if input is param data, use the one computed
	 * above
	 */
	if (group_src != NULL)
		(void) memcpy(*group_dest, group_src,
		    sizeof (nscd_cfg_group_info_t));
	else {
		gi = _nscd_cfg_get_gi(*group_dest);
		_nscd_cfg_bitmap_set(&gi->bitmap, bitmap);
	}

	return (rc);
}

/* ARGSUSED */
nscd_rc_t
_nscd_cfg_get(
	nscd_cfg_handle_t	*handle,
	void			**data,
	int			*data_len,
	nscd_cfg_error_t	**errorp)
{
	char			*me = "_nscd_cfg_get";
	int			dlen;
	nscd_rc_t		rc = NSCD_SUCCESS;
	nscd_cfg_id_t		*nswdb;
	nscd_cfg_param_desc_t	*desc;
	void			*cfg_data, *ptr = NULL;
	nscd_bool_t		get_group = nscd_false;
	nscd_bool_t		out = nscd_false;
	nscd_cfg_lock_t		*lock = NULL;

	if (data_len != NULL)
		*data_len = 0;

	if (data == NULL) {
		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "input data = %p\n", data);
		return (NSCD_INVALID_ARGUMENT);
	}

	*data = NULL;

	if (handle == NULL) {
		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "handle is NULL\n");
		return (NSCD_INVALID_ARGUMENT);
	}

	nswdb = handle->nswdb;
	desc = (nscd_cfg_param_desc_t *)handle->desc;

	if (_nscd_cfg_flag_is_set(desc->pflag, NSCD_CFG_PFLAG_GROUP))
		get_group = nscd_true;

	/*
	 * locate the current value of the param or group
	 * and lock the config data for reading
	 */
	rc = _nscd_cfg_locate_cfg_data(&cfg_data, nscd_true, desc,
	    nswdb, get_group, NULL, &dlen, &lock);
	if (rc != NSCD_SUCCESS) {

		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "unable to locate config data\n");
		return (rc);

	} else if (cfg_data == NULL) /* NULL vlen data */
		goto done;

	ptr = calloc(1, dlen);
	if (ptr == NULL) {
		rc = NSCD_NO_MEMORY;
		goto error_exit;
	}

	if (get_group == nscd_true) {

		rc = _nscd_cfg_copy_group_data_out(desc, ptr, cfg_data);
		if (rc != NSCD_SUCCESS) {
			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
			(me, "unable to copy group data %p: "
			"error = %d\n", cfg_data, rc);

			goto error_exit;
		}
	} else {
		/*
		 * nscd_false asks _nscd_cfg_copy_param_data to
		 * copy the data content rather than just setting
		 * the addr of the vlen data in 'ptr'
		 */
		rc = _nscd_cfg_copy_param_data(desc, ptr, cfg_data,
		    out, nscd_false);

		if (rc != NSCD_SUCCESS) {
			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
			(me, "unable to copy param data %p: "
			"error = %d\n", cfg_data, rc);

			goto error_exit;
		}
	}

	*data = ptr;

	done:

	if (data_len != NULL)
		*data_len = dlen;

	_nscd_cfg_unlock(lock);

	return (NSCD_SUCCESS);

	error_exit:

	_nscd_cfg_unlock(lock);
	if (ptr != NULL)
		free(ptr);

	return (rc);
}

/*
 * three type of data:
 * 1 - single param
 * 	desc is that of the param
 * 2 - single param to be sent in a group
 *	a single bit is set in the bitmap,
 * 	desc is that of the group
 * 3 - group data
 *	one of more bits are set in the bitmap,
 * 	desc is that of the group
 */
static nscd_rc_t
_nscd_cfg_notify_s(
	nscd_cfg_param_desc_t	*desc,
	nscd_cfg_id_t		*nswdb,
	void			*data,
	nscd_cfg_error_t	**errorp)
{
	int			i, num, is_group = 0;
	void			*cookie = NULL;
	void			*cdata;
	nscd_rc_t		rc;
	nscd_cfg_flag_t		dflag, dflag1;
	nscd_cfg_bitmap_t	bitmap_s, bitmap_in, *bitmap_addr = NULL;
	nscd_cfg_group_info_t	*gi;

	if (errorp != NULL)
		*errorp = NULL;

	/*
	 * Set data flag going with data to be sent to the
	 * verify/notify routines. To allow the config flag
	 * be exipandable, set the bits one by one.
	 */
	dflag = NSCD_CFG_FLAG_ZERO;
	dflag = _nscd_cfg_flag_set(dflag, NSCD_CFG_DFLAG_STATIC_DATA);
	if (_nscd_cfg_flag_is_set(desc->pflag, NSCD_CFG_PFLAG_GROUP)) {
		dflag = _nscd_cfg_flag_set(dflag, NSCD_CFG_DFLAG_GROUP);
		is_group = 1;
	}
	if (nswdb != NULL &&
	    strcmp(NSCD_CFG_NSW_ALLDB, nswdb->name) == 0)
		dflag = _nscd_cfg_flag_set(dflag,
		    NSCD_CFG_DFLAG_SET_ALL_DB);

	/*
	 * the bitmap in the input data may be replaced before
	 * sending to the components, so save the bitmap for
	 * later use
	 */
	if (is_group == 1) {
		gi = _nscd_cfg_get_gi(data);
		bitmap_in = gi->bitmap;
		bitmap_addr = &(gi->bitmap);

		if (_nscd_cfg_flag_is_set(desc->pflag,
		    NSCD_CFG_PFLAG_INIT_SEND_WHOLE_GROUP))
			/* send the entire group just once */
			num = 1;

		else { /* send individual members one by one */

			num = desc->p_fn;

			/*
			 * skip the first desc which is for the group
			 * and get to the desc for the first member
			 */
			desc++;

			dflag = _nscd_cfg_flag_unset(dflag,
			    NSCD_CFG_DFLAG_GROUP);
		}
	} else {
		/* not group data, send the member once */
			num = 1;
	}

	dflag1 = dflag;
	for (i = 0; i < num; i++, desc++) {

		dflag = dflag1;

		if (is_group == 0) {
			cdata = data;
			goto verify_data;
		}

		if (_nscd_cfg_flag_is_set(desc->pflag,
		    NSCD_CFG_PFLAG_SEND_BIT_SELECTED)) {

			/* set the bitmap to select just this member */
			bitmap_s = NSCD_CFG_BITMAP_ZERO;
			_nscd_cfg_bitmap_set_nth(bitmap_s, i);
			/* replace the bitmap in the input data */
			_nscd_cfg_bitmap_set(bitmap_addr, bitmap_s);

			/*
			 * send the whole group but with only one
			 * member selected
			 */
			cdata = data;

			dflag = _nscd_cfg_flag_set(dflag,
			    NSCD_CFG_DFLAG_GROUP);
			dflag = _nscd_cfg_flag_set(dflag,
			    NSCD_CFG_DFLAG_BIT_SELECTED);
		} else {
			/*
			 * send param data or group data:
			 * param data - non-xero desc->p_offset
			 * group data - zero desc->p_offset
			 */
			cdata = (char *)data + desc->p_offset;

			/*
			 * if variable length data, need to send pointer
			 * to the data (not the address of the pointer)
			 */
			if (_nscd_cfg_flag_is_set(desc->pflag,
			    NSCD_CFG_PFLAG_VLEN_DATA))
				cdata = *(char **)cdata;
		}

		verify_data:

		if (desc->verify != NULL) {
			dflag = _nscd_cfg_flag_set(dflag,
			    NSCD_CFG_DFLAG_VERIFY);
			rc = desc->verify(cdata, desc, nswdb,
			    dflag, errorp, &cookie);
			if (rc != NSCD_SUCCESS)
				goto error_exit;
		}

		if (desc->notify != NULL) {
			dflag = _nscd_cfg_flag_set(dflag,
			    NSCD_CFG_DFLAG_NOTIFY);

			rc = desc->notify(data, desc, nswdb,
			    dflag, errorp, cookie);
			if (rc != NSCD_SUCCESS)
				goto error_exit;
		}
	}

	rc = NSCD_SUCCESS;

	error_exit:

	/* restore the bitmap in the input data */
	if (bitmap_addr != NULL)
		_nscd_cfg_bitmap_set(bitmap_addr, bitmap_in);

	return (rc);
}

/*
 * Convert string 'str' to data based on the data type in 'desc'.
 * 'data' points to the buffer in which the converted data
 * is placed. '*data_p' points to the buffer, or in the case
 * of a string data type, points to the untoched string (i.e.,
 * 'str').
 */
nscd_rc_t
_nscd_cfg_str_to_data(
	nscd_cfg_param_desc_t	*desc,
	char			*str,
	void			*data,
	void			**data_p,
	nscd_cfg_error_t	**errorp)
{

	char			*me = "_nscd_cfg_str_to_data";
	char			*c;
	nscd_cfg_bitmap_t	bitmap;
	char			msg[NSCD_CFG_MAX_ERR_MSG_LEN];
	nscd_rc_t		rc = NSCD_CFG_DATA_CONVERSION_FAILED;

	if (desc == NULL || str == NULL || data == NULL) {
		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "ERROR: one of the following is NULL "
		    "desc = %p, str = %p, data = %p, data_p = %p\n",
		    desc, str, data, data_p);

		return (NSCD_INVALID_ARGUMENT);
	}
	*data_p = data;

	/* if description is that of a group, return error */
	if (_nscd_cfg_flag_is_set(desc->pflag, NSCD_CFG_PFLAG_GROUP)) {

		(void) snprintf(msg, sizeof (msg),
		gettext("single data specified for group %s"), desc->id.name);

		if (errorp != NULL)
			*errorp = _nscd_cfg_make_error(NSCD_INVALID_ARGUMENT,
			    msg);

		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "ERROR: %s)\n", msg);

		return (NSCD_INVALID_ARGUMENT);

	}

	if (desc->type == NSCD_CFG_DATA_STRING) {
		if (strcmp(str, NSCD_NULL) == 0)
			*(char **)data_p = NULL;
		else {
			/* remove the " char if quoted string */
			if (str[0] == '"') {
				c = str + strlen(str) - 1;
				if (*c == '"')
					*c = '\0';
				*(char **)data_p = str + 1;
			} else
				*(char **)data_p = str;

		}
		return (NSCD_SUCCESS);
	}

	if (str == NULL) {

		(void) snprintf(msg, sizeof (msg),
		gettext("data must be specified for %s"), desc->id.name);

		if (errorp != NULL)
			*errorp = _nscd_cfg_make_error(NSCD_INVALID_ARGUMENT,
			    msg);

		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "ERROR: %s\n", msg);

		return (NSCD_INVALID_ARGUMENT);

	}

	switch (desc->type) {

	case NSCD_CFG_DATA_BOOLEAN:

		if (strcasecmp(str, "yes") == 0)
			*(nscd_bool_t *)data = nscd_true;
		else if (strcasecmp(str, "no") == 0)
			*(nscd_bool_t *)data = nscd_false;
		else {

		(void) snprintf(msg, sizeof (msg),
		gettext("data (%s) must be 'yes' or 'no' for %s"),
		    str, desc->id.name);

		if (errorp != NULL)
			*errorp = _nscd_cfg_make_error(NSCD_INVALID_ARGUMENT,
			    msg);

			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
			(me, "ERROR: %s\n", msg);

			return (NSCD_INVALID_ARGUMENT);
		}

		break;

	case NSCD_CFG_DATA_INTEGER:

		errno = 0;
		*(int *)data = (int)strtol(str, (char **)NULL, 10);
		if (errno != NULL) {

			(void) snprintf(msg, sizeof (msg),
			gettext("unable to convert data (%s) for %s"),
			    str, desc->id.name);

			if (errorp != NULL)
				*errorp = _nscd_cfg_make_error(rc, msg);

			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
			(me, "ERROR: %s\n", msg);

			return (rc);
		}

		break;

	case NSCD_CFG_DATA_BITMAP:

		errno = 0;
		bitmap = (nscd_cfg_bitmap_t)strtol(str, (char **)NULL, 10);
		if (errno != NULL) {

			(void) snprintf(msg, sizeof (msg),
			gettext("unable to convert data (%s) for %s"),
			    str, desc->id.name);

			if (errorp != NULL)
				*errorp = _nscd_cfg_make_error(rc, msg);

			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
			(me, "ERROR: %s\n", msg);

			return (rc);
		}

		_nscd_cfg_bitmap_set(data, bitmap);

		break;

	}

	return (NSCD_SUCCESS);
}


nscd_rc_t
_nscd_cfg_set(
	nscd_cfg_handle_t	*handle,
	void			*data,
	nscd_cfg_error_t	**errorp)
{
	char			*me = "_nscd_cfg_set";
	int			dlen;
	nscd_cfg_id_t		*nswdb;
	nscd_cfg_param_desc_t	*desc, *gdesc;
	nscd_cfg_group_info_t	*gi;
	char			*nswdb_name, *param_name;
	void			*pdata = NULL;
	void			*cfg_data, *vdata_addr = NULL;
	nscd_bool_t		get_group = 0;
	nscd_bool_t		in = nscd_true;
	nscd_cfg_lock_t		*lock = NULL;
	nscd_rc_t		rc = NSCD_SUCCESS;

	if (handle == NULL) {
		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "handle is NULL\n");
		return (NSCD_INVALID_ARGUMENT);
	}

	nswdb = handle->nswdb;
	desc = (nscd_cfg_param_desc_t *)handle->desc;
	if (nswdb == NULL)
		nswdb_name = "global";
	else
		nswdb_name = nswdb->name;
	param_name = desc->id.name;

	if (data == NULL && _nscd_cfg_flag_is_not_set(desc->pflag,
	    NSCD_CFG_PFLAG_VLEN_DATA)) {
		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "data == NULL\n");
		return (NSCD_INVALID_ARGUMENT);
	}

	if (_nscd_cfg_flag_is_set(desc->pflag,
	    NSCD_CFG_PFLAG_UPDATE_SEND_WHOLE_GROUP) ||
	    _nscd_cfg_flag_is_set(desc->pflag, NSCD_CFG_PFLAG_GROUP))
		get_group = nscd_true;

	/*
	 * locate the current value of the param or group
	 * and lock the config data for writing
	 */
	rc = _nscd_cfg_locate_cfg_data(&cfg_data, nscd_false, desc,
	    nswdb, get_group, &vdata_addr, &dlen, &lock);
	if (rc != NSCD_SUCCESS) {
		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "unable to locate config data (rc = %d)\n", rc);
		return (rc);
	}

	if (_nscd_cfg_flag_is_set(desc->pflag, NSCD_CFG_PFLAG_GROUP) &&
	    ((nscd_cfg_group_info_t *)cfg_data)->num_param !=
	    ((nscd_cfg_group_info_t *)data)->num_param) {

		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "number of parameters in group <%s : %s> not equal: "
		    "%d in input data, should be %d\n",
		    NSCD_STR_OR_GLOBAL(nswdb_name),
		    NSCD_STR_OR_NULL(param_name),
		    ((nscd_cfg_group_info_t *)data)->num_param,
		    ((nscd_cfg_group_info_t *)cfg_data)->num_param);

		rc = NSCD_INVALID_ARGUMENT;
		goto error_exit;
	}

	/*
	 * if variable length data, we want the address
	 * of the pointer pointing to the data
	 */
	if (vdata_addr != NULL)
		cfg_data = vdata_addr;

	/*
	 * just copy in the specified data, if no need
	 * to verify the data or notify the associated
	 * component
	 */
		if (get_group == nscd_true) {

			gdesc = &_nscd_cfg_param_desc[desc->g_index];

			rc = _nscd_cfg_copy_group_data_merge(
			    gdesc, &pdata, data, cfg_data,
			    desc->id.index, data);

			if (rc != NSCD_SUCCESS) {
				_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
				(me, "unable to copy group data <%s : %s>\n",
				    NSCD_STR_OR_GLOBAL(nswdb_name),
				    NSCD_STR_OR_NULL(param_name));

				goto error_exit;
			}

			rc = _nscd_cfg_notify_s(gdesc, nswdb,
			    pdata, errorp);

		} else
			rc = _nscd_cfg_notify_s(desc, nswdb, data,
			    errorp);

		if (rc != NSCD_SUCCESS) {

			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
			(me, "verifying/notifying  of new configuration "
			    "parameter <%s : %s> failed. %s\n",
			    NSCD_STR_OR_GLOBAL(nswdb_name),
			    param_name, (*errorp && (*errorp)->msg) ?
			    (*errorp)->msg : "");

			goto error_exit;
		}

	/*
	 * Move the new config into the config store
	 */
	rc = NSCD_CFG_SET_PARAM_FAILED;
	if (_nscd_cfg_flag_is_set(desc->pflag,
	    NSCD_CFG_PFLAG_GROUP)) {
		gi = _nscd_cfg_get_gi(pdata);
		rc = _nscd_cfg_copy_group_data_in(gdesc, gi,
		    cfg_data, pdata);
	} else {
		/*
		 * nscd_true asks _nscd_cfg_copy_param_data to
		 * set addr of the vlen data in 'cfg_data' rather
		 * than copying the data content
		 */
		if (pdata != NULL)
			_nscd_cfg_free_vlen_data_group(gdesc,
			    pdata, in);

		rc = _nscd_cfg_copy_param_data(desc,
		    cfg_data, data, in, nscd_true);
	}

	if (rc != NSCD_SUCCESS) {

		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "unable to make new param data <%s : %s> current\n",
		    NSCD_STR_OR_GLOBAL(nswdb_name),
		    NSCD_STR_OR_NULL(param_name));
	}

	error_exit:

	_nscd_cfg_unlock(lock);

	return (rc);
}

nscd_rc_t
_nscd_cfg_set_linked(
	nscd_cfg_handle_t		*handle,
	void				*data,
	nscd_cfg_error_t		**errorp)
{
	char				*me = "_nscd_cfg_set_linked";
	nscd_cfg_id_t			*nswdb;
	nscd_cfg_handle_t		*hl;
	nscd_cfg_param_desc_t		*desc;
	char				*nswdb_name, *param_name, *dbl;
	nscd_rc_t			rc = NSCD_SUCCESS;
	nscd_cfg_nsw_spc_default_t	*spc;
	int				i;
	char				msg[NSCD_CFG_MAX_ERR_MSG_LEN];

	if (handle == NULL) {
		_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
		(me, "handle is NULL\n");
		return (NSCD_INVALID_ARGUMENT);
	}

	nswdb = handle->nswdb;
	desc = (nscd_cfg_param_desc_t *)handle->desc;

	/*
	 * no need to do the special linking thing,
	 * if a global param, or a group, or not a linked param
	 */
	if (nswdb == NULL || _nscd_cfg_flag_is_set(desc->pflag,
	    NSCD_CFG_PFLAG_GROUP) ||
	    _nscd_cfg_flag_is_not_set(desc->pflag,
	    NSCD_CFG_PFLAG_LINKED))
		return (_nscd_cfg_set(handle, data, errorp));
	else
		nswdb_name = nswdb->name;
	param_name = desc->id.name;

	/*
	 * if a param is linked to another, it can not be
	 * changed directly
	 */
	for (i = 0; i < _nscd_cfg_num_link_default; i++) {

		if (_nscd_cfg_nsw_link_default[i].data == NULL)
			continue;

		if (strcmp(_nscd_cfg_nsw_link_default[i].db,
		    nswdb_name) == 0 &&
		    _nscd_cfg_nsw_link_default[i].group_off ==
		    desc->g_offset &&
		    _nscd_cfg_nsw_link_default[i].param_off ==
		    desc->p_offset) {

			rc = NSCD_CFG_READ_ONLY;

			(void) snprintf(msg, sizeof (msg),
			    gettext("value of \'%s\' not changeable, "
			    "change that of \'%s\' instead"),
			    nswdb->name, "passwd");

			if (errorp != NULL)
				*errorp = _nscd_cfg_make_error(rc, msg);

			_NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR)
			(me, "ERROR: %s\n", msg);

			return (rc);
		}
	}

	/*
	 * if a param is linked from another, it should be verify
	 * and changed first
	 */
	for (i = 0; i < _nscd_cfg_num_link_default; i++) {

		if (_nscd_cfg_nsw_link_default[i].data == NULL)
			continue;

		spc = _nscd_cfg_nsw_link_default[i].data;

		if (strcmp(spc->db, nswdb_name) == 0 &&
		    spc->group_off == desc->g_offset &&
		    spc->param_off == desc->p_offset) {

			rc = _nscd_cfg_set(handle, data, errorp);
			if (rc != NSCD_SUCCESS)
				return (rc);
			break;
		}
	}

	/*
	 * then change all those linked to the one that has been changed
	 */
	for (i = 0; i < _nscd_cfg_num_link_default; i++) {

		if (_nscd_cfg_nsw_link_default[i].data == NULL)
			continue;

		spc = _nscd_cfg_nsw_link_default[i].data;

		if (strcmp(spc->db, nswdb_name) == 0 &&
		    spc->group_off == desc->g_offset &&
		    spc->param_off == desc->p_offset &&
		    _nscd_cfg_nsw_link_default[i].group_off ==
		    desc->g_offset &&
		    _nscd_cfg_nsw_link_default[i].param_off ==
		    desc->p_offset) {

			dbl = _nscd_cfg_nsw_link_default[i].db;

			rc = _nscd_cfg_get_handle(param_name, dbl,
			    &hl, errorp);
			if (rc != NSCD_SUCCESS)
				return (rc);
			rc = _nscd_cfg_set(hl, data, errorp);
			_nscd_cfg_free_handle(hl);
			if (rc != NSCD_SUCCESS)
				return (rc);
		}
	}

	return (_nscd_cfg_set(handle, data, errorp));
}

/*
 * Return a list of comma-separated database names that
 * have at least one of the input sources (the srcs array)
 * appears in their configured nsswitch policy string.
 * That is, if srcs contains "ldap" and "passwd: files ldap"
 * "group: files ldap" are in /etc/nsswitch.conf, then
 * "passwd,group" will be returned. The return string
 * should be freed by the caller.
 *
 * For compat nsswitch configuration, "group" and/or
 * "passwd,user_attr,shadow,audit_user" (not "group_compat"
 * or "passwd_compat") will be returned. Note that the
 * user_attr, shadow, and audit_user databases share the
 * same policy with the passwd database.
 *
 * For example, if srcs has "ldap" and in /etc/nsswitch.conf,
 * there are:
 *   passwd:		compat
 *   passwd_compat:	ldap
 *   group:		compat
 *   group_compat:	ldap
 *   netgroup:		ldap
 * then "netgroup,passwd,group,user_attr,shadow,audit_user"
 * will be returned.
 */
char *
_nscd_srcs_in_db_nsw_policy(
	int			num_src,
	char			**srcs)
{
	uint8_t			i, j, n = 0, nc = 0;
	uint8_t			compat_grp = 0, compat_pwd = 0;
	uint8_t			*db;
	uint8_t			*db_compat;
	int			dlen = 0;
	nscd_cfg_nsw_db_data_t	*dbcfg;
	nscd_cfg_switch_t	*sw;
	char			*outstr = NULL;
	char			*dbname;

	db = (uint8_t *)calloc(_nscd_cfg_num_nsw_db, sizeof (uint8_t));
	if (db == NULL)
		return (NULL);

	db_compat = (uint8_t *)calloc(_nscd_cfg_num_nsw_db,
	    sizeof (uint8_t));
	if (db_compat == NULL) {
		free(db);
		return (NULL);
	}

	for (i = 0; i < _nscd_cfg_num_nsw_db; i++) {

		(void) rw_rdlock(&nscd_cfg_nsw_db_data_rwlock[i]);

		dbcfg = &nscd_cfg_nsw_db_data_current[i];
		sw = &dbcfg->sw;
		if (sw->nsw_config_string == NULL) {
			(void) rw_unlock(&nscd_cfg_nsw_db_data_rwlock[i]);
			continue;
		}

		dbname = _nscd_cfg_nsw_db[i].name;
		for (j = 0; j < num_src; j++) {
			if (strstr(sw->nsw_config_string, srcs[j]) !=
			    NULL) {
				db[n++] = i;
				dlen += strlen(dbname) + 1;
			} else if (strcmp(sw->nsw_config_string,
			    "compat") == 0) {
				if (strcmp(dbname, "passwd") == 0) {
					compat_pwd = 1;
					dlen += 7;
				} else if (strcmp(dbname, "group") == 0) {
					compat_grp = 1;
					dlen += 6;
				} else {
					db_compat[nc++] = i;
					dlen += strlen(dbname) + 1;

				}
			}
		}
		(void) rw_unlock(&nscd_cfg_nsw_db_data_rwlock[i]);
	}

	if (dlen != 0)
		outstr = (char *)calloc(1, dlen);
	if (outstr == NULL) {
		free(db_compat);
		free(db);
		return (NULL);
	}

	for (j = 0; j < n; j++) {
		dbname = _nscd_cfg_nsw_db[db[j]].name;
		if (strstr(dbname, "group_compat") != NULL) {
			if (compat_grp == 1)
				dbname = "group";
			else
				continue;
		} else if (strstr(dbname, "passwd_compat") != NULL) {
			if (compat_pwd == 1)
				dbname = "passwd";
			else
				continue;
		}

		(void) strlcat(outstr, dbname, dlen);
		(void) strlcat(outstr, ",", dlen);
	}

	for (j = 0; j < nc; j++) {
		dbname = _nscd_cfg_nsw_db[db_compat[j]].name;
		if (compat_pwd == 1) {
			(void) strlcat(outstr, dbname, dlen);
			(void) strlcat(outstr, ",", dlen);
		}
	}

	/* remove the last comma */
	i = strlen(outstr) - 1;
	if (outstr[i] == ',')
		outstr[i] = '\0';

	free(db);
	free(db_compat);
	return (outstr);

}