/*

 * 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 2009 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*

 * Shared code used by the name-service-switch frontends (e.g. getpwnam_r())

 */

#include "lint.h"

#include <mtlib.h>

#include <dlfcn.h>

#include <atomic.h>

#define	__NSS_PRIVATE_INTERFACE

#include "nsswitch_priv.h"

#undef	__NSS_PRIVATE_INTERFACE

#include <nss_common.h>

#include <nss_dbdefs.h>

#include <unistd.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <thread.h>

#include <synch.h>

#include <pthread.h>

#include <sys/types.h>

#include <sys/mman.h>

#include <errno.h>

#include "libc.h"

#include "tsd.h"

#include <getxby_door.h>

/*

 * configurable values for default buffer sizes

 */

/*

 * PSARC/2005/133 updated the buffering mechanisms to handle

 * up to 2^64 buffering.  But sets a practical limit of 512*1024.

 * The expectation is the practical limit will be dynamic from

 * nscd.  For now, set the group limit to this value.

 */

#define	NSS_BUFLEN_PRACTICAL	(512*1024)

static size_t __nss_buflen_group = NSS_BUFLEN_PRACTICAL;

static size_t __nss_buflen_default = NSS_BUFLEN_DOOR;

/*

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

 * The golden rule is:  if you hold a pointer to an nss_db_state struct and

 * you don't hold the lock, you'd better have incremented the refcount

 * while you held the lock;  otherwise, it may vanish or change

 * significantly when you least expect it.

 *

 * The pointer in nss_db_root_t is one such, so the reference count >= 1.

 * Ditto the pointer in struct nss_getent_context.

 */

/*

 * State for one nsswitch database (e.g. "passwd", "hosts")

 */

struct nss_db_state {

	nss_db_root_t		orphan_root;	/* XXX explain */

	unsigned		refcount;	/* One for the pointer in    */

						/*   nss_db_root_t, plus one */

						/*   for each active thread. */

	nss_db_params_t		p;

	struct __nsw_switchconfig_v1 *config;

	int			max_src;	/* is == config->num_lookups */

	struct nss_src_state	*src;		/* Pointer to array[max_src] */

};

/*

 * State for one of the sources (e.g. "nis", "compat") for a database

 */

struct nss_src_state {

	struct __nsw_lookup_v1	*lkp;

	int			n_active;

	int			n_dormant;

	int			n_waiting;	/* ... on wanna_be */

	cond_t			wanna_be;

	union {

		nss_backend_t	*single; /* Efficiency hack for common case */

					    /* when limit_dead_backends == 1 */

		nss_backend_t	**multi; /* array[limit_dead_backends] of */

	} dormant;			    /* pointers to dormant backends */

	nss_backend_constr_t	be_constr;

	nss_backend_finder_t	*finder;

	void			*finder_priv;

};

static struct nss_db_state	*_nss_db_state_constr(nss_db_initf_t);

void				_nss_db_state_destr(struct nss_db_state *);

/* ==== null definitions if !MTSAFE?  Ditto lock field in nss_db_root_t */

#define	NSS_ROOTLOCK(r, sp)	(cancel_safe_mutex_lock(&(r)->lock), \

				*(sp) = (r)->s)

#define	NSS_UNLOCK(r)		(cancel_safe_mutex_unlock(&(r)->lock))

#define	NSS_CHECKROOT(rp, s)	((s) != (*(rp))->s &&			\

			(cancel_safe_mutex_unlock(&(*(rp))->lock),	\

			cancel_safe_mutex_lock(&(s)->orphan_root.lock), \

			*(rp) = &(s)->orphan_root))

#define	NSS_RELOCK(rp, s)	(cancel_safe_mutex_lock(&(*(rp))->lock), \

			NSS_CHECKROOT(rp, s))

#define	NSS_STATE_REF_u(s)	(++(s)->refcount)

#define	NSS_UNREF_UNLOCK(r, s)	(--(s)->refcount != 0			\

			? ((void)NSS_UNLOCK(r))				\

			: ((void)NSS_UNLOCK(r), (void)_nss_db_state_destr(s)))

#define	NSS_LOCK_CHECK(r, f, sp)    (NSS_ROOTLOCK((r), (sp)),	\

				    *(sp) == 0 &&		\

				    (r->s = *(sp) = _nss_db_state_constr(f)))

/* === In the future, NSS_LOCK_CHECK() may also have to check that   */

/* === the config info hasn't changed (by comparing version numbers) */

/*

 * NSS_OPTIONS/NIS_OPTIONS environment varibles data definitions:

 * This remains for backwards compatibility.  But generally nscd will

 * decide if/how this gets used.

 */

static int checked_env = 0;		/* protected by "rootlock" */

	/* allowing __nss_debug_file to be set could be a security hole. */

FILE *__nss_debug_file = stdout;

int __nss_debug_eng_loop;

/* NIS_OPTIONS infrastructure (from linbsl/nis/cache/cache_api.cc) */

	/* allowing __nis_debug_file to be set could be a security hole. */

FILE *__nis_debug_file = stdout;

int __nis_debug_bind;

int __nis_debug_rpc;

int __nis_debug_calls;

char *__nis_prefsrv;

char *__nis_preftype;

char *__nis_server;   /* if set, use only this server for binding */

#define	OPT_INT 1

#define	OPT_STRING 2

#ifdef DEBUG

#define	OPT_FILE 3

#endif

struct option {

	char *name;

	int type;

	void *address;

};

static struct option nss_options[] = {

#ifdef DEBUG

	/* allowing __nss_debug_file to be set could be a security hole. */

	{ "debug_file", OPT_FILE, &__nss_debug_file },

#endif

	{ "debug_eng_loop", OPT_INT, &__nss_debug_eng_loop },

	{ 0, 0, 0 },

};

static struct option nis_options[] = {

#ifdef DEBUG

	/* allowing __nis_debug_file to be set could be a security hole. */

	{ "debug_file", OPT_FILE, &__nis_debug_file },

#endif

	{ "debug_bind", OPT_INT, &__nis_debug_bind },

	{ "debug_rpc", OPT_INT, &__nis_debug_rpc },

	{ "debug_calls", OPT_INT, &__nis_debug_calls },

	{ "server", OPT_STRING, &__nis_server },

	{ "pref_srvr", OPT_STRING, &__nis_prefsrv },

	{ "pref_type", OPT_STRING, &__nis_preftype },

	{ 0, 0, 0 },

};

/*

 * 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 = 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()

{

	nss_cfglist_t *cfg;

	int i;

	/* First time caller? */

	if (nss_cfg != NULL) {

		membar_consumer();

		return (0);

	}

	/* Initialize internal tables */

	lmutex_lock(&nss_cfglock);

	if (nss_cfg != NULL) {

		lmutex_unlock(&nss_cfglock);

		membar_consumer();

		return (0);

	}

	cfg = libc_malloc(NSS_CFG_INCR * sizeof (nss_cfglist_t));

	if (cfg == NULL) {

		errno = ENOMEM;

		lmutex_unlock(&nss_cfglock);

		return (-1);

	}

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

		cfg[i].list = libc_malloc(

		    NSS_CFG_INCR * sizeof (nss_cfgparam_t));

		if (cfg[i].list == NULL) {

			while (--i >= 0)

				libc_free(cfg[i].list);

			libc_free(cfg);

			errno = ENOMEM;

			lmutex_unlock(&nss_cfglock);

			return (-1);

		}

		cfg[i].max = NSS_CFG_INCR;

	}

	nss_cfgmax = NSS_CFG_INCR;

	membar_producer();

	nss_cfg = cfg;

	lmutex_unlock(&nss_cfglock);

	/* Initialize Policy Engine values */

	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_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;

	}