/*

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

 */

#include "lint.h"

#include <mtlib.h>

#include <ctype.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <nss_dbdefs.h>

#include <limits.h>

#include <dlfcn.h>

#include <link.h>

#include <thread.h>

#include <atomic.h>

/* headers for key2str/str2key routines */

#include <sys/ethernet.h>

#include <exec_attr.h>

#include <grp.h>

/*

 * functions in nss_dbdefs.c deal more with the mechanics of

 * the data structures like nss_XbyY_args_t and the interaction

 * with the packed buffers etc.  versus the mechanics of the

 * actual policy component operations such as nss_search sequencing.

 */

/*

 * ALIGN? is there an official definition of this?

 * We use sizeof(long) to cover what we want

 * for both the 32-bit world and 64-bit world.

 */

#define	ALIGN(x) ((((long)(x)) + sizeof (long) - 1) & ~(sizeof (long) - 1))

nss_XbyY_buf_t *

_nss_XbyY_buf_alloc(int struct_size, int buffer_size)

{

	nss_XbyY_buf_t	*b;

	/* Use one malloc for dbargs, result struct and buffer */

	b = (nss_XbyY_buf_t *)

	    malloc(ALIGN(sizeof (*b)) + struct_size + buffer_size);

	if (b == 0) {

		return (0);

	}

	b->result = (void *)ALIGN(&b[1]);

	b->buffer = (char *)(b->result) + struct_size;

	b->buflen = buffer_size;

	return (b);

}

void

_nss_XbyY_buf_free(nss_XbyY_buf_t *b)

{

	if (b != 0) {

		free(b);

	}

}

/* === Comment:  used by fget{gr,pw,sp}ent */

/* ==== Should do ye olde syslog()ing of suspiciously long lines */

void

_nss_XbyY_fgets(FILE *f, nss_XbyY_args_t *b)

{

	char		buf[LINE_MAX];

	int		len, parsestat;

	if (fgets(buf, LINE_MAX, f) == 0) {

		/* End of file */

		b->returnval = 0;

		b->erange    = 0;

		return;

	}

	len = (int)strlen(buf);

	/* len >= 0 (otherwise we would have got EOF) */

	if (buf[len - 1] != '\n') {

		if ((len + 1) == LINE_MAX) {

			/* Line too long for buffer; too bad */

			while (fgets(buf, LINE_MAX, f) != 0 &&

			    buf[strlen(buf) - 1] != '\n') {

				;

			}

			b->returnval = 0;

			b->erange    = 1;

			return;

		}

		/* case where the file is not terminated with a Newline */

		len++;

	}

	parsestat = (*b->str2ent)(buf, (len - 1), b->buf.result, b->buf.buffer,

	    b->buf.buflen);

	if (parsestat == NSS_STR_PARSE_ERANGE) {

		b->returnval = 0;

		b->erange    = 1;

	} else if (parsestat == NSS_STR_PARSE_SUCCESS) {

		b->returnval = b->buf.result;

	}

}

/*

 * parse the aliases string into the buffer and if successful return

 * a char ** pointer to the beginning of the aliases.

 *

 * CAUTION: (instr, instr+lenstr) and (buffer, buffer+buflen) are

 * non-intersecting memory areas. Since this is an internal interface,

 * we should be able to live with that.

 */

char **

_nss_netdb_aliases(const char *instr, int lenstr, char *buffer, int buflen)

	/* "instr" is the beginning of the aliases string */

	/* "buffer" has the return val for success */

	/* "buflen" is the length of the buffer available for aliases */

{

	/*

	 * Build the alias-list in the start of the buffer, and copy

	 * the strings to the end of the buffer.

	 */

	const char

		*instr_limit	= instr + lenstr;

	char	*copyptr	= buffer + buflen;

	char	**aliasp	= (char **)ROUND_UP(buffer, sizeof (*aliasp));

	char	**alias_start	= aliasp;

	int	nstrings	= 0;

	for (;;) {

		const char	*str_start;

		size_t		str_len;

		while (instr < instr_limit && isspace(*instr)) {

			instr++;

		}

		if (instr >= instr_limit || *instr == '#') {

			break;

		}

		str_start = instr;

		while (instr < instr_limit && !isspace(*instr)) {

			instr++;

		}

		++nstrings;

		str_len = instr - str_start;

		copyptr -= str_len + 1;

		if (copyptr <= (char *)(&aliasp[nstrings + 1])) {

			/* Has to be room for the pointer to */

			/* the alias we're about to add,   */

			/* as well as the final NULL ptr.  */

			return (0);

		}

		*aliasp++ = copyptr;

		(void) memcpy(copyptr, str_start, str_len);

		copyptr[str_len] = '\0';

	}

	*aliasp++ = 0;

	return (alias_start);

}

extern nss_status_t process_cstr(const char *, int, struct nss_groupsbymem *);

/*

 * pack well known getXbyY keys to packed buffer prior to the door_call

 * to nscd.  Some consideration is given to ordering the tests based on

 * usage.  Note: buf is nssuint_t aligned.

 */

typedef struct {

	const char	*name;		/* NSS_DBNAM_* */

	const char	*defconf;	/* NSS_DEFCONF_* */

	const char	*initfn;	/* init function name */

	const char	*strfn;		/* str2X function name */

	const char	*cstrfn;	/* cstr2X function name */

	void		*initfnp;	/* init function pointer */

	void		*strfnp;	/* str2X function pointer */

	uint32_t	dbop;		/* NSS_DBOP_* */

	const char	*tostr;		/* key2str cvt str */

} getXbyY_to_dbop_t;

#define	NSS_MK_GETXYDBOP(x, y, f, e)	\

	{ NSS_DBNAM_##x, NSS_DEFCONF_##x, "_nss_initf_" f, "str2" f, \

		NULL, NULL, NULL, NSS_DBOP_##x##_##y, (e) }

#define	NSS_MK_GETXYDBOPA(x, a, f, e)	\

	{ NSS_DBNAM_##x, NSS_DEFCONF_##x, "_nss_initf_" f, "str2" f, \

		NULL, NULL, NULL, NSS_DBOP_##a, (e) }

#define	NSS_MK_GETXYDBOPB(x, b, a, f, s, e)	\

	{ NSS_DBNAM_##x, NSS_DEFCONF_##b, "_nss_initf_" f, s,  \

		NULL, NULL, NULL, NSS_DBOP_##a, (e) }

#define	NSS_MK_GETXYDBOPC(x, a, f, s, e)	\

	{ NSS_DBNAM_##x, NSS_DEFCONF_##x, "_nss_initf_" f, s, \

		NULL, NULL, NULL, NSS_DBOP_##x##_##a, (e) }

#define	NSS_MK_GETXYDBOPD(x, y, i, f, e)	\

	{ NSS_DBNAM_##x, NSS_DEFCONF_##x, "_nss_initf_" i, "str2" f, \

		NULL, NULL, NULL, NSS_DBOP_##x##_##y, (e) }

#define	NSS_MK_GETXYDBOPCSTR(x, a, f, s, e)	\

	{ NSS_DBNAM_##x, NSS_DEFCONF_##x, "_nss_initf_" f, s, \

		"process_cstr", NULL, NULL, NSS_DBOP_##x##_##a, (e) }

/*

 * The getXbyY_to_dbop structure is hashed on first call in order to

 * reduce the search time for the well known getXbyY operations.

 * A binary search was not fast enough.  There were on average

 * 3-4 tests (strcmps) per getXbyY call.

 *

 * DBOP_PRIME_HASH must be a prime number (reasonably small) but that

 * is sufficient to uniquely map the entries in the following table

 * without collision.

 *

 * The DBOP_PRIME_HASH was selected as the smallest hash value

 * for this table without collisions. Changing this table WILL

 * necessitate re-testing for possible collisions.

 */

#define	DBOP_PRIME_HASH		227

#define	DBOP_HASH_TAG		0xf0000000

static int getXbyYdbopHASH[DBOP_PRIME_HASH] = { 0 };

static mutex_t getXbydbop_hash_lock = DEFAULTMUTEX;

static int getXbyYdbop_hashed = 0;

/*

 * If the size of getXbyY_to_dbop[] is changed then hash function must be

 * corrected to be without collisions in nss_dbop_search().

 */

static getXbyY_to_dbop_t getXbyY_to_dbop[] = {

	/* NSS_MK_GETXYDBOP(ALIASES, ?, ?), */

	NSS_MK_GETXYDBOPD(AUDITUSER, BYNAME, "auuser", "audituser", "n"),

	NSS_MK_GETXYDBOP(AUTHATTR, BYNAME, "authattr", "n"),

	/* NSS_MK_GETXYDBOP(AUTOMOUNT, ?, ?), */

	NSS_MK_GETXYDBOP(BOOTPARAMS, BYNAME, "bootparams", "n"),

	NSS_MK_GETXYDBOPC(ETHERS, HOSTTON, "ethers", "str2ether", "n"),

	NSS_MK_GETXYDBOPC(ETHERS, NTOHOST, "ethers", "str2ether", "e"),

	NSS_MK_GETXYDBOP(EXECATTR, BYNAME, "execattr", "A"),

	NSS_MK_GETXYDBOP(EXECATTR, BYID, "execattr", "A"),

	NSS_MK_GETXYDBOP(EXECATTR, BYNAMEID, "execattr", "A"),

	NSS_MK_GETXYDBOP(GROUP, BYNAME, "group", "n"),

	NSS_MK_GETXYDBOP(GROUP, BYGID, "group", "g"),

	NSS_MK_GETXYDBOPCSTR(GROUP, BYMEMBER, "group", "str2group", "I"),

	NSS_MK_GETXYDBOPC(HOSTS, BYNAME, "hosts", "str2hostent", "n"),

	NSS_MK_GETXYDBOPC(HOSTS, BYADDR, "hosts", "str2hostent", "h"),

	NSS_MK_GETXYDBOPC(IPNODES, BYNAME, "ipnodes", "str2hostent", "i"),

	NSS_MK_GETXYDBOPC(IPNODES, BYADDR, "ipnodes", "str2hostent", "h"),

	NSS_MK_GETXYDBOP(NETGROUP, IN, "netgroup", "t"),

	NSS_MK_GETXYDBOP(NETGROUP, SET, "netgroup", "T"),

	NSS_MK_GETXYDBOPC(NETMASKS, BYNET, "netmasks", "str2addr", "n"),

	NSS_MK_GETXYDBOPC(NETWORKS, BYNAME, "net", "str2netent", "n"),

	NSS_MK_GETXYDBOPC(NETWORKS, BYADDR, "net", "str2netent", "a"),

	NSS_MK_GETXYDBOP(PASSWD, BYNAME, "passwd", "n"),

	NSS_MK_GETXYDBOP(PASSWD, BYUID, "passwd", "u"),

	NSS_MK_GETXYDBOP(PRINTERS, BYNAME, "printers", "n"),

	NSS_MK_GETXYDBOP(PROFATTR, BYNAME, "profattr", "n"),

	NSS_MK_GETXYDBOP(PROJECT, BYNAME, "project", "n"),

	NSS_MK_GETXYDBOP(PROJECT, BYID, "project", "p"),

	NSS_MK_GETXYDBOPC(PROTOCOLS, BYNAME, "proto", "str2protoent", "n"),

	NSS_MK_GETXYDBOPC(PROTOCOLS, BYNUMBER, "proto", "str2protoent", "N"),

	NSS_MK_GETXYDBOPA(PUBLICKEY, KEYS_BYNAME, "publickey", "k"),

	NSS_MK_GETXYDBOPC(RPC, BYNAME, "rpc", "str2rpcent", "n"),

	NSS_MK_GETXYDBOPC(RPC, BYNUMBER, "rpc", "str2rpcent", "N"),

	NSS_MK_GETXYDBOPC(SERVICES, BYNAME, "services", "str2servent", "s"),

	NSS_MK_GETXYDBOPC(SERVICES, BYPORT, "services", "str2servent", "S"),

	NSS_MK_GETXYDBOPB(SHADOW, PASSWD, PASSWD_BYNAME, "shadow",

				"str2spwd", "n"),

	NSS_MK_GETXYDBOPC(TSOL_RH, BYADDR, "tsol_rh", "str_to_rhstr", "h"),

	NSS_MK_GETXYDBOPC(TSOL_TP, BYNAME, "tsol_tp", "str_to_tpstr", "n"),

	NSS_MK_GETXYDBOPC(TSOL_ZC, BYNAME, "tsol_zc", "str_to_zcstr", "n"),

	NSS_MK_GETXYDBOP(USERATTR, BYNAME, "userattr", "n"),

};

static int

nss_dbop_search(const char *name, uint32_t dbop)

{

	getXbyY_to_dbop_t *hptr;

	int count = (sizeof (getXbyY_to_dbop) / sizeof (getXbyY_to_dbop_t));

	uint32_t hval, g;

	const char *cp;

	int i, idx;

	static const uint32_t hbits_tst = 0xf0000000;

	/* Uses a table size is known to have no collisions */

	if (getXbyYdbop_hashed == 0) {

		lmutex_lock(&getXbydbop_hash_lock);

		if (getXbyYdbop_hashed == 0) {

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

				cp = getXbyY_to_dbop[i].name;

				hval = 0;

				while (*cp) {

					hval = (hval << 4) + *cp++;

					if ((g = (hval & hbits_tst)) != 0)

						hval ^= g >> 24;

					hval &= ~g;

				}

				hval += getXbyY_to_dbop[i].dbop;

				hval %= DBOP_PRIME_HASH;

				if (getXbyYdbopHASH[hval] != 0) {

					/* hash table collision-see above */

					lmutex_unlock(&getXbydbop_hash_lock);

					return (-1);

				}

				getXbyYdbopHASH[hval] = i | DBOP_HASH_TAG;

			}

			membar_producer();

			getXbyYdbop_hashed = 1;

		}

		lmutex_unlock(&getXbydbop_hash_lock);

	}

	membar_consumer();

	cp = name;

	hval = 0;

	while (*cp) {

		hval = (hval << 4) + *cp++;

		if ((g = (hval & hbits_tst)) != 0)

			hval ^= g >> 24;

		hval &= ~g;

	}

	hval += dbop;

	hval %= DBOP_PRIME_HASH;

	idx = getXbyYdbopHASH[hval];

	if ((idx & DBOP_HASH_TAG) != DBOP_HASH_TAG)

		return (-1);

	idx &= ~DBOP_HASH_TAG;

	if (idx >= count)

		return (-1);

	hptr = &getXbyY_to_dbop[idx];

	if (hptr->dbop != dbop || strcmp(name, hptr->name) != 0)

		return (-1);

	return (idx);

}

/*

 * nss_pack_key2str

 * Private key to string packing function for getXbyY routines

 * This routine performs a printf like parse over the argument

 * key, given a string of items to pack and assembles the key in

 * the packed structure.  This routine is called (currently) by

 * nss_default_key2str, but will be used by other external

 * APIs in the future.

 *

 * buffer - Start of the key buffer location [in packed buffer]

 * length - Length of key buffer component

 * Key offsets are relative to start of key buffer location.

 *

 * Pack fields			Key

 *   key.name			n

 *   key.number			N

 *   key.uid			u

 *   key.gid			g

 *   key.hostaddr		h

 *   key.ipnode			i

 *   key.projid			p

 *   key.serv(name)		s

 *   key.serv(port)		S

 *   key.ether			e

 *   key.pkey			k

 *   key.netaddr		a

 *   key.attrp			A

 *   groupsbymember		I

 *   innetgr_args		t

 *   setnetgr_args		T

 */

/*ARGSUSED*/

static nss_status_t

nss_pack_key2str(void *buffer, size_t length, nss_XbyY_args_t *arg,

	const char *dbname, int dbop, size_t *rlen, const char *typestr)

{

	int				i, j;

	size_t				len, len2, len3, len4, len5, slop;

	nssuint_t 			*uptr, offv, offc;

	struct nss_setnetgrent_args	*sng;

	struct nss_innetgr_args		*ing;

	struct nss_groupsbymem		*gbm;

	char				**cv, *dptr;

	nss_pnetgr_t			*pptr;

	_priv_execattr			*pe;

	if (buffer == NULL || length == 0 || arg == NULL ||

	    dbname == NULL || rlen == NULL || typestr == NULL)

		return (NSS_ERROR);

	while (typestr && *typestr) {

		switch (*typestr++) {

		case 'n':

			if (arg->key.name == NULL)

				return (NSS_NOTFOUND);

			len = strlen(arg->key.name) + 1;

			if (len >= length)

				return (NSS_ERROR);

			(void) strlcpy(buffer, arg->key.name, len);

			*rlen = len;

			break;

		case 'N':

			len = sizeof (nssuint_t);

			if (len >= length)

				return (NSS_ERROR);

			*(nssuint_t *)buffer = (nssuint_t)arg->key.number;

			*rlen = len;

			break;

		case 'u':

			len = sizeof (nssuint_t);

			if (len >= length)

				return (NSS_ERROR);

			*(nssuint_t *)buffer = (nssuint_t)arg->key.uid;

			*rlen = len;

			break;

		case 'g':

			len = sizeof (nssuint_t);

			if (len >= length)

				return (NSS_ERROR);

			*(nssuint_t *)buffer = (nssuint_t)arg->key.gid;

			*rlen = len;

			break;

		case 'h':

			if (arg->key.hostaddr.addr == NULL)

				return (-1);

			len = arg->key.hostaddr.len;

			len = ROUND_UP(len, sizeof (nssuint_t));

			len2 = (sizeof (nssuint_t) * 2) + len;

			if (len2 >= length)

				return (NSS_ERROR);

			*(nssuint_t *)buffer =

			    (nssuint_t)arg->key.hostaddr.len;

			buffer = (void *)((char *)buffer + sizeof (nssuint_t));

			*(nssuint_t *)buffer =

			    (nssuint_t)arg->key.hostaddr.type;

			buffer = (void *)((char *)buffer + sizeof (nssuint_t));

			(void) memcpy(buffer, arg->key.hostaddr.addr,

			    arg->key.hostaddr.len);

			*rlen = len2;

			break;

		case 'i':

			if (arg->key.ipnode.name == NULL)

				return (NSS_NOTFOUND);

			len = strlen(arg->key.ipnode.name) + 1;

			len = ROUND_UP(len, sizeof (nssuint_t));

			len2 = (sizeof (nssuint_t) * 2) + len;

			if (len2 >= length)

				return (NSS_ERROR);

			*(nssuint_t *)buffer =

			    (nssuint_t)arg->key.ipnode.af_family;

			buffer = (void *)((char *)buffer + sizeof (nssuint_t));

			*(nssuint_t *)buffer =

			    (nssuint_t)arg->key.ipnode.flags;

			buffer = (void *)((char *)buffer + sizeof (nssuint_t));

			(void) strlcpy(buffer, arg->key.ipnode.name, len);

			*rlen = len2;

			break;

		case 'p':

			len = sizeof (nssuint_t);

			if (len >= length)

				return (NSS_ERROR);

			*(nssuint_t *)buffer = (nssuint_t)arg->key.projid;

			*rlen = len;

			break;

		case 's':

			if (arg->key.serv.serv.name == NULL)

				return (NSS_NOTFOUND);

			len = strlen(arg->key.serv.serv.name) + 1;

			len2 = 1;

			if (arg->key.serv.proto != NULL)

				len2 += strlen(arg->key.serv.proto);

			len3 = len + len2;

			len3 = ROUND_UP(len3, sizeof (nssuint_t));

			if (len3 >= length)

				return (NSS_ERROR);

			(void) strlcpy(buffer, arg->key.serv.serv.name, len);

			buffer = (void *)((char *)buffer + len);

			if (len2 > 1)

				(void) strlcpy(buffer, arg->key.serv.proto,

				    len2);

			else

				*(char *)buffer = '\0';

			*rlen = len3;

			break;

		case 'S':