/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (the "License").  You may not use this file except in compliance

 * with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

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

#pragma weak endgrent = _endgrent

#pragma weak setgrent = _setgrent

#pragma weak getgrnam_r = _getgrnam_r

#pragma weak getgrgid_r = _getgrgid_r

#pragma weak getgrent_r = _getgrent_r

#pragma weak fgetgrent_r = _fgetgrent_r

#include "synonyms.h"

#include <mtlib.h>

#include <sys/types.h>

#include <grp.h>

#include <memory.h>

#include <nsswitch.h>

#include <nss_dbdefs.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <synch.h>

#include <sys/param.h>

#include <sys/mman.h>

#define	__NSS_PRIVATE_INTERFACE

#include "nsswitch_priv.h"

#undef	__NSS_PRIVATE_INTERFACE

extern int _getgroupsbymember(const char *, gid_t[], int, int);

int str2group(const char *, int, void *,

	char *, int);

static DEFINE_NSS_DB_ROOT(db_root);

static DEFINE_NSS_GETENT(context);

#define	USE_NETID_STR	"NETID_AUTHORITATIVE=TRUE"

void

_nss_initf_group(nss_db_params_t *p)

{

	p->name	= NSS_DBNAM_GROUP;

	p->default_config = NSS_DEFCONF_GROUP;

}

#include <getxby_door.h>

#include <sys/door.h>

static struct group *

process_getgr(struct group *result, char *buffer, int buflen,

    nsc_data_t *sptr, int ndata);

struct group *

_uncached_getgrnam_r(const char *name, struct group *result, char *buffer,

    int buflen);

struct group *

_uncached_getgrgid_r(gid_t gid, struct group *result, char *buffer, int buflen);

/*

 * POSIX.1c Draft-6 version of the function getgrnam_r.

 * It was implemented by Solaris 2.3.

 */

struct group *

_getgrnam_r(const char *name, struct group *result, char *buffer, int buflen)

{

	/*

	 * allocate room on the stack for the nscd to return

	 * group and group member information

	 */

	union {

		nsc_data_t	s_d;

		char		s_b[8192];

	} space;

	nsc_data_t	*sptr;

	int		ndata;

	int		adata;

	struct group	*resptr = NULL;

	if ((name == (const char *)NULL) ||

	    (strlen(name) >= (sizeof (space) - sizeof (nsc_data_t)))) {

		errno = ERANGE;

		return (NULL);

	}

	ndata = sizeof (space);

	adata = strlen(name) + sizeof (nsc_call_t) + 1;

	space.s_d.nsc_call.nsc_callnumber = GETGRNAM;

	(void) strcpy(space.s_d.nsc_call.nsc_u.name, name);

	sptr = &space.s_d;

	switch (_nsc_trydoorcall(&sptr, &ndata, &adata)) {

	case SUCCESS:	/* positive cache hit */

		break;

	case NOTFOUND:	/* negative cache hit */

		return (NULL);

	default:

		return ((struct group *)_uncached_getgrnam_r(name, result,

		    buffer, buflen));

	}

	resptr = process_getgr(result, buffer, buflen, sptr, ndata);

	/*

	 * check to see if doors reallocated memory underneath us

	 * if they did munmap the memory or suffer a memory leak

	 */

	if (sptr != &space.s_d)

		munmap((void *)sptr, ndata);

	return (resptr);

}

/*

 * POSIX.1c Draft-6 version of the function getgrgid_r.

 * It was implemented by Solaris 2.3.

 */

struct group *

_getgrgid_r(gid_t gid, struct group *result, char *buffer, int buflen)

{

	/*

	 * allocate room on the stack for the nscd to return

	 * group and group member information

	 */

	union {

		nsc_data_t	s_d;

		char		s_b[8192];

	} space;

	nsc_data_t	*sptr;

	int		ndata;

	int		adata;

	struct group	*resptr = NULL;

	ndata = sizeof (space);

	adata = sizeof (nsc_call_t) + 1;

	space.s_d.nsc_call.nsc_callnumber = GETGRGID;

	space.s_d.nsc_call.nsc_u.gid = gid;

	sptr = &space.s_d;

	switch (_nsc_trydoorcall(&sptr, &ndata, &adata)) {

	case SUCCESS:	/* positive cache hit */

		break;

	case NOTFOUND:	/* negative cache hit */

		return (NULL);

	default:

		return ((struct group *)_uncached_getgrgid_r(gid, result,

		    buffer, buflen));

	}

	resptr = process_getgr(result, buffer, buflen, sptr, ndata);

	/*

	 * check to see if doors reallocated memory underneath us

	 * if they did munmap the memory or suffer a memory leak

	 */

	if (sptr != &space.s_d)

		munmap((void *)sptr, ndata);

	return (resptr);

}

/*

 *  This routine should be rewritten - there's no reason it

 *  cannot be the same code for 32 and 64 bit w/ a bit of care.

 */

/* ARGSUSED4 */

static struct group *

process_getgr(struct group *result, char *buffer, int buflen,

    nsc_data_t *sptr, int ndata)

{

	int i;

	char *fixed;

#ifdef	_LP64

	char	*buffer32;

	char	**gr_mem32;

	uptr32_t	index;

	struct group	group64;

#endif	/*	_LP64	*/

/* align buffer on a pointer boundry 4bytes in 32bits and 8 bytes in 64bits */

#ifdef	_LP64

	fixed = (char *)(((uintptr_t)buffer + 7) & ~7);

#else

	fixed = (char *)(((uintptr_t)buffer + 3) & ~3);

#endif	/*	_LP64	*/

	if (buflen <= fixed - buffer) { /* watch out for wrap-around */

		errno = ERANGE;

		return (NULL);

	}

	buflen -= fixed - buffer;

	buffer = fixed;

#ifdef	_LP64

	/*

	 * this is just a rationality check; we need to make

	 * sure that there's enough space for the gr_mem array

	 * as well... easiest place to do that is when we copy

	 * them in place.

	 */

	if (sptr->nsc_ret.nsc_bufferbytesused +

		/*

		 * ^^^ number of bytes from nscd

		 */

	    (sizeof (char **)) +

		/*

		 * ^^^ we need 8 bytes for gr_mem

		 */

	    (sizeof (char *) - 1) -

		/*

		 * ^^^ plus space for pssibly fixing aligment of gr_mem

		 */

	    sizeof (group32_t)

		/*

		 * ^^^ because we don't put this in the usr buffer

		 */

	    > buflen) {

#else

	if (sptr->nsc_ret.nsc_bufferbytesused - sizeof (struct group)

	    > buflen) {

#endif	/*	_LP64	*/

		errno = ERANGE;

		return (NULL);

	}

	if (sptr->nsc_ret.nsc_return_code != SUCCESS)

		return (NULL);

/*

 * ncsd is a 32bit application, so use 32bit data items if we are in 64bit mode

 */

#ifdef	_LP64

	(void) memcpy(buffer,

	    (sptr->nsc_ret.nsc_u.buff + sizeof (group32_t)),

	    (sptr->nsc_ret.nsc_bufferbytesused - sizeof (group32_t)));

	group64.gr_name = (char *)(sptr->nsc_ret.nsc_u.grp.gr_name +

				(uintptr_t)buffer);

	group64.gr_passwd = (char *)(sptr->nsc_ret.nsc_u.grp.gr_passwd +

				(uintptr_t)buffer);

	group64.gr_gid = sptr->nsc_ret.nsc_u.grp.gr_gid;

	group64.gr_mem = (char **)((uintptr_t)buffer +

			sptr->nsc_ret.nsc_bufferbytesused - sizeof (group32_t));

	group64.gr_mem = (char **)(((uintptr_t)group64.gr_mem + 7) & ~7);

	gr_mem32 = (char **)(uintptr_t)sptr->nsc_ret.nsc_u.grp.gr_mem;

	buffer32 = buffer;

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

		index = *((uptr32_t *)

		    ((uintptr_t)gr_mem32 + (uintptr_t)buffer32));

		/*

		 * make sure there's enough space to copy the pointer...

		 */

		if (&group64.gr_mem[i + 1] >

		    (char **)((uintptr_t)buffer + buflen)) {

			errno = ERANGE;

			return (NULL);

		}

		if (index == 0)

			break;

		group64.gr_mem[i] = (char *)(index + buffer);

		buffer32 += sizeof (uptr32_t);

	}

	group64.gr_mem[i] = NULL;

	*result = group64;

#else

	(void) memcpy(buffer,

	    (sptr->nsc_ret.nsc_u.buff + sizeof (struct group)),

	    (sptr->nsc_ret.nsc_bufferbytesused - sizeof (struct group)));

	sptr->nsc_ret.nsc_u.grp.gr_name += (uintptr_t)buffer;

	sptr->nsc_ret.nsc_u.grp.gr_passwd += (uintptr_t)buffer;

	sptr->nsc_ret.nsc_u.grp.gr_mem =

	    (char **)((uintptr_t)sptr->nsc_ret.nsc_u.grp.gr_mem +

		(uintptr_t)buffer);

	i = 0;

	while (sptr->nsc_ret.nsc_u.grp.gr_mem[i]) {

		sptr->nsc_ret.nsc_u.grp.gr_mem[i] += (uintptr_t)buffer;

		i++;

	}

	*result = sptr->nsc_ret.nsc_u.grp;

#endif	/*	_LP64	*/

	return (result);

}

struct group *

_uncached_getgrgid_r(gid_t gid, struct group *result, char *buffer,

    int buflen)

{

	nss_XbyY_args_t arg;

	NSS_XbyY_INIT(&arg, result, buffer, buflen, str2group);

	arg.key.gid = gid;

	(void) nss_search(&db_root, _nss_initf_group,

				NSS_DBOP_GROUP_BYGID, &arg);

	return ((struct group *)NSS_XbyY_FINI(&arg));

}

/*

 * POSIX.1c standard version of the function getgrgid_r.

 * User gets it via static getgrgid_r from the header file.

 */

int

__posix_getgrgid_r(gid_t gid, struct group *grp, char *buffer,

    size_t bufsize, struct group **result)

{

	int nerrno = 0;

	int oerrno = errno;

	errno = 0;

	if ((*result = _getgrgid_r(gid, grp, buffer, (uintptr_t)bufsize))

		== NULL) {

			nerrno = errno;

	}

	errno = oerrno;

	return (nerrno);

}

extern struct group *

_getgrnam_r(const char *name, struct group *result, char *buffer,

	int buflen);

struct group *

_uncached_getgrnam_r(const char *name, struct group *result, char *buffer,

	int buflen)

{

	nss_XbyY_args_t arg;

	NSS_XbyY_INIT(&arg, result, buffer, buflen, str2group);

	arg.key.name = name;

	(void) nss_search(&db_root, _nss_initf_group,

			NSS_DBOP_GROUP_BYNAME, &arg);

	return ((struct group *)NSS_XbyY_FINI(&arg));

}

/*

 * POSIX.1c standard version of the function getgrnam_r.

 * User gets it via static getgrnam_r from the header file.

 */

int

__posix_getgrnam_r(const char *name, struct group *grp, char *buffer,

    size_t bufsize, struct group **result)

{

	int nerrno = 0;

	int oerrno = errno;

	if ((*result = _getgrnam_r(name, grp, buffer, (uintptr_t)bufsize))

		== NULL) {

			nerrno = errno;

	}

	errno = oerrno;

	return (nerrno);

}

void

setgrent(void)

{

	nss_setent(&db_root, _nss_initf_group, &context);

}

void

endgrent(void)

{

	nss_endent(&db_root, _nss_initf_group, &context);

	nss_delete(&db_root);

}

struct group *

getgrent_r(struct group *result, char *buffer, int buflen)

{

	nss_XbyY_args_t arg;

	char		*nam;

	/* In getXXent_r(), protect the unsuspecting caller from +/- entries */

	do {

		NSS_XbyY_INIT(&arg, result, buffer, buflen, str2group);

		/* No key to fill in */

		(void) nss_getent(&db_root, _nss_initf_group, &context, &arg);

	} while (arg.returnval != 0 &&

		(nam = ((struct group *)arg.returnval)->gr_name) != 0 &&

		(*nam == '+' || *nam == '-'));

	return ((struct group *)NSS_XbyY_FINI(&arg));

}

struct group *

fgetgrent_r(FILE *f, struct group *result, char *buffer, int buflen)

{

	extern void	_nss_XbyY_fgets(FILE *, nss_XbyY_args_t *);

	nss_XbyY_args_t	arg;

	/* ... but in fgetXXent_r, the caller deserves any +/- entry he gets */

	/* No key to fill in */

	NSS_XbyY_INIT(&arg, result, buffer, buflen, str2group);

	_nss_XbyY_fgets(f, &arg);

	return ((struct group *)NSS_XbyY_FINI(&arg));

}

/*

 * _getgroupsbymember(uname, gid_array, maxgids, numgids):

 *	Private interface for initgroups().  It returns the group ids of

 *	groups of which the specified user is a member.

 *

 * Arguments:

 *   username	Username of the putative member

 *   gid_array	Space in which to return the gids.  The first [numgids]

 *		elements are assumed to already contain valid gids.

 *   maxgids	Maximum number of elements in gid_array.

 *   numgids	Number of elements (normally 0 or 1) that already contain

 *		valid gids.

 * Return value:

 *   number of valid gids in gid_array (may be zero)

 *	or

 *   -1 (and errno set appropriately) on errors (none currently defined)

 */

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

int

_getgroupsbymember(const char *username, gid_t gid_array[],

    int maxgids, int numgids)

{

	struct nss_groupsbymem	arg;

	char defval[BUFSIZ];

	__NSL_FILE *defl;

	arg.username	= username;

	arg.gid_array	= gid_array;

	arg.maxgids	= maxgids;

	arg.numgids	= numgids;

	arg.str2ent	= str2group;

	arg.process_cstr = process_cstr;

	/*

	 * The old value being provided here was 0, ie do the quick

	 * way.  Given that this was never actually used under NIS

	 * and had the wrong (now corrected) meaning for NIS+ we need

	 * to change the default to be 1 (TRUE) as we now need the

	 * admin to decided to use netid, setting NETID_AUTHORITATIVE

	 * in /etc/default/nss to TRUE gets us a value of 0 for

	 * force_slow_way - don't you just love double negatives ;-)

	 *

	 * We need to do this to preserve the behaviour seen when the

	 * admin makes no changes.

	 */

	arg.force_slow_way = 1;

	/*

	 * The "easy" way to do /etc/default/nss is to use the defread()

	 * stuff from libcmd, but since we are in libc we don't want to

	 * link ourselfs against libcmd, so instead we just do it by hand

	 */

	if ((defl = __nsl_c_fopen(__NSW_DEFAULT_FILE, "r")) != NULL) {

		while (__nsl_c_fgets(defval, sizeof (defval), defl) != NULL) {

			if (strncmp(USE_NETID_STR, defval,

			    sizeof (USE_NETID_STR) - 1) == 0) {

				arg.force_slow_way = 0;

				break;

			}

		}

		(void) __nsl_c_fclose(defl);

	}

	(void) nss_search(&db_root, _nss_initf_group,

			NSS_DBOP_GROUP_BYMEMBER, &arg);

#ifdef	undef

	/*

	 * Only do this if there's existing code somewhere that relies on

	 *   initgroups() doing an endgrent() -- most unlikely.

	 */

	endgrent();

#endif	/* undef */

	return (arg.numgids);

}

static char *

gettok(char **nextpp, char sep)

{

	char	*p = *nextpp;