X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=libpwdgrp%2Fpwd_grp.c;h=34690a738e554f3caff88d596c4593515a37117d;hb=2b46fd49b14b2ac30e0c767c65ac2b29f6922a45;hp=3fe70f40c4a1c0b031ebb96dbc1fc96975b8b724;hpb=9230582315a15dd7b95de9f03c48024858ec935d;p=oweals%2Fbusybox.git

diff --git a/libpwdgrp/pwd_grp.c b/libpwdgrp/pwd_grp.c
index 3fe70f40c..34690a738 100644
--- a/libpwdgrp/pwd_grp.c
+++ b/libpwdgrp/pwd_grp.c
@@ -19,7 +19,6 @@
  */
 
 #include "libbb.h"
-#include <features.h>
 #include <assert.h>
 
 #ifndef _PATH_SHADOW
@@ -43,13 +42,17 @@
 /**********************************************************************/
 /* Prototypes for internal functions. */
 
-static int bb__pgsreader(int (*parserfunc)(void *d, char *line), void *data,
-		char *__restrict line_buff, size_t buflen, FILE *f);
+static int bb__pgsreader(
+		int FAST_FUNC (*parserfunc)(void *d, char *line),
+		void *data,
+		char *__restrict line_buff,
+		size_t buflen,
+		FILE *f);
 
-static int bb__parsepwent(void *pw, char *line);
-static int bb__parsegrent(void *gr, char *line);
+static int FAST_FUNC bb__parsepwent(void *pw, char *line);
+static int FAST_FUNC bb__parsegrent(void *gr, char *line);
 #if ENABLE_USE_BB_SHADOW
-static int bb__parsespent(void *sp, char *line);
+static int FAST_FUNC bb__parsespent(void *sp, char *line);
 #endif
 
 /**********************************************************************/
@@ -161,6 +164,7 @@ int fgetgrent_r(FILE *__restrict stream, struct group *__restrict resultbuf,
 }
 
 #if ENABLE_USE_BB_SHADOW
+#ifdef UNUSED_FOR_NOW
 int fgetspent_r(FILE *__restrict stream, struct spwd *__restrict resultbuf,
 				char *__restrict buffer, size_t buflen,
 				struct spwd **__restrict result)
@@ -177,6 +181,7 @@ int fgetspent_r(FILE *__restrict stream, struct spwd *__restrict resultbuf,
 	return rv;
 }
 #endif
+#endif
 
 /**********************************************************************/
 /* For the various fget??ent funcs, return NULL on failure and a
@@ -184,7 +189,7 @@ int fgetspent_r(FILE *__restrict stream, struct spwd *__restrict resultbuf,
  * TODO: audit & stop using these in bbox, they pull in static buffers */
 /**********************************************************************/
 
-#if 0
+#ifdef UNUSED_SINCE_WE_AVOID_STATIC_BUFS
 struct passwd *fgetpwent(FILE *stream)
 {
 	struct statics *S;
@@ -209,7 +214,7 @@ struct group *fgetgrent(FILE *stream)
 #endif
 
 #if ENABLE_USE_BB_SHADOW
-#if 0
+#ifdef UNUSED_SINCE_WE_AVOID_STATIC_BUFS
 struct spwd *fgetspent(FILE *stream)
 {
 	struct statics *S;
@@ -222,6 +227,7 @@ struct spwd *fgetspent(FILE *stream)
 }
 #endif
 
+#ifdef UNUSED_FOR_NOW
 int sgetspent_r(const char *string, struct spwd *result_buf,
 				char *buffer, size_t buflen, struct spwd **result)
 {
@@ -230,8 +236,8 @@ int sgetspent_r(const char *string, struct spwd *result_buf,
 	*result = NULL;
 
 	if (buflen < PWD_BUFFER_SIZE) {
-	DO_ERANGE:
-		errno=rv;
+ DO_ERANGE:
+		errno = rv;
 		goto DONE;
 	}
 
@@ -251,6 +257,7 @@ int sgetspent_r(const char *string, struct spwd *result_buf,
 	return rv;
 }
 #endif
+#endif /* ENABLE_USE_BB_SHADOW */
 
 /**********************************************************************/
 
@@ -396,30 +403,6 @@ struct spwd *getspnam(const char *name)
 }
 #endif
 
-/* This one doesn't use static buffers */
-int getpw(uid_t uid, char *buf)
-{
-	struct passwd resultbuf;
-	struct passwd *result;
-	char buffer[PWD_BUFFER_SIZE];
-
-	if (!buf) {
-		errno = EINVAL;
-	} else if (!getpwuid_r(uid, &resultbuf, buffer, sizeof(buffer), &result)) {
-		if (sprintf(buf, "%s:%s:%lu:%lu:%s:%s:%s\n",
-					resultbuf.pw_name, resultbuf.pw_passwd,
-					(unsigned long)(resultbuf.pw_uid),
-					(unsigned long)(resultbuf.pw_gid),
-					resultbuf.pw_gecos, resultbuf.pw_dir,
-					resultbuf.pw_shell) >= 0
-			) {
-			return 0;
-		}
-	}
-
-	return -1;
-}
-
 /**********************************************************************/
 
 /* FIXME: we don't have such CONFIG_xx - ?! */
@@ -464,7 +447,7 @@ int getpwent_r(struct passwd *__restrict resultbuf,
 	*result = NULL;				/* In case of error... */
 
 	if (!pwf) {
-		pwf = fopen(_PATH_PASSWD, "r");
+		pwf = fopen_for_read(_PATH_PASSWD);
 		if (!pwf) {
 			rv = errno;
 			goto ERR;
@@ -511,7 +494,7 @@ int getgrent_r(struct group *__restrict resultbuf,
 	*result = NULL;				/* In case of error... */
 
 	if (!grf) {
-		grf = fopen(_PATH_GROUP, "r");
+		grf = fopen_for_read(_PATH_GROUP);
 		if (!grf) {
 			rv = errno;
 			goto ERR;
@@ -528,6 +511,7 @@ int getgrent_r(struct group *__restrict resultbuf,
 	return rv;
 }
 
+#ifdef UNUSED_FOR_NOW
 #if ENABLE_USE_BB_SHADOW
 static FILE *spf /*= NULL*/;
 void setspent(void)
@@ -558,7 +542,7 @@ int getspent_r(struct spwd *resultbuf, char *buffer,
 	*result = NULL;				/* In case of error... */
 
 	if (!spf) {
-		spf = fopen(_PATH_SHADOW, "r");
+		spf = fopen_for_read(_PATH_SHADOW);
 		if (!spf) {
 			rv = errno;
 			goto ERR;
@@ -575,8 +559,9 @@ int getspent_r(struct spwd *resultbuf, char *buffer,
 	return rv;
 }
 #endif
+#endif /* UNUSED_FOR_NOW */
 
-#if 0
+#ifdef UNUSED_SINCE_WE_AVOID_STATIC_BUFS
 struct passwd *getpwent(void)
 {
 	static char line_buff[PWD_BUFFER_SIZE];
@@ -596,9 +581,8 @@ struct group *getgrent(void)
 	getgrent_r(&gr, line_buff, sizeof(line_buff), &result);
 	return result;
 }
-#endif
 
-#if 0 //ENABLE_USE_BB_SHADOW
+#if ENABLE_USE_BB_SHADOW
 struct spwd *getspent(void)
 {
 	static char line_buff[PWD_BUFFER_SIZE];
@@ -619,66 +603,88 @@ struct spwd *sgetspent(const char *string)
 	return result;
 }
 #endif
+#endif /* UNUSED_SINCE_WE_AVOID_STATIC_BUFS */
 
-int initgroups(const char *user, gid_t gid)
+static gid_t *getgrouplist_internal(int *ngroups_ptr, const char *user, gid_t gid)
 {
 	FILE *grfile;
 	gid_t *group_list;
-	int num_groups, rv;
-	char **m;
+	int ngroups;
 	struct group group;
 	char buff[PWD_BUFFER_SIZE];
 
-	rv = -1;
-	grfile = fopen(_PATH_GROUP, "r");
-	if (grfile != NULL) {
-
-		/* We alloc space for 8 gids at a time. */
-		group_list = xmalloc(8 * sizeof(gid_t *));
-		*group_list = gid;
-		num_groups = 1;
+	/* We alloc space for 8 gids at a time. */
+	group_list = xmalloc(8 * sizeof(group_list[0]));
+	group_list[0] = gid;
+	ngroups = 1;
 
+	grfile = fopen_for_read(_PATH_GROUP);
+	if (grfile) {
 		while (!bb__pgsreader(bb__parsegrent, &group, buff, sizeof(buff), grfile)) {
+			char **m;
 			assert(group.gr_mem); /* Must have at least a NULL terminator. */
-			if (group.gr_gid != gid) {
-				for (m = group.gr_mem; *m; m++) {
-					if (!strcmp(*m, user)) {
-						if (!(num_groups & 7)) {
-							gid_t *tmp = xrealloc(group_list,
-									(num_groups+8) * sizeof(gid_t *));
-							group_list = tmp;
-						}
-						group_list[num_groups++] = group.gr_gid;
-						break;
-					}
-				}
+			if (group.gr_gid == gid)
+				continue;
+			for (m = group.gr_mem; *m; m++) {
+				if (strcmp(*m, user) != 0)
+					continue;
+				group_list = xrealloc_vector(group_list, /*8=2^3:*/ 3, ngroups);
+				group_list[ngroups++] = group.gr_gid;
+				break;
 			}
 		}
-
-		rv = setgroups(num_groups, group_list);
-		free(group_list);
 		fclose(grfile);
 	}
+	*ngroups_ptr = ngroups;
+	return group_list;
+}
 
-	return rv;
+int initgroups(const char *user, gid_t gid)
+{
+	int ngroups;
+	gid_t *group_list = getgrouplist_internal(&ngroups, user, gid);
+
+	ngroups = setgroups(ngroups, group_list);
+	free(group_list);
+	return ngroups;
 }
 
+int getgrouplist(const char *user, gid_t gid, gid_t *groups, int *ngroups)
+{
+	int ngroups_old = *ngroups;
+	gid_t *group_list = getgrouplist_internal(ngroups, user, gid);
+
+	if (*ngroups <= ngroups_old) {
+		ngroups_old = *ngroups;
+		memcpy(groups, group_list, ngroups_old * sizeof(groups[0]));
+	} else {
+		ngroups_old = -1;
+	}
+	free(group_list);
+	return ngroups_old;
+}
+
+#ifdef UNUSED_SINCE_WE_AVOID_STATIC_BUFS
 int putpwent(const struct passwd *__restrict p, FILE *__restrict f)
 {
 	int rv = -1;
 
+#if 0
+	/* glibc does this check */
 	if (!p || !f) {
 		errno = EINVAL;
-	} else {
-		/* No extra thread locking is needed above what fprintf does. */
-		if (fprintf(f, "%s:%s:%lu:%lu:%s:%s:%s\n",
-					p->pw_name, p->pw_passwd,
-					(unsigned long)(p->pw_uid),
-					(unsigned long)(p->pw_gid),
-					p->pw_gecos, p->pw_dir, p->pw_shell) >= 0
-			) {
-			rv = 0;
-		}
+		return rv;
+	}
+#endif
+
+	/* No extra thread locking is needed above what fprintf does. */
+	if (fprintf(f, "%s:%s:%lu:%lu:%s:%s:%s\n",
+				p->pw_name, p->pw_passwd,
+				(unsigned long)(p->pw_uid),
+				(unsigned long)(p->pw_gid),
+				p->pw_gecos, p->pw_dir, p->pw_shell) >= 0
+		) {
+		rv = 0;
 	}
 
 	return rv;
@@ -686,48 +692,52 @@ int putpwent(const struct passwd *__restrict p, FILE *__restrict f)
 
 int putgrent(const struct group *__restrict p, FILE *__restrict f)
 {
-	static const char format[] ALIGN1 = ",%s";
-
-	char **m;
-	const char *fmt;
 	int rv = -1;
 
-	if (!p || !f) {				/* Sigh... glibc checks. */
+#if 0
+	/* glibc does this check */
+	if (!p || !f) {
 		errno = EINVAL;
-	} else {
-		if (fprintf(f, "%s:%s:%lu:",
-					p->gr_name, p->gr_passwd,
-					(unsigned long)(p->gr_gid)) >= 0
-			) {
+		return rv;
+	}
+#endif
 
-			fmt = format + 1;
+	if (fprintf(f, "%s:%s:%lu:",
+				p->gr_name, p->gr_passwd,
+				(unsigned long)(p->gr_gid)) >= 0
+	) {
+		static const char format[] ALIGN1 = ",%s";
 
-			assert(p->gr_mem);
-			m = p->gr_mem;
+		char **m;
+		const char *fmt;
 
-			do {
-				if (!*m) {
-					if (fputc('\n', f) >= 0) {
-						rv = 0;
-					}
-					break;
-				}
-				if (fprintf(f, fmt, *m) < 0) {
-					break;
-				}
-				++m;
-				fmt = format;
-			} while (1);
+		fmt = format + 1;
 
-		}
+		assert(p->gr_mem);
+		m = p->gr_mem;
 
+		while (1) {
+			if (!*m) {
+				if (fputc('\n', f) >= 0) {
+					rv = 0;
+				}
+				break;
+			}
+			if (fprintf(f, fmt, *m) < 0) {
+				break;
+			}
+			m++;
+			fmt = format;
+		}
 	}
 
 	return rv;
 }
+#endif
 
 #if ENABLE_USE_BB_SHADOW
-static const unsigned char _sp_off[] ALIGN1 = {
+#ifdef UNUSED_FOR_NOW
+static const unsigned char put_sp_off[] ALIGN1 = {
 	offsetof(struct spwd, sp_lstchg),       /* 2 - not a char ptr */
 	offsetof(struct spwd, sp_min),          /* 3 - not a char ptr */
 	offsetof(struct spwd, sp_max),          /* 4 - not a char ptr */
@@ -738,9 +748,7 @@ static const unsigned char _sp_off[] ALIGN1 = {
 
 int putspent(const struct spwd *p, FILE *stream)
 {
-	static const char ld_format[] ALIGN1 = "%ld:";
-
-	const char *f;
+	const char *fmt;
 	long x;
 	int i;
 	int rv = -1;
@@ -752,13 +760,13 @@ int putspent(const struct spwd *p, FILE *stream)
 		goto DO_UNLOCK;
 	}
 
-	for (i = 0; i < sizeof(_sp_off); i++) {
-		f = ld_format;
-		x = *(const long *)(((const char *) p) + _sp_off[i]);
+	for (i = 0; i < sizeof(put_sp_off); i++) {
+		fmt = "%ld:";
+		x = *(long *)((char *)p + put_sp_off[i]);
 		if (x == -1) {
-			f += 3;
+			fmt += 3;
 		}
-		if (fprintf(stream, f, x) < 0) {
+		if (fprintf(stream, fmt, x) < 0) {
 			goto DO_UNLOCK;
 		}
 	}
@@ -771,13 +779,14 @@ int putspent(const struct spwd *p, FILE *stream)
 		rv = 0;
 	}
 
-DO_UNLOCK:
+ DO_UNLOCK:
 	return rv;
 }
 #endif
+#endif /* USE_BB_SHADOW */
 
 /**********************************************************************/
-/* Internal uClibc functions.                                         */
+/* Internal functions                                                 */
 /**********************************************************************/
 
 static const unsigned char pw_off[] ALIGN1 = {
@@ -790,19 +799,19 @@ static const unsigned char pw_off[] ALIGN1 = {
 	offsetof(struct passwd, pw_shell)       /* 6 */
 };
 
-static int bb__parsepwent(void *data, char *line)
+static int FAST_FUNC bb__parsepwent(void *data, char *line)
 {
 	char *endptr;
 	char *p;
 	int i;
 
 	i = 0;
-	do {
-		p = ((char *) ((struct passwd *) data)) + pw_off[i];
+	while (1) {
+		p = (char *) data + pw_off[i];
 
-		if ((i & 6) ^ 2) {	/* i!=2 and i!=3 */
+		if (i < 2 || i > 3) {
 			*((char **) p) = line;
-			if (i==6) {
+			if (i == 6) {
 				return 0;
 			}
 			/* NOTE: glibc difference - glibc allows omission of
@@ -829,9 +838,9 @@ static int bb__parsepwent(void *data, char *line)
 			}
 		}
 
-		*line++ = 0;
-		++i;
-	} while (1);
+		*line++ = '\0';
+		i++;
+	} /* while (1) */
 
 	return -1;
 }
@@ -844,7 +853,7 @@ static const unsigned char gr_off[] ALIGN1 = {
 	offsetof(struct group, gr_gid)          /* 2 - not a char ptr */
 };
 
-static int bb__parsegrent(void *data, char *line)
+static int FAST_FUNC bb__parsegrent(void *data, char *line)
 {
 	char *endptr;
 	char *p;
@@ -854,8 +863,8 @@ static int bb__parsegrent(void *data, char *line)
 
 	end_of_buf = ((struct group *) data)->gr_name; /* Evil hack! */
 	i = 0;
-	do {
-		p = ((char *) ((struct group *) data)) + gr_off[i];
+	while (1) {
+		p = (char *) data + gr_off[i];
 
 		if (i < 2) {
 			*((char **) p) = line;
@@ -863,8 +872,8 @@ static int bb__parsegrent(void *data, char *line)
 			if (!line) {
 				break;
 			}
-			*line++ = 0;
-			++i;
+			*line++ = '\0';
+			i++;
 		} else {
 			*((gid_t *) p) = strtoul(line, &endptr, 10);
 
@@ -884,9 +893,9 @@ static int bb__parsegrent(void *data, char *line)
 
 			if (p[1]) { /* We have a member list to process. */
 				/* Overwrite the last ':' with a ',' before counting.
-				 * This allows us to test for initial ',' and adds
-				 * one ',' so that the ',' count equals the member
-				 * count. */
+				 * This allows us to (1) test for initial ','
+				 * and (2) adds one ',' so that the number of commas
+				 * equals the member count. */
 				*p = ',';
 				do {
 					/* NOTE: glibc difference - glibc allows and trims leading
@@ -917,17 +926,19 @@ static int bb__parsegrent(void *data, char *line)
 
 			if (--i) {
 				p = endptr;	/* Pointing to char prior to first member. */
-				do {
+				while (1) {
 					*members++ = ++p;
-					if (!--i) break;
-					while (*++p) {}
-				} while (1);
+					if (!--i)
+						break;
+					while (*++p)
+						continue;
+				}
 			}
 			*members = NULL;
 
 			return 0;
 		}
-	} while (1);
+	} /* while (1) */
 
  ERR:
 	return -1;
@@ -937,57 +948,51 @@ static int bb__parsegrent(void *data, char *line)
 
 #if ENABLE_USE_BB_SHADOW
 static const unsigned char sp_off[] ALIGN1 = {
-	offsetof(struct spwd, sp_namp),         /* 0 */
-	offsetof(struct spwd, sp_pwdp),         /* 1 */
-	offsetof(struct spwd, sp_lstchg),       /* 2 - not a char ptr */
-	offsetof(struct spwd, sp_min),          /* 3 - not a char ptr */
-	offsetof(struct spwd, sp_max),          /* 4 - not a char ptr */
-	offsetof(struct spwd, sp_warn),         /* 5 - not a char ptr */
-	offsetof(struct spwd, sp_inact),        /* 6 - not a char ptr */
-	offsetof(struct spwd, sp_expire),       /* 7 - not a char ptr */
-	offsetof(struct spwd, sp_flag)          /* 8 - not a char ptr */
+	offsetof(struct spwd, sp_namp),         /* 0: char* */
+	offsetof(struct spwd, sp_pwdp),         /* 1: char* */
+	offsetof(struct spwd, sp_lstchg),       /* 2: long */
+	offsetof(struct spwd, sp_min),          /* 3: long */
+	offsetof(struct spwd, sp_max),          /* 4: long */
+	offsetof(struct spwd, sp_warn),         /* 5: long */
+	offsetof(struct spwd, sp_inact),        /* 6: long */
+	offsetof(struct spwd, sp_expire),       /* 7: long */
+	offsetof(struct spwd, sp_flag)          /* 8: unsigned long */
 };
 
-static int bb__parsespent(void *data, char * line)
+static int FAST_FUNC bb__parsespent(void *data, char *line)
 {
 	char *endptr;
 	char *p;
 	int i;
 
 	i = 0;
-	do {
-		p = ((char *) ((struct spwd *) data)) + sp_off[i];
+	while (1) {
+		p = (char *) data + sp_off[i];
 		if (i < 2) {
 			*((char **) p) = line;
 			line = strchr(line, ':');
 			if (!line) {
-				break;
+				break; /* error */
 			}
 		} else {
-			*((long *) p) = (long) strtoul(line, &endptr, 10);
-
+			*((long *) p) = strtoul(line, &endptr, 10);
 			if (endptr == line) {
-				*((long *) p) = ((i != 8) ? -1L : ((long)(~0UL)));
+				*((long *) p) = -1L;
 			}
-
 			line = endptr;
-
 			if (i == 8) {
-				if (!*endptr) {
-					return 0;
+				if (*line != '\0') {
+					break; /* error */
 				}
-				break;
+				return 0; /* all ok */
 			}
-
-			if (*endptr != ':') {
-				break;
+			if (*line != ':') {
+				break; /* error */
 			}
-
 		}
-
-		*line++ = 0;
-		++i;
-	} while (1);
+		*line++ = '\0';
+		i++;
+	}
 
 	return EINVAL;
 }
@@ -995,65 +1000,72 @@ static int bb__parsespent(void *data, char * line)
 
 /**********************************************************************/
 
-/* Reads until if EOF, or until if finds a line which fits in the buffer
+/* Reads until EOF, or until it finds a line which fits in the buffer
  * and for which the parser function succeeds.
  *
- * Returns 0 on success and ENOENT for end-of-file (glibc concession).
+ * Returns 0 on success and ENOENT for end-of-file (glibc convention).
  */
-
-static int bb__pgsreader(int (*parserfunc)(void *d, char *line), void *data,
-				char *__restrict line_buff, size_t buflen, FILE *f)
+static int bb__pgsreader(
+		int FAST_FUNC (*parserfunc)(void *d, char *line),
+		void *data,
+		char *__restrict line_buff,
+		size_t buflen,
+		FILE *f)
 {
-	int line_len;
 	int skip;
 	int rv = ERANGE;
 
 	if (buflen < PWD_BUFFER_SIZE) {
 		errno = rv;
-	} else {
-		skip = 0;
-		do {
-			if (!fgets(line_buff, buflen, f)) {
-				if (feof(f)) {
-					rv = ENOENT;
-				}
-				break;
-			}
+		return rv;
+	}
 
-			line_len = strlen(line_buff) - 1; /* strlen() must be > 0. */
-			if (line_buff[line_len] == '\n') {
-				line_buff[line_len] = 0;
-			} else if (line_len + 2 == buflen) { /* line too long */
-				++skip;
-				continue;
+	skip = 0;
+	while (1) {
+		if (!fgets(line_buff, buflen, f)) {
+			if (feof(f)) {
+				rv = ENOENT;
 			}
+			break;
+		}
 
-			if (skip) {
-				--skip;
+		{
+			int line_len = strlen(line_buff) - 1;
+			if (line_len >= 0 && line_buff[line_len] == '\n') {
+				line_buff[line_len] = '\0';
+			} else
+			if (line_len + 2 == buflen) {
+				/* A start (or continuation) of overlong line */
+				skip = 1;
 				continue;
-			}
+			} /* else: a last line in the file, and it has no '\n' */
+		}
 
-			/* NOTE: glibc difference - glibc strips leading whitespace from
-			 * records.  We do not allow leading whitespace. */
-
-			/* Skip empty lines, comment lines, and lines with leading
-			 * whitespace. */
-			if (*line_buff && (*line_buff != '#') && !isspace(*line_buff)) {
-				if (parserfunc == bb__parsegrent) {	/* Do evil group hack. */
-					/* The group entry parsing function needs to know where
-					 * the end of the buffer is so that it can construct the
-					 * group member ptr table. */
-					((struct group *) data)->gr_name = line_buff + buflen;
-				}
+		if (skip) {
+			/* This "line" is a remainder of overlong line, ignore */
+			skip = 0;
+			continue;
+		}
 
-				if (!parserfunc(data, line_buff)) {
-					rv = 0;
-					break;
-				}
+		/* NOTE: glibc difference - glibc strips leading whitespace from
+		 * records.  We do not allow leading whitespace. */
+
+		/* Skip empty lines, comment lines, and lines with leading
+		 * whitespace. */
+		if (line_buff[0] != '\0' && line_buff[0] != '#' && !isspace(line_buff[0])) {
+			if (parserfunc == bb__parsegrent) {
+				/* Do evil group hack:
+				 * The group entry parsing function needs to know where
+				 * the end of the buffer is so that it can construct the
+				 * group member ptr table. */
+				((struct group *) data)->gr_name = line_buff + buflen;
 			}
-		} while (1);
-
-	}
+			if (parserfunc(data, line_buff) == 0) {
+				rv = 0;
+				break;
+			}
+		}
+	} /* while (1) */
 
 	return rv;
 }