minix/lib/nbsd_libc/gen/getgroupmembership.c

/*	$NetBSD: getgroupmembership.c,v 1.4 2008/04/28 20:22:59 martin Exp $	*/

/*-
 * Copyright (c) 2004-2005 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Luke Mewburn.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
__RCSID("$NetBSD: getgroupmembership.c,v 1.4 2008/04/28 20:22:59 martin Exp $");
#endif /* LIBC_SCCS and not lint */

/*
 * calculate group access list
 */

#include "namespace.h"
#include "reentrant.h"

#include <sys/param.h>

#include <assert.h>
#include <errno.h>
#include <grp.h>
#include <limits.h>
#include <nsswitch.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#ifdef HESIOD
#include <hesiod.h>
#endif

#include "gr_private.h"

#ifdef __weak_alias
__weak_alias(getgroupmembership,_getgroupmembership)
#endif

/*
 * __gr_addgid
 *	Add gid to the groups array (of maxgrp size) at the position
 *	indicated by *groupc, unless it already exists or *groupc is
 *	past &groups[maxgrp].
 *	Returns 1 upon success (including duplicate suppression), 0 otherwise.
 */
static int
__gr_addgid(gid_t gid, gid_t *groups, int maxgrp, int *groupc)
{
	int	ret, dupc;

	_DIAGASSERT(groupc != NULL);
	_DIAGASSERT(groups != NULL);

						/* skip duplicates */
	for (dupc = 0; dupc < MIN(maxgrp, *groupc); dupc++) {
		if (groups[dupc] == gid)
			return 1;
	}

	ret = 1;
	if (*groupc < maxgrp)			/* add this gid */
		groups[*groupc] = gid;
	else
		ret = 0;
	(*groupc)++;
	return ret;
}


/*ARGSUSED*/
static int
_files_getgroupmembership(void *retval, void *cb_data, va_list ap)
{
	int		*result	= va_arg(ap, int *);
	const char 	*uname	= va_arg(ap, const char *);
#ifdef __minix
	gid_t		 agroup = (gid_t)va_arg(ap, int);
#else
	gid_t		 agroup	= va_arg(ap, gid_t);
#endif
	gid_t		*groups	= va_arg(ap, gid_t *);
	int		 maxgrp	= va_arg(ap, int);
	int		*groupc	= va_arg(ap, int *);

	struct __grstate_files	state;
	struct group		grp;
	char			grpbuf[_GETGR_R_SIZE_MAX];
	int			rv, i;

	_DIAGASSERT(result != NULL);
	_DIAGASSERT(uname != NULL);
	/* groups may be NULL if just sizing when invoked with maxgrp = 0 */
	_DIAGASSERT(groupc != NULL);

						/* install primary group */
	(void) __gr_addgid(agroup, groups, maxgrp, groupc);

	memset(&state, 0, sizeof(state));
	while (__grscan_files(&rv, &grp, grpbuf, sizeof(grpbuf), &state,
				0, NULL, 0) == NS_SUCCESS) {
						/* scan members */
		for (i = 0; grp.gr_mem[i]; i++) {
			if (strcmp(grp.gr_mem[i], uname) != 0)
				continue;
			if (! __gr_addgid(grp.gr_gid, groups, maxgrp, groupc))
				*result = -1;
			break;
		}
	}
	__grend_files(&state);
	return NS_NOTFOUND;
}


#ifdef HESIOD

/*ARGSUSED*/
static int
_dns_getgroupmembership(void *retval, void *cb_data, va_list ap)
{
	int		*result	= va_arg(ap, int *);
	const char 	*uname	= va_arg(ap, const char *);
#ifdef __minix
	gid_t		 agroup = (gid_t)va_arg(ap, int);
#else
	gid_t		 agroup	= va_arg(ap, gid_t);
#endif
	gid_t		*groups	= va_arg(ap, gid_t *);
	int		 maxgrp	= va_arg(ap, int);
	int		*groupc	= va_arg(ap, int *);

	struct __grstate_dns	state;
	struct group		grp;
	char			grpbuf[_GETGR_R_SIZE_MAX];
	unsigned long		id;
	void			*context;
	char			**hp, *cp, *ep;
	int			rv, i;

	_DIAGASSERT(result != NULL);
	_DIAGASSERT(uname != NULL);
	/* groups may be NULL if just sizing when invoked with maxgrp = 0 */
	_DIAGASSERT(groupc != NULL);

						/* install primary group */
	(void) __gr_addgid(agroup, groups, maxgrp, groupc);

	hp = NULL;
	rv = NS_NOTFOUND;

	if (hesiod_init(&context) == -1)		/* setup hesiod */
		return NS_UNAVAIL;

	hp = hesiod_resolve(context, uname, "grplist");	/* find grplist */
	if (hp == NULL) {
		if (errno != ENOENT) {			/* wasn't "not found"*/
			rv = NS_UNAVAIL;
			goto dnsgroupmembers_out;
		}
			/* grplist not found, fallback to _dns_grscan */
		memset(&state, 0, sizeof(state));
		while (__grscan_dns(&rv, &grp, grpbuf, sizeof(grpbuf), &state,
					0, NULL, 0) == NS_SUCCESS) {
							/* scan members */
			for (i = 0; grp.gr_mem[i]; i++) {
				if (strcmp(grp.gr_mem[i], uname) != 0)
					continue;
				if (! __gr_addgid(grp.gr_gid, groups, maxgrp,
				    groupc))
					*result = -1;
				break;
			}
		}
		__grend_dns(&state);
		rv = NS_NOTFOUND;
		goto dnsgroupmembers_out;
	}

	if ((ep = strchr(hp[0], '\n')) != NULL)
		*ep = '\0';				/* clear trailing \n */

	for (cp = hp[0]; *cp != '\0'; ) {		/* parse grplist */
		if ((cp = strchr(cp, ':')) == NULL)	/* skip grpname */
			break;
		cp++;
		id = strtoul(cp, &ep, 10);		/* parse gid */
		if (id > GID_MAX || (*ep != ':' && *ep != '\0')) {
			rv = NS_UNAVAIL;
			goto dnsgroupmembers_out;
		}
		cp = ep;
		if (*cp == ':')
			cp++;

							/* add gid */
		if (! __gr_addgid((gid_t)id, groups, maxgrp, groupc))
			*result = -1;
	}

	rv = NS_NOTFOUND;

 dnsgroupmembers_out:
	if (hp)
		hesiod_free_list(context, hp);
	hesiod_end(context);
	return rv;
}

#endif /* HESIOD */


#ifdef YP

/*ARGSUSED*/
static int
_nis_getgroupmembership(void *retval, void *cb_data, va_list ap)
{
	int		*result	= va_arg(ap, int *);
	const char 	*uname	= va_arg(ap, const char *);
#ifdef __minix
	gid_t		 agroup = (gid_t)va_arg(ap, int);
#else
	gid_t		 agroup	= va_arg(ap, gid_t);
#endif
	gid_t		*groups	= va_arg(ap, gid_t *);
	int		 maxgrp	= va_arg(ap, int);
	int		*groupc	= va_arg(ap, int *);

	struct __grstate_nis	state;
	struct group		grp;
	char			grpbuf[_GETGR_R_SIZE_MAX];
	int			rv, i;

	_DIAGASSERT(result != NULL);
	_DIAGASSERT(uname != NULL);
	/* groups may be NULL if just sizing when invoked with maxgrp = 0 */
	_DIAGASSERT(groupc != NULL);

						/* install primary group */
	(void) __gr_addgid(agroup, groups, maxgrp, groupc);

	memset(&state, 0, sizeof(state));
	while (__grscan_nis(&rv, &grp, grpbuf, sizeof(grpbuf), &state,
				0, NULL, 0) == NS_SUCCESS) {
						/* scan members */
		for (i = 0; grp.gr_mem[i]; i++) {
			if (strcmp(grp.gr_mem[i], uname) != 0)
				continue;
			if (! __gr_addgid(grp.gr_gid, groups, maxgrp, groupc))
				*result = -1;
			break;
		}
	}
	__grend_nis(&state);

	return NS_NOTFOUND;
}

#endif /* YP */


#ifdef _GROUP_COMPAT

struct __compatggm {
	const char	*uname;		/* user to search for */
	gid_t		*groups;
	gid_t		 agroup;
	int		 maxgrp;
	int		*groupc;
};

static int
_compat_ggm_search(void *cookie, struct group **groupres)
{
	struct __compatggm	*cp;
	int			rerror, crv;

	static const ns_dtab dtab[] = {
		NS_FILES_CB(__grbad_compat, "files")
		NS_DNS_CB(_dns_getgroupmembership, NULL)
		NS_NIS_CB(_nis_getgroupmembership, NULL)
		NS_COMPAT_CB(__grbad_compat, "compat")
		NS_NULL_CB
	};

	*groupres = NULL;	/* we don't care about this */
	cp = (struct __compatggm *)cookie;

	crv = nsdispatch(NULL, dtab,
	    NSDB_GROUP_COMPAT, "getgroupmembership",
	    __nsdefaultnis,
#ifdef __minix
	    &rerror, cp->uname, (int)cp->agroup, cp->groups, cp->maxgrp, cp->groupc);
#else
	    &rerror, cp->uname, cp->agroup, cp->groups, cp->maxgrp, cp->groupc);

#endif
	if (crv == NS_SUCCESS)
		crv = NS_NOTFOUND;	/* indicate "no more +: entries" */

	return crv;
}

/* ARGSUSED */
static int
_compat_getgroupmembership(void *retval, void *cb_data, va_list ap)
{
	int		*result	= va_arg(ap, int *);
	const char 	*uname	= va_arg(ap, const char *);
#ifdef __minix
	gid_t		 agroup = (gid_t)va_arg(ap, int);
#else
	gid_t		 agroup	= va_arg(ap, gid_t);
#endif
	gid_t		*groups	= va_arg(ap, gid_t *);
	int		 maxgrp	= va_arg(ap, int);
	int		*groupc	= va_arg(ap, int *);

	struct __grstate_compat	state;
	struct __compatggm	ggmstate;
	struct group		grp;
	char			grpbuf[_GETGR_R_SIZE_MAX];
	int			rv, i;

	_DIAGASSERT(result != NULL);
	_DIAGASSERT(uname != NULL);
	/* groups may be NULL if just sizing when invoked with maxgrp = 0 */
	_DIAGASSERT(groupc != NULL);

						/* install primary group */
	(void) __gr_addgid(agroup, groups, maxgrp, groupc);

	memset(&state, 0, sizeof(state));
	memset(&ggmstate, 0, sizeof(ggmstate));
	ggmstate.uname = uname;
	ggmstate.groups = groups;
	ggmstate.agroup = agroup;
	ggmstate.maxgrp = maxgrp;
	ggmstate.groupc = groupc;

	while (__grscan_compat(&rv, &grp, grpbuf, sizeof(grpbuf), &state,
				0, NULL, 0, _compat_ggm_search, &ggmstate)
		== NS_SUCCESS) {
						/* scan members */
		for (i = 0; grp.gr_mem[i]; i++) {
			if (strcmp(grp.gr_mem[i], uname) != 0)
				continue;
			if (! __gr_addgid(grp.gr_gid, groups, maxgrp, groupc))
				*result = -1;
			break;
		}
	}

	__grend_compat(&state);
	return NS_NOTFOUND;
}

#endif	/* _GROUP_COMPAT */


int
getgroupmembership(const char *uname, gid_t agroup,
    gid_t *groups, int maxgrp, int *groupc)
{
	int	rerror;

	static const ns_dtab dtab[] = {
		NS_FILES_CB(_files_getgroupmembership, NULL)
		NS_DNS_CB(_dns_getgroupmembership, NULL)
		NS_NIS_CB(_nis_getgroupmembership, NULL)
		NS_COMPAT_CB(_compat_getgroupmembership, NULL)
		NS_NULL_CB
	};

	_DIAGASSERT(uname != NULL);
	/* groups may be NULL if just sizing when invoked with maxgrp = 0 */
	_DIAGASSERT(groupc != NULL);

	*groupc = 0;

	mutex_lock(&__grmutex);
			/*
			 * Call each backend.
			 * For compatibility with getgrent(3) semantics,
			 * a backend should return NS_NOTFOUND even upon
			 * completion, to allow result merging to occur.
			 */
	(void) nsdispatch(NULL, dtab, NSDB_GROUP, "getgroupmembership",
	    __nsdefaultcompat,
#ifdef __minix
	    &rerror, uname, (int)agroup, groups, maxgrp, groupc);
#else
	    &rerror, uname, agroup, groups, maxgrp, groupc);
#endif
	mutex_unlock(&__grmutex);

	if (*groupc > maxgrp)			/* too many groups found */
		return -1;
	else
		return 0;
}