 @@ -1,1271 +1,1274 @@
-/*	$NetBSD: getgrent.c,v 1.62 2008/04/28 20:22:59 martin Exp $	*/
+/*	$NetBSD: getgrent.c,v 1.63 2011/06/09 05:11:17 sjg Exp $	*/
 /*-
  * Copyright (c) 1999-2000, 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.
  */
 /*
  * Copyright (c) 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * 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.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
  */
 /*
  * Portions Copyright (c) 1994, Jason Downs. All Rights Reserved.
+ *
  * 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 AUTHOR(S) ``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 AUTHOR(S) 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)
 #if 0
 static char sccsid[] = "@(#)getgrent.c	8.2 (Berkeley) 3/21/94";
 #else
-__RCSID("$NetBSD: getgrent.c,v 1.62 2008/04/28 20:22:59 martin Exp $");
+__RCSID("$NetBSD: getgrent.c,v 1.63 2011/06/09 05:11:17 sjg Exp $");
 #endif
 #endif /* LIBC_SCCS and not lint */
 #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 <syslog.h>
 #ifdef HESIOD
 #include <hesiod.h>
 #endif
 #ifdef YP
 #include <rpc/rpc.h>
 #include <rpcsvc/yp_prot.h>
 #include <rpcsvc/ypclnt.h>
 #endif
 #include "gr_private.h"
 #ifdef __weak_alias
 __weak_alias(endgrent,_endgrent)
 __weak_alias(getgrent,_getgrent)
 __weak_alias(getgrent_r,_getgrent_r)
 __weak_alias(getgrgid,_getgrgid)
 __weak_alias(getgrgid_r,_getgrgid_r)
 __weak_alias(getgrnam,_getgrnam)
 __weak_alias(getgrnam_r,_getgrnam_r)
 __weak_alias(setgrent,_setgrent)
 __weak_alias(setgroupent,_setgroupent)
 #endif
 #ifdef _REENTRANT
 mutex_t	__grmutex = MUTEX_INITIALIZER;
 #endif
 /*
  * _gr_memfrombuf
  *	Obtain want bytes from buffer (of size buflen) and return a pointer
  *	to the available memory after adjusting buffer/buflen.
  *	Returns NULL if there is insufficient space.
  */
 static char *
 _gr_memfrombuf(size_t want, char **buffer, size_t *buflen)
+{
 	char	*rv;
 	if (want > *buflen) {
 		errno = ERANGE;
 		return NULL;
+	}
 	rv = *buffer;
 	*buffer += want;
 	*buflen -= want;
 	return rv;
+}
 /*
  * _gr_parse
  *	Parses entry as a line per group(5) (without the trailing \n)
  *	and fills in grp with corresponding values; memory for strings
  *	and arrays will be allocated from buf (of size buflen).
  *	Returns 1 if parsed successfully, 0 on parse failure.
  */
 static int
 _gr_parse(const char *entry, struct group *grp, char *buf, size_t buflen)
+{
 	unsigned long	id;
 	const char	*bp;
 	char		*ep;
 	size_t		count;
 	int		memc;
 	_DIAGASSERT(entry != NULL);
 	_DIAGASSERT(grp != NULL);
 	_DIAGASSERT(buf != NULL);
 #define COPYTOBUF(to) \
 	do { \
 		(to) = _gr_memfrombuf(count+1, &buf, &buflen); \
 		if ((to) == NULL) \
 			return 0; \
 		memmove((to), entry, count); \
 		to[count] = '\0'; \
 	} while (0)	/* LINTED */
 #if 0
 	if (*entry == '+')			/* fail on compat `+' token */
 		return 0;
 #endif
 	count = strcspn(entry, ":");		/* parse gr_name */
 	if (entry[count] == '\0')
 		return 0;
 	COPYTOBUF(grp->gr_name);
 	entry += count + 1;
 	count = strcspn(entry, ":");		/* parse gr_passwd */
 	if (entry[count] == '\0')
 		return 0;
 	COPYTOBUF(grp->gr_passwd);
 	entry += count + 1;
 	count = strcspn(entry, ":");		/* parse gr_gid */
 	if (entry[count] == '\0')
 		return 0;
 	id = strtoul(entry, &ep, 10);
 	if (id > GID_MAX || *ep != ':')
 		return 0;
 	grp->gr_gid = (gid_t)id;
 	entry += count + 1;
 	memc = 1;				/* for final NULL */
 	if (*entry != '\0')
 		memc++;				/* for first item */
 	for (bp = entry; *bp != '\0'; bp++) {
 		if (*bp == ',')
 			memc++;
+	}
 				/* grab ALIGNed char **gr_mem from buf */
 	ep = _gr_memfrombuf(memc * sizeof(char *) + ALIGNBYTES, &buf, &buflen);
 	grp->gr_mem = (char **)ALIGN(ep);
 	if (grp->gr_mem == NULL)
 		return 0;
 	for (memc = 0; *entry != '\0'; memc++) {
 		count = strcspn(entry, ",");	/* parse member */
 		COPYTOBUF(grp->gr_mem[memc]);
 		entry += count;
 		if (*entry == ',')
 			entry++;
+	}
 #undef COPYTOBUF
 	grp->gr_mem[memc] = NULL;
 	return 1;
+}
 /*
  * _gr_copy
  *	Copy the contents of fromgrp to grp; memory for strings
  *	and arrays will be allocated from buf (of size buflen).
  *	Returns 1 if copied successfully, 0 on copy failure.
  *	NOTE: fromgrp must not use buf for its own pointers.
  */
 static int
 _gr_copy(struct group *fromgrp, struct group *grp, char *buf, size_t buflen)
+{
 	char	*ep;
 	int	memc;
 	_DIAGASSERT(fromgrp != NULL);
 	_DIAGASSERT(grp != NULL);
 	_DIAGASSERT(buf != NULL);
 #define COPYSTR(to, from) \
 	do { \
 		size_t count = strlen((from)); \
 		(to) = _gr_memfrombuf(count+1, &buf, &buflen); \
 		if ((to) == NULL) \
 			return 0; \
 		memmove((to), (from), count); \
 		to[count] = '\0'; \
 	} while (0)	/* LINTED */
 	COPYSTR(grp->gr_name, fromgrp->gr_name);
 	COPYSTR(grp->gr_passwd, fromgrp->gr_passwd);
 	grp->gr_gid = fromgrp->gr_gid;
 	if (fromgrp->gr_mem == NULL)
 		return 0;
 	for (memc = 0; fromgrp->gr_mem[memc]; memc++)
 		continue;
 	memc++;					/* for final NULL */
 				/* grab ALIGNed char **gr_mem from buf */
 	ep = _gr_memfrombuf(memc * sizeof(char *) + ALIGNBYTES, &buf, &buflen);
 	grp->gr_mem = (char **)ALIGN(ep);
 	if (grp->gr_mem == NULL)
 		return 0;
 	for (memc = 0; fromgrp->gr_mem[memc]; memc++) {
 		COPYSTR(grp->gr_mem[memc], fromgrp->gr_mem[memc]);
+	}
 #undef COPYSTR
 	grp->gr_mem[memc] = NULL;
 	return 1;
+}
 		/*
 		 *	files methods
 		 */
 int
 __grstart_files(struct __grstate_files *state)
+{
 	_DIAGASSERT(state != NULL);
 	if (state->fp == NULL) {
 		state->fp = fopen(_PATH_GROUP, "r");
 		if (state->fp == NULL)
 			return NS_UNAVAIL;
 	} else {
 		rewind(state->fp);
+	}
 	return NS_SUCCESS;
+}
 int
 __grend_files(struct __grstate_files *state)
+{
 	_DIAGASSERT(state != NULL);
 	if (state->fp) {
 		(void) fclose(state->fp);
 		state->fp = NULL;
+	}
 	return NS_SUCCESS;
+}
 /*
  * __grscan_files
  *	Scan state->fp for the next desired entry.
  *	If search is zero, return the next entry.
  *	If search is non-zero, look for a specific name (if name != NULL),
  *	or a specific gid (if name == NULL).
  *	Sets *retval to the errno if the result is not NS_SUCCESS
  *	or NS_NOTFOUND.
  */
 int
 __grscan_files(int *retval, struct group *grp, char *buffer, size_t buflen,
 	struct __grstate_files *state, int search, const char *name, gid_t gid)
+{
 	int	rv;
 	char	filebuf[_GETGR_R_SIZE_MAX], *ep;
 	_DIAGASSERT(retval != NULL);
 	_DIAGASSERT(grp != NULL);
 	_DIAGASSERT(buffer != NULL);
 	_DIAGASSERT(state != NULL);
 	/* name is NULL to indicate searching for gid */
 	*retval = 0;
 	if (state->fp == NULL) {	/* only start if file not open yet */
 		rv = __grstart_files(state);
 		if (rv != NS_SUCCESS)
 			goto filesgrscan_out;
+	}
 	rv = NS_NOTFOUND;
 							/* scan line by line */
 	while (fgets(filebuf, sizeof(filebuf), state->fp) != NULL) {
 		ep = strchr(filebuf, '\n');
 		if (ep == NULL) {	/* skip lines that are too big */
 			int ch;
 			while ((ch = getc(state->fp)) != '\n' && ch != EOF)
 				continue;
 			continue;
+		}
 		*ep = '\0';				/* clear trailing \n */
 		if (filebuf[0] == '+')			/* skip compat line */
 			continue;
 							/* validate line */
 		if (! _gr_parse(filebuf, grp, buffer, buflen)) {
 			continue;			/* skip bad lines */
+		}
 		if (! search) {				/* just want this one */
 			rv = NS_SUCCESS;
 			break;
+		}
 							/* want specific */
 		if ((name && strcmp(name, grp->gr_name) == 0) ||
 		    (!name && gid == grp->gr_gid)) {
 			rv = NS_SUCCESS;
 			break;
+		}
+	}
  filesgrscan_out:
 	if (rv != NS_SUCCESS && rv != NS_NOTFOUND)
 		*retval = errno;
 	return rv;
+}
 static struct __grstate_files	_files_state;
 					/* storage for non _r functions */
 static struct group		_files_group;
 static char			_files_groupbuf[_GETGR_R_SIZE_MAX];
 /*ARGSUSED*/
 static int
 _files_setgrent(void *nsrv, void *nscb, va_list ap)
+{
 	_files_state.stayopen = 0;
 	return __grstart_files(&_files_state);
+}
 /*ARGSUSED*/
 static int
 _files_setgroupent(void *nsrv, void *nscb, va_list ap)
+{
 	int	*retval		= va_arg(ap, int *);
 	int	 stayopen	= va_arg(ap, int);
 	int	rv;
 	_files_state.stayopen = stayopen;
 	rv = __grstart_files(&_files_state);
 	*retval = (rv == NS_SUCCESS);
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _files_endgrent(void *nsrv, void *nscb, va_list ap)
+{
 	_files_state.stayopen = 0;
 	return __grend_files(&_files_state);
+}
 /*ARGSUSED*/
 static int
 _files_getgrent(void *nsrv, void *nscb, va_list ap)
+{
 	struct group	**retval = va_arg(ap, struct group **);
 	int	rv, rerror;
 	_DIAGASSERT(retval != NULL);
 	*retval = NULL;
 	rv = __grscan_files(&rerror, &_files_group,
 	    _files_groupbuf, sizeof(_files_groupbuf),
 	    &_files_state, 0, NULL, 0);
 	if (rv == NS_SUCCESS)
 		*retval = &_files_group;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _files_getgrent_r(void *nsrv, void *nscb, va_list ap)
+{
 	int		*retval	= va_arg(ap, int *);
 	struct group	*grp	= va_arg(ap, struct group *);
 	char		*buffer	= va_arg(ap, char *);
 	size_t		 buflen	= va_arg(ap, size_t);
 	struct group   **result	= va_arg(ap, struct group **);
 	int	rv;
 	_DIAGASSERT(retval != NULL);
 	_DIAGASSERT(grp != NULL);
 	_DIAGASSERT(buffer != NULL);
 	_DIAGASSERT(result != NULL);
 	rv = __grscan_files(retval, grp, buffer, buflen,
 	    &_files_state, 0, NULL, 0);
 	if (rv == NS_SUCCESS)
 		*result = grp;
 	else
 		*result = NULL;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _files_getgrgid(void *nsrv, void *nscb, va_list ap)
+{
 	struct group	**retval = va_arg(ap, struct group **);
 	gid_t		 gid	= va_arg(ap, gid_t);
 	int	rv, rerror;
 	_DIAGASSERT(retval != NULL);
 	*retval = NULL;
 	rv = __grstart_files(&_files_state);
 	if (rv != NS_SUCCESS)
 		return rv;
 	rv = __grscan_files(&rerror, &_files_group,
 	    _files_groupbuf, sizeof(_files_groupbuf),
 	    &_files_state, 1, NULL, gid);
 	if (!_files_state.stayopen)
 		__grend_files(&_files_state);
 	if (rv == NS_SUCCESS)
 		*retval = &_files_group;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _files_getgrgid_r(void *nsrv, void *nscb, va_list ap)
+{
 	int		*retval	= va_arg(ap, int *);
 	gid_t		 gid	= va_arg(ap, gid_t);
 	struct group	*grp	= va_arg(ap, struct group *);
 	char		*buffer	= va_arg(ap, char *);
 	size_t		 buflen	= va_arg(ap, size_t);
 	struct group   **result	= va_arg(ap, struct group **);
 	struct __grstate_files state;
 	int	rv;
 	_DIAGASSERT(retval != NULL);
 	_DIAGASSERT(grp != NULL);
 	_DIAGASSERT(buffer != NULL);
 	_DIAGASSERT(result != NULL);
 	*result = NULL;
 	memset(&state, 0, sizeof(state));
 	rv = __grscan_files(retval, grp, buffer, buflen, &state, 1, NULL, gid);
 	__grend_files(&state);
 	if (rv == NS_SUCCESS)
 		*result = grp;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _files_getgrnam(void *nsrv, void *nscb, va_list ap)
+{
 	struct group	**retval = va_arg(ap, struct group **);
 	const char	*name	= va_arg(ap, const char *);
 	int	rv, rerror;
 	_DIAGASSERT(retval != NULL);
 	*retval = NULL;
 	rv = __grstart_files(&_files_state);
 	if (rv != NS_SUCCESS)
 		return rv;
 	rv = __grscan_files(&rerror, &_files_group,
 	    _files_groupbuf, sizeof(_files_groupbuf),
 	    &_files_state, 1, name, 0);
 	if (!_files_state.stayopen)
 		__grend_files(&_files_state);
 	if (rv == NS_SUCCESS)
 		*retval = &_files_group;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _files_getgrnam_r(void *nsrv, void *nscb, va_list ap)
+{
 	int		*retval	= va_arg(ap, int *);
 	const char	*name	= va_arg(ap, const char *);
 	struct group	*grp	= va_arg(ap, struct group *);
 	char		*buffer	= va_arg(ap, char *);
 	size_t		 buflen	= va_arg(ap, size_t);
 	struct group   **result	= va_arg(ap, struct group **);
 	struct __grstate_files state;
 	int	rv;
 	_DIAGASSERT(retval != NULL);
 	_DIAGASSERT(grp != NULL);
 	_DIAGASSERT(buffer != NULL);
 	_DIAGASSERT(result != NULL);
 	*result = NULL;
 	memset(&state, 0, sizeof(state));
 	rv = __grscan_files(retval, grp, buffer, buflen, &state, 1, name, 0);
 	__grend_files(&state);
 	if (rv == NS_SUCCESS)
 		*result = grp;
 	return rv;
+}
 #ifdef HESIOD
 		/*
 		 *	dns methods
 		 */
 int
 __grstart_dns(struct __grstate_dns *state)
+{
 	_DIAGASSERT(state != NULL);
 	state->num = 0;
 	if (state->context == NULL) {			/* setup Hesiod */
 		if (hesiod_init(&state->context) == -1)
 			return NS_UNAVAIL;
+	}
 	return NS_SUCCESS;
+}
 int
 __grend_dns(struct __grstate_dns *state)
+{
 	_DIAGASSERT(state != NULL);
 	state->num = 0;
 	if (state->context) {
 		hesiod_end(state->context);
 		state->context = NULL;
+	}
 	return NS_SUCCESS;
+}
 /*
  * __grscan_dns
  *	Search Hesiod for the next desired entry.
  *	If search is zero, return the next entry.
  *	If search is non-zero, look for a specific name (if name != NULL),
  *	or a specific gid (if name == NULL).
  */
 int
 __grscan_dns(int *retval, struct group *grp, char *buffer, size_t buflen,
 	struct __grstate_dns *state, int search, const char *name, gid_t gid)
+{
 	const char	**curzone;
 	char		**hp, *ep;
 	int		rv;
 	static const char *zones_gid_group[] = {
 		"gid",
 		"group",
 		NULL
 	};
 	static const char *zones_group[] = {
 		"group",
 		NULL
 	};
 	_DIAGASSERT(retval != NULL);
 	_DIAGASSERT(grp != NULL);
 	_DIAGASSERT(buffer != NULL);
 	_DIAGASSERT(state != NULL);
 	/* name is NULL to indicate searching for gid */
 	*retval = 0;
 	if (state->context == NULL) {	/* only start if Hesiod not setup */
 		rv = __grstart_dns(state);
 		if (rv != NS_SUCCESS)
 			return rv;
+	}
  next_dns_entry:
 	hp = NULL;
 	rv = NS_NOTFOUND;
 	if (! search) {			/* find next entry */
 		if (state->num == -1)		/* exhausted search */
 			return NS_NOTFOUND;
 						/* find group-NNN */
 		snprintf(buffer, buflen, "group-%u", state->num);
 		state->num++;
 		curzone = zones_group;
 	} else if (name) {		/* find group name */
 		snprintf(buffer, buflen, "%s", name);
 		curzone = zones_group;
 	} else {			/* find gid */
 		snprintf(buffer, buflen, "%u", (unsigned int)gid);
 		curzone = zones_gid_group;
+	}
 	for (; *curzone; curzone++) {		/* search zones */
 		hp = hesiod_resolve(state->context, buffer, *curzone);
 		if (hp != NULL)
 			break;
 		if (errno != ENOENT) {
 			rv = NS_UNAVAIL;
 			goto dnsgrscan_out;
+		}
+	}
 	if (*curzone == NULL) {
 		if (! search)
 			state->num = -1;
 		goto dnsgrscan_out;
+	}
 	if ((ep = strchr(hp[0], '\n')) != NULL)
 		*ep = '\0';				/* clear trailing \n */
 	if (_gr_parse(hp[0], grp, buffer, buflen)) {	/* validate line */
 		if (! search) {				/* just want this one */
 			rv = NS_SUCCESS;
 		} else if ((name && strcmp(name, grp->gr_name) == 0) ||
 		    (!name && gid == grp->gr_gid)) {	/* want specific */
 			rv = NS_SUCCESS;
+		}
 	} else {					/* dodgy entry */
 		if (!search) {			/* try again if ! searching */
 			hesiod_free_list(state->context, hp);
 			goto next_dns_entry;
+		}
+	}
  dnsgrscan_out:
 	if (rv != NS_SUCCESS && rv != NS_NOTFOUND)
 		*retval = errno;
 	if (hp)
 		hesiod_free_list(state->context, hp);
 	return rv;
+}
 static struct __grstate_dns	_dns_state;
 					/* storage for non _r functions */
 static struct group		_dns_group;
 static char			_dns_groupbuf[_GETGR_R_SIZE_MAX];
 /*ARGSUSED*/
 static int
 _dns_setgrent(void *nsrv, void *nscb, va_list ap)
+{
 	_dns_state.stayopen = 0;
 	return __grstart_dns(&_dns_state);
+}
 /*ARGSUSED*/
 static int
 _dns_setgroupent(void *nsrv, void *nscb, va_list ap)
+{
 	int	*retval		= va_arg(ap, int *);
 	int	 stayopen	= va_arg(ap, int);
 	int	rv;
 	_dns_state.stayopen = stayopen;
 	rv = __grstart_dns(&_dns_state);
 	*retval = (rv == NS_SUCCESS);
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _dns_endgrent(void *nsrv, void *nscb, va_list ap)
+{
 	_dns_state.stayopen = 0;
 	return __grend_dns(&_dns_state);
+}
 /*ARGSUSED*/
 static int
 _dns_getgrent(void *nsrv, void *nscb, va_list ap)
+{
 	struct group	**retval = va_arg(ap, struct group **);
 	int	  rv, rerror;
 	_DIAGASSERT(retval != NULL);
 	*retval = NULL;
 	rv = __grscan_dns(&rerror, &_dns_group,
 	    _dns_groupbuf, sizeof(_dns_groupbuf), &_dns_state, 0, NULL, 0);
 	if (rv == NS_SUCCESS)
 		*retval = &_dns_group;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _dns_getgrent_r(void *nsrv, void *nscb, va_list ap)
+{
 	int		*retval	= va_arg(ap, int *);
 	struct group	*grp	= va_arg(ap, struct group *);
 	char		*buffer	= va_arg(ap, char *);
 	size_t		 buflen	= va_arg(ap, size_t);
 	struct group   **result	= va_arg(ap, struct group **);
 	int	rv;
 	_DIAGASSERT(retval != NULL);
 	_DIAGASSERT(grp != NULL);
 	_DIAGASSERT(buffer != NULL);
 	_DIAGASSERT(result != NULL);
 	rv = __grscan_dns(retval, grp, buffer, buflen,
 	    &_dns_state, 0, NULL, 0);
 	if (rv == NS_SUCCESS)
 		*result = grp;
 	else
 		*result = NULL;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _dns_getgrgid(void *nsrv, void *nscb, va_list ap)
+{
 	struct group	**retval = va_arg(ap, struct group **);
 	gid_t		 gid	= va_arg(ap, gid_t);
 	int	rv, rerror;
 	_DIAGASSERT(retval != NULL);
 	*retval = NULL;
 	rv = __grstart_dns(&_dns_state);
 	if (rv != NS_SUCCESS)
 		return rv;
 	rv = __grscan_dns(&rerror, &_dns_group,
 	    _dns_groupbuf, sizeof(_dns_groupbuf), &_dns_state, 1, NULL, gid);
 	if (!_dns_state.stayopen)
 		__grend_dns(&_dns_state);
 	if (rv == NS_SUCCESS)
 		*retval = &_dns_group;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _dns_getgrgid_r(void *nsrv, void *nscb, va_list ap)
+{
 	int		*retval	= va_arg(ap, int *);
 	gid_t		 gid	= va_arg(ap, gid_t);
 	struct group	*grp	= va_arg(ap, struct group *);
 	char		*buffer	= va_arg(ap, char *);
 	size_t		 buflen	= va_arg(ap, size_t);
 	struct group   **result	= va_arg(ap, struct group **);
 	struct __grstate_dns state;
 	int	rv;
 	_DIAGASSERT(retval != NULL);
 	_DIAGASSERT(grp != NULL);
 	_DIAGASSERT(buffer != NULL);
 	_DIAGASSERT(result != NULL);
 	*result = NULL;
 	memset(&state, 0, sizeof(state));
 	rv = __grscan_dns(retval, grp, buffer, buflen, &state, 1, NULL, gid);
 	__grend_dns(&state);
 	if (rv == NS_SUCCESS)
 		*result = grp;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _dns_getgrnam(void *nsrv, void *nscb, va_list ap)
+{
 	struct group	**retval = va_arg(ap, struct group **);
 	const char	*name	= va_arg(ap, const char *);
 	int	rv, rerror;
 	_DIAGASSERT(retval != NULL);
 	*retval = NULL;
 	rv = __grstart_dns(&_dns_state);
 	if (rv != NS_SUCCESS)
 		return rv;
 	rv = __grscan_dns(&rerror, &_dns_group,
 	    _dns_groupbuf, sizeof(_dns_groupbuf), &_dns_state, 1, name, 0);
 	if (!_dns_state.stayopen)
 		__grend_dns(&_dns_state);
 	if (rv == NS_SUCCESS)
 		*retval = &_dns_group;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _dns_getgrnam_r(void *nsrv, void *nscb, va_list ap)
+{
 	int		*retval	= va_arg(ap, int *);
 	const char	*name	= va_arg(ap, const char *);
 	struct group	*grp	= va_arg(ap, struct group *);
 	char		*buffer	= va_arg(ap, char *);
 	size_t		 buflen	= va_arg(ap, size_t);
 	struct group   **result	= va_arg(ap, struct group **);
 	struct __grstate_dns state;
 	int	rv;
 	_DIAGASSERT(retval != NULL);
 	_DIAGASSERT(grp != NULL);
 	_DIAGASSERT(buffer != NULL);
 	_DIAGASSERT(result != NULL);
 	*result = NULL;
 	memset(&state, 0, sizeof(state));
 	rv = __grscan_dns(retval, grp, buffer, buflen, &state, 1, name, 0);
 	__grend_dns(&state);
 	if (rv == NS_SUCCESS)
 		*result = grp;
 	return rv;
+}
 #endif /* HESIOD */
 #ifdef YP
 		/*
 		 *	nis methods
 		 */
 int
 __grstart_nis(struct __grstate_nis *state)
+{
 	_DIAGASSERT(state != NULL);
 	state->done = 0;
 	if (state->current) {
 		free(state->current);
 		state->current = NULL;
+	}
 	if (state->domain == NULL) {			/* setup NIS */
 		switch (yp_get_default_domain(&state->domain)) {
 		case 0:
 			break;
 		case YPERR_RESRC:
 			return NS_TRYAGAIN;
 		default:
 			return NS_UNAVAIL;
+		}
+	}
 	return NS_SUCCESS;
+}
 int
 __grend_nis(struct __grstate_nis *state)
+{
 	_DIAGASSERT(state != NULL);
 	if (state->domain) {
 		state->domain = NULL;
+	}
 	state->done = 0;
 	if (state->current) {
 		free(state->current);
 		state->current = NULL;
+	}
 	return NS_SUCCESS;
+}
 /*
  * __grscan_nis
  *	Search NIS for the next desired entry.
  *	If search is zero, return the next entry.
  *	If search is non-zero, look for a specific name (if name != NULL),
  *	or a specific gid (if name == NULL).
  */
 int
 __grscan_nis(int *retval, struct group *grp, char *buffer, size_t buflen,
 	struct __grstate_nis *state, int search, const char *name, gid_t gid)
+{
 	const char *map;
 	char	*key, *data;
 	int	nisr, rv, keylen, datalen;
 	_DIAGASSERT(retval != NULL);
 	_DIAGASSERT(grp != NULL);
 	_DIAGASSERT(buffer != NULL);
 	_DIAGASSERT(state != NULL);
 	/* name is NULL to indicate searching for gid */
 	*retval = 0;
 	if (state->domain == NULL) {	/* only start if NIS not setup */
 		rv = __grstart_nis(state);
 		if (rv != NS_SUCCESS)
 			return rv;
+	}
  next_nis_entry:
 	key = NULL;
 	data = NULL;
 	rv = NS_SUCCESS;
 	if (! search) 	{			/* find next entry */
 		if (state->done)			/* exhausted search */
 			return NS_NOTFOUND;
 		map = "group.byname";
 		if (state->current) {			/* already searching */
 			nisr = yp_next(state->domain, map,
 			    state->current, state->currentlen,
 			    &key, &keylen, &data, &datalen);
 			free(state->current);
 			state->current = NULL;
 			switch (nisr) {
 			case 0:
 				state->current = key;
 				state->currentlen = keylen;
 				key = NULL;
 				break;
 			case YPERR_NOMORE:
 				rv = NS_NOTFOUND;
 				state->done = 1;
 				break;
 			default:
 				rv = NS_UNAVAIL;
 				break;
+			}
 		} else {				/* new search */
 			if (yp_first(state->domain, map,
 			    &state->current, &state->currentlen,
 			    &data, &datalen)) {
 				rv = NS_UNAVAIL;
+			}
+		}
 	} else {				/* search for specific item */
 		if (name) {			/* find group name */
 			snprintf(buffer, buflen, "%s", name);
 			map = "group.byname";
 		} else {			/* find gid */
 			snprintf(buffer, buflen, "%u", (unsigned int)gid);
 			map = "group.bygid";
+		}
 		nisr = yp_match(state->domain, map, buffer, (int)strlen(buffer),
 		    &data, &datalen);
 		switch (nisr) {
 		case 0:
 			break;
 		case YPERR_KEY:
 			rv = NS_NOTFOUND;
 			break;
 		default:
 			rv = NS_UNAVAIL;
 			break;
+		}
+	}
 	if (rv == NS_SUCCESS) {				/* validate data */
 		data[datalen] = '\0';			/* clear trailing \n */
 		if (_gr_parse(data, grp, buffer, buflen)) {
 			if (! search) {			/* just want this one */
 				rv = NS_SUCCESS;
 			} else if ((name && strcmp(name, grp->gr_name) == 0) ||
 			    (!name && gid == grp->gr_gid)) {
 							/* want specific */
 				rv = NS_SUCCESS;
+			}
 		} else {				/* dodgy entry */
 			if (!search) {		/* try again if ! searching */
 				free(data);
 				goto next_nis_entry;
+			}
+		}
+	}
 	if (rv != NS_SUCCESS && rv != NS_NOTFOUND)
 		*retval = errno;
 	if (key)
 		free(key);
 	if (data)
 		free(data);
 	return rv;
+}
 static struct __grstate_nis	_nis_state;
 					/* storage for non _r functions */
 static struct group		_nis_group;
 static char			_nis_groupbuf[_GETGR_R_SIZE_MAX];
 /*ARGSUSED*/
 static int
 _nis_setgrent(void *nsrv, void *nscb, va_list ap)
+{
 	_nis_state.stayopen = 0;
 	return __grstart_nis(&_nis_state);
+}
 /*ARGSUSED*/
 static int
 _nis_setgroupent(void *nsrv, void *nscb, va_list ap)
+{
 	int	*retval		= va_arg(ap, int *);
 	int	 stayopen	= va_arg(ap, int);
 	int	rv;
 	_nis_state.stayopen = stayopen;
 	rv = __grstart_nis(&_nis_state);
 	*retval = (rv == NS_SUCCESS);
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _nis_endgrent(void *nsrv, void *nscb, va_list ap)
+{
 	return __grend_nis(&_nis_state);
+}
 /*ARGSUSED*/
 static int
 _nis_getgrent(void *nsrv, void *nscb, va_list ap)
+{
 	struct group	**retval = va_arg(ap, struct group **);
 	int	rv, rerror;
 	_DIAGASSERT(retval != NULL);
 	*retval = NULL;
 	rv = __grscan_nis(&rerror, &_nis_group,
 	    _nis_groupbuf, sizeof(_nis_groupbuf), &_nis_state, 0, NULL, 0);
 	if (rv == NS_SUCCESS)
 		*retval = &_nis_group;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _nis_getgrent_r(void *nsrv, void *nscb, va_list ap)
+{
 	int		*retval	= va_arg(ap, int *);
 	struct group	*grp	= va_arg(ap, struct group *);
 	char		*buffer	= va_arg(ap, char *);
 	size_t		 buflen	= va_arg(ap, size_t);
 	struct group   **result	= va_arg(ap, struct group **);
 	int	rv;
 	_DIAGASSERT(retval != NULL);
 	_DIAGASSERT(grp != NULL);
 	_DIAGASSERT(buffer != NULL);
 	_DIAGASSERT(result != NULL);
 	rv = __grscan_nis(retval, grp, buffer, buflen,
 	    &_nis_state, 0, NULL, 0);
 	if (rv == NS_SUCCESS)
 		*result = grp;
 	else
 		*result = NULL;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _nis_getgrgid(void *nsrv, void *nscb, va_list ap)
+{
 	struct group	**retval = va_arg(ap, struct group **);
 	gid_t		 gid	= va_arg(ap, gid_t);
 	int	rv, rerror;
 	_DIAGASSERT(retval != NULL);
 	*retval = NULL;
 	rv = __grstart_nis(&_nis_state);
 	if (rv != NS_SUCCESS)
 		return rv;
 	rv = __grscan_nis(&rerror, &_nis_group,
 	    _nis_groupbuf, sizeof(_nis_groupbuf), &_nis_state, 1, NULL, gid);
 	if (!_nis_state.stayopen)
 		__grend_nis(&_nis_state);
 	if (rv == NS_SUCCESS)
 		*retval = &_nis_group;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _nis_getgrgid_r(void *nsrv, void *nscb, va_list ap)
+{
 	int		*retval	= va_arg(ap, int *);
 	gid_t		 gid	= va_arg(ap, gid_t);
 	struct group	*grp	= va_arg(ap, struct group *);
 	char		*buffer	= va_arg(ap, char *);
 	size_t		 buflen	= va_arg(ap, size_t);
 	struct group   **result	= va_arg(ap, struct group **);
 	struct __grstate_nis state;
 	int	rv;
 	_DIAGASSERT(retval != NULL);
 	_DIAGASSERT(grp != NULL);
 	_DIAGASSERT(buffer != NULL);
 	_DIAGASSERT(result != NULL);
 	*result = NULL;
 	memset(&state, 0, sizeof(state));
 	rv = __grscan_nis(retval, grp, buffer, buflen, &state, 1, NULL, gid);
 	__grend_nis(&state);
 	if (rv == NS_SUCCESS)
 		*result = grp;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _nis_getgrnam(void *nsrv, void *nscb, va_list ap)
+{
 	struct group	**retval = va_arg(ap, struct group **);
 	const char	*name	= va_arg(ap, const char *);
 	int	rv, rerror;
 	_DIAGASSERT(retval != NULL);
 	*retval = NULL;
 	rv = __grstart_nis(&_nis_state);
 	if (rv != NS_SUCCESS)
 		return rv;
 	rv = __grscan_nis(&rerror, &_nis_group,
 	    _nis_groupbuf, sizeof(_nis_groupbuf), &_nis_state, 1, name, 0);
 	if (!_nis_state.stayopen)
 		__grend_nis(&_nis_state);
 	if (rv == NS_SUCCESS)
 		*retval = &_nis_group;
 	return rv;
+}
 /*ARGSUSED*/
 static int
 _nis_getgrnam_r(void *nsrv, void *nscb, va_list ap)
+{
 	int		*retval	= va_arg(ap, int *);
 	const char	*name	= va_arg(ap, const char *);
 	struct group	*grp	= va_arg(ap, struct group *);
 	char		*buffer	= va_arg(ap, char *);
 	size_t		 buflen	= va_arg(ap, size_t);
 	struct group   **result	= va_arg(ap, struct group **);
 	struct __grstate_nis state;
 	int	rv;
 	_DIAGASSERT(retval != NULL);
 	_DIAGASSERT(grp != NULL);
 	_DIAGASSERT(buffer != NULL);
 	_DIAGASSERT(result != NULL);
 	*result = NULL;
 	memset(&state, 0, sizeof(state));
 	rv = __grscan_nis(retval, grp, buffer, buflen, &state, 1, name, 0);
 	__grend_nis(&state);
 	if (rv == NS_SUCCESS)
 		*result = grp;
 	return rv;
+}
 #endif /* YP */
 #ifdef _GROUP_COMPAT
 		/*
 		 *	compat methods
 		 */
 int
 __grstart_compat(struct __grstate_compat *state)
+{
 	_DIAGASSERT(state != NULL);
 	if (state->fp == NULL) {
 		state->fp = fopen(_PATH_GROUP, "r");
 		if (state->fp == NULL)
 			return NS_UNAVAIL;
 	} else {
 		rewind(state->fp);
+	}
 	return NS_SUCCESS;