#include <nss_dbdefs.h>

#include <sys/types.h>

#include <sys/mman.h>

#include <errno.h>

#include <getxby_door.h>

 * policy component function interposing definitions:

 * nscd if so desired can interpose it's own switch functions over

 * the internal unlocked counterparts.  This will allow nscd to replace

 * the switch policy state engine with one that uses it's internal

 * components.

 * Only nscd can change this through it's use of nss_config.

 * The golden rule is: ptr == NULL checking is used in the switch to

 * see if a function was interposed.  But nscd is responsible for seeing

 * that mutex locking to change the values are observed when the data is

 * changed.  Especially if it happens > once.  The switch does not lock

 * the pointer with mutexs.

 */

typedef struct {

	void	*p;

#if 0

	void		(*nss_delete_fp)(nss_db_root_t *rootp);

	nss_status_t	(*nss_search_fp)(nss_db_root_t *rootp,

				nss_db_initf_t initf, int search_fnum,

				void *search_args);

	void		(*nss_setent_u_fp)(nss_db_root_t *,

				nss_db_initf_t, nss_getent_t *);

	nss_status_t	(*nss_getent_u_fp)(nss_db_root_t *,

				nss_db_initf_t, nss_getent_t *, void *);

	void		(*nss_endent_u_fp)(nss_db_root_t *,

				nss_db_initf_t, nss_getent_t *);

	void		(*end_iter_u_fp)(nss_db_root_t *rootp,

				struct nss_getent_context *contextp);

#endif

} nss_policyf_t;

static mutex_t nss_policyf_lock = DEFAULTMUTEX;

static nss_policyf_t nss_policyf_ptrs =

	{ (void *)NULL };

/*

 * nsswitch db_root state machine definitions:

/*

 * NSS_OPTIONS/NIS_OPTIONS environment varibles data definitions:

 * This remains for backwards compatibility.  But generally nscd will

 * decide if/how this gets used.

 */

/*

 * switch configuration parameter "database" definitions:

 * The switch maintains a simmple read/write parameter database

 * that nscd and the switch components can use to communicate

 * nscd data to other components for configuration or out of band

 * [IE no in the context of a getXbyY or putXbyY operation] data.

 * The data passed are pointers to a lock  data buffer and a length.

 * Use of this is treated as SunwPrivate between nscd and the switch

 * unless other wise stated.

 */

typedef struct nss_cfgparam {

	char 		*name;

	mutex_t		*lock;

	void		*buffer;

	size_t		length;

} nss_cfgparam_t;

typedef struct nss_cfglist {

	char 		*name;

	nss_cfgparam_t	*list;

	int		count;

	int		max;

} nss_cfglist_t;

#define	NSS_CFG_INCR	16

static nss_cfglist_t *nss_cfg = (nss_cfglist_t *)NULL;

static int nss_cfgcount = 0;

static int nss_cfgmax = 0;

static mutex_t nss_cfglock = DEFAULTMUTEX;

static int nss_cfg_policy_init();

/*

 * A config parameters are in the form component:parameter

 * as in: nss:parameter - switch (internal FE/policy/BE) parameter

 *	  nscd:param - nscd application parameter

 *	  ldap:param - nss_ldap BE parameter

 *	  passwd:param - get/put passwd FE parameter

 */

#define	NSS_CONFIG_BRK	':'

/*

 * The policy components initial parameter list

 */

static nss_config_t	nss_policy_params[] = {

	{ "nss:policyfunc", NSS_CONFIG_ADD, &nss_policyf_lock,

		(void *)&nss_policyf_ptrs, (size_t)sizeof (nss_policyf_t) },

	{ NULL,	NSS_CONFIG_ADD,	(mutex_t *)NULL, (void *)NULL, (size_t)0 },

};

/*

 * NSS parameter configuration routines

 */

/* compare config name (component:parameter) to a component name */

static int

nss_cfgcn_cmp(const char *cfgname, const char *compname)

{

	char *c;

	size_t len, len2;

	/* this code assumes valid pointers */

	if ((c = strchr(cfgname, NSS_CONFIG_BRK)) == NULL)

		return (-1);

	len = (size_t)(c - cfgname);

	len2 = strlen(compname);

	if (len2 != len)

		return (-1);

	return (strncmp(cfgname, compname, len));

}

/* init configuration arena */

static int

nss_cfg_init()

{

	int i;

	/* First time caller? */

	if (nss_cfg != NULL)

		return (0);

	/* Initialize internal tables */

	lmutex_lock(&nss_cfglock);

	if (nss_cfg != NULL) {

		lmutex_unlock(&nss_cfglock);

		return (0);

	}

	nss_cfg = (nss_cfglist_t *)libc_malloc(NSS_CFG_INCR *

					    sizeof (nss_cfglist_t));

	if (nss_cfg == (nss_cfglist_t *)NULL) {

		errno = ENOMEM;

		lmutex_unlock(&nss_cfglock);

		return (-1);

	}

	nss_cfgmax = NSS_CFG_INCR;

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

		nss_cfg[i].list = (nss_cfgparam_t *)libc_malloc(NSS_CFG_INCR *

					sizeof (nss_cfgparam_t));

		if (nss_cfg[i].list == (nss_cfgparam_t *)NULL) {

			errno = ENOMEM;

			lmutex_unlock(&nss_cfglock);

			return (-1);

		}

		nss_cfg[i].max = NSS_CFG_INCR;

	}

	/* Initialize Policy Engine values */

	lmutex_unlock(&nss_cfglock);

	if (nss_cfg_policy_init() < 0) {

		return (-1);

	}

	return (0);

}

/* find the name'd component list - create it if non-existent */

static nss_cfglist_t *

nss_cfgcomp_get(char *name, int add)

{

	nss_cfglist_t	*next;

	char	*c;

	int	i, len;

	size_t	nsize;

	/* Make sure system is init'd */

	if (nss_cfg == NULL && nss_cfg_init() < 0)

		return ((nss_cfglist_t *)NULL);

	/* and check component:name validity */

	if (name == NULL || (c = strchr(name, NSS_CONFIG_BRK)) == NULL)

		return ((nss_cfglist_t *)NULL);

	lmutex_lock(&nss_cfglock);

	next = nss_cfg;

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

		if (next->name && nss_cfgcn_cmp(name, next->name) == 0) {

			lmutex_unlock(&nss_cfglock);

			return (next);

		}

		next++;

	}

	if (!add) {

		lmutex_unlock(&nss_cfglock);

		return (NULL);

	}

	/* not found, create a fresh one */

	if (nss_cfgcount >= nss_cfgmax) {

		/* realloc first */

		nsize = (nss_cfgmax + NSS_CFG_INCR) * sizeof (nss_cfgparam_t);

		next = (nss_cfglist_t *)libc_realloc(nss_cfg, nsize);

		if (next == NULL) {

			errno = ENOMEM;

			lmutex_unlock(&nss_cfglock);

			return ((nss_cfglist_t *)NULL);

		}

		(void) memset((void *)(next + nss_cfgcount), '\0',

			NSS_CFG_INCR * sizeof (nss_cfglist_t));

		nss_cfgmax += NSS_CFG_INCR;

		nss_cfg = next;

	}

	next = nss_cfg + nss_cfgcount;

	len = (size_t)(c - name) + 1;

	if ((next->name = libc_malloc(len)) == NULL) {

		errno = ENOMEM;

		lmutex_unlock(&nss_cfglock);

		return ((nss_cfglist_t *)NULL);

	}

	nss_cfgcount++;

	(void) strlcpy(next->name, name, len);

	lmutex_unlock(&nss_cfglock);

	return (next);

}

/* find the name'd parameter - create it if non-existent */

static nss_cfgparam_t *

nss_cfgparam_get(char *name, int add)

{

	nss_cfglist_t	*comp;

	nss_cfgparam_t	*next;

	int	count, i;

	size_t	nsize;

	if ((comp = nss_cfgcomp_get(name, add)) == NULL)

		return ((nss_cfgparam_t *)NULL);

	lmutex_lock(&nss_cfglock);

	count = comp->count;

	next = comp->list;

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

		if (next->name && strcmp(name, next->name) == 0) {

			lmutex_unlock(&nss_cfglock);

			return (next);

		}

		next++;

	}

	if (!add) {

		lmutex_unlock(&nss_cfglock);

		return (NULL);

	}

	/* not found, create a fresh one */

	if (count >= comp->max) {

		/* realloc first */

		nsize = (comp->max + NSS_CFG_INCR) * sizeof (nss_cfgparam_t);

		next = (nss_cfgparam_t *)libc_realloc(comp->list, nsize);

		if (next == NULL) {

			errno = ENOMEM;

			lmutex_unlock(&nss_cfglock);

			return ((nss_cfgparam_t *)NULL);

		}

		comp->max += NSS_CFG_INCR;

		comp->list = next;

	}

	next = comp->list + comp->count;

	if ((next->name = libc_strdup(name)) == NULL) {

		errno = ENOMEM;

		lmutex_unlock(&nss_cfglock);

		return ((nss_cfgparam_t *)NULL);

	}

	comp->count++;

	lmutex_unlock(&nss_cfglock);

	return (next);

}

/* find the name'd parameter - delete it if it exists */

static void

nss_cfg_del(nss_config_t *cfgp)

{

	char		*name;

	nss_cfglist_t	*comp;

	nss_cfgparam_t	*next, *cur;

	int	count, i, j;

	/* exit if component name does not already exist */

	if ((name = cfgp->name) == NULL ||

	    (comp = nss_cfgcomp_get(name, 0)) == NULL)

		return;

	/* find it */

	lmutex_lock(&nss_cfglock);

	count = comp->count;

	next = comp->list;

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

		if (next->name && strcmp(name, next->name) == 0) {

			break;	/* found it... */

		}

		next++;

	}

	if (i >= count) {

		/* not found, already deleted */

		lmutex_unlock(&nss_cfglock);

		return;

	}

	/* copy down the remaining parameters, and clean up */

	/* don't try to clean up component tables */

	cur = next;

	next++;

	for (j = i+1; j < count; j++) {

		*cur = *next;

		cur++;

		next++;

	}

	/* erase the last one */

	if (cur->name) {

		libc_free(cur->name);

		cur->name = (char *)NULL;

	}

	cur->lock = (mutex_t *)NULL;

	cur->buffer = (void *)NULL;

	cur->length = 0;

	comp->count--;

	lmutex_unlock(&nss_cfglock);

}

static int