Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libc/gen/getnetgrent.c	Lines:	0	257	0.0 %
Date:	2017-11-07	Branches:	0	219	0.0 %


/*	$OpenBSD: getnetgrent.c,v 1.28 2016/09/24 12:43:37 millert Exp $	*/

/*
 * Copyright (c) 1994 Christos Zoulas
 * 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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by Christos Zoulas.
 * 4. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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/types.h>
#include <stdio.h>
#include <netgroup.h>
#include <string.h>
#include <fcntl.h>
#include <err.h>
#include <ctype.h>
#include <stdlib.h>
#include <db.h>
#ifdef YP
#include <rpcsvc/ypclnt.h>
#endif

#define _NG_STAR(s)	(((s) == NULL || *(s) == '\0') ? _ngstar : s)
#define _NG_EMPTY(s)	((s) == NULL ? "" : s)
#define _NG_ISSPACE(p)	(isspace((unsigned char) (p)) || (p) == '\n')

static const char _ngstar[] = "*";
static struct netgroup *_nghead = (struct netgroup *)NULL;
static struct netgroup *_nglist = (struct netgroup *)NULL;
static DB *_ng_db;

/*
 * Simple string list
 */
struct stringlist {
	char		**sl_str;
	size_t		  sl_max;
	size_t		  sl_cur;
};

static struct stringlist *_ng_sl_init(void);
static int	_ng_sl_add(struct stringlist *, char *);
static void	_ng_sl_free(struct stringlist *, int);
static char    *_ng_sl_find(struct stringlist *, char *);
static char    *_ng_makekey(const char *, const char *, size_t);
static int	_ng_parse(char **, char **, struct netgroup **);
static void	_ng_print(char *, size_t, const struct netgroup *);

static int		getstring(char **, int, char **);
static struct netgroup	*getnetgroup(char **);
static int		 lookup(const char *, char *, char **, int);
static void		 addgroup(char *, struct stringlist *, char *);
static int		 in_check(const char *, const char *,
			    const char *, struct netgroup *);
static int		 in_find(char *, struct stringlist *,
			    char *, const char *, const char *, const char *);
static char		*in_lookup1(const char *, const char *,
			    const char *, int);
static int		 in_lookup(const char *, const char *,
			    const char *, const char *, int);

/*
 * _ng_sl_init(): Initialize a string list
 */
static struct stringlist *
_ng_sl_init(void)
{
	struct stringlist *sl = malloc(sizeof(struct stringlist));
	if (sl == NULL)
		return NULL;

	sl->sl_cur = 0;
	sl->sl_max = 20;
	sl->sl_str = calloc(sl->sl_max, sizeof(char *));
	if (sl->sl_str == NULL) {
		free(sl);
		return NULL;
	}
	return sl;
}


/*
 * _ng_sl_add(): Add an item to the string list
 */
static int
_ng_sl_add(struct stringlist *sl, char *name)
{
	if (sl->sl_cur == sl->sl_max - 1) {
		char **slstr;

		sl->sl_max += 20;
		slstr = reallocarray(sl->sl_str, sl->sl_max, sizeof(char *));
		if (slstr == NULL) {
			free(sl->sl_str);
			sl->sl_str = NULL;
			return -1;
		}
		sl->sl_str = slstr;
	}
	sl->sl_str[sl->sl_cur++] = name;
	return 0;
}


/*
 * _ng_sl_free(): Free a stringlist
 */
static void
_ng_sl_free(struct stringlist *sl, int all)
{
	size_t	i;

	if (all)
		for (i = 0; i < sl->sl_cur; i++)
			free(sl->sl_str[i]);
	free(sl->sl_str);
	free(sl);
}


/*
 * sl_find(): Find a name in the string list
 */
static char *
_ng_sl_find(struct stringlist *sl, char *name)
{
	size_t	i;

	for (i = 0; i < sl->sl_cur; i++)
		if (strcmp(sl->sl_str[i], name) == 0)
			return sl->sl_str[i];

	return NULL;
}


/*
 * getstring(): Get a string delimited by the character, skipping leading and
 * trailing blanks and advancing the pointer
 */
static int
getstring(char **pp, int del, char **str)
{
	char *sp, *ep, *dp;

	/* skip leading blanks */
	for (sp = *pp; *sp && _NG_ISSPACE(*sp); sp++)
		continue;

	/* accumulate till delimiter or space */
	for (ep = sp; *ep && *ep != del && !_NG_ISSPACE(*ep); ep++)
		continue;

	/* hunt for the delimiter */
	for (dp = ep; *dp && *dp != del && _NG_ISSPACE(*dp); dp++)
		continue;

	if (*dp != del) {
		*str = NULL;
		return 0;
	}

	*pp = ++dp;

	del = (ep - sp) + 1;
	if (del > 1) {
		dp = malloc(del);
		if (dp == NULL)
			return 0;
		memcpy(dp, sp, del);
		dp[del - 1] = '\0';
	} else
		dp = NULL;

	*str = dp;
	return 1;
}


/*
 * getnetgroup(): Parse a netgroup, and advance the pointer
 */
static struct netgroup *
getnetgroup(char **pp)
{
	struct netgroup *ng = malloc(sizeof(struct netgroup));

	if (ng == NULL)
		return NULL;

	(*pp)++;	/* skip '(' */
	if (!getstring(pp, ',', &ng->ng_host))
		goto badhost;

	if (!getstring(pp, ',', &ng->ng_user))
		goto baduser;

	if (!getstring(pp, ')', &ng->ng_domain))
		goto baddomain;

#ifdef DEBUG_NG
	{
		char buf[1024];
		_ng_print(buf, sizeof(buf), ng);
		fprintf(stderr, "netgroup %s\n", buf);
	}
#endif
	return ng;

baddomain:
	free(ng->ng_user);
baduser:
	free(ng->ng_host);
badhost:
	free(ng);
	return NULL;
}


/*
 * lookup(): Find the given key in the database or yp, and return its value
 * in *line; returns 1 if key was found, 0 otherwise
 */
static int
lookup(const char *ypdom, char *name, char **line, int bywhat)
{
	int	ret;
#ifdef YP
	int	i;
	char	*map = NULL;
#endif

	if (_ng_db) {
		DBT	 key, data;
		size_t	 len = strlen(name) + 2;
		char	*ks = malloc(len);

		if (ks == NULL)
			return 0;
		ks[0] = bywhat;
		memcpy(&ks[1], name, len - 1);

		key.data = (u_char *) ks;
		key.size = len;

		ret = (_ng_db->get)(_ng_db, &key, &data, 0);
		free(ks);
		switch (ret) {
		case 0:
			*line = strdup(data.data);
			if (*line == NULL)
				return 0;
			return 1;

		case 1:
			break;

		case -1:
			return 0;
		}
	}
#ifdef YP
	if (ypdom) {
		switch (bywhat) {
		case _NG_KEYBYNAME:
			map = "netgroup";
			break;

		case _NG_KEYBYUSER:
			map = "netgroup.byuser";
			break;

		case _NG_KEYBYHOST:
			map = "netgroup.byhost";
			break;
		}


		if (yp_match(ypdom, map, name, strlen(name), line, &i) == 0)
			return 1;
	}
#endif

	return 0;
}


/*
 * _ng_parse(): Parse a line and return: _NG_ERROR: Syntax Error _NG_NONE:
 * line was empty or a comment _NG_GROUP: line had a netgroup definition,
 * returned in ng _NG_NAME:  line had a netgroup name, returned in name
 *
 * Public since used by netgroup_mkdb
 */
static int
_ng_parse(char **p, char **name, struct netgroup **ng)
{
	while (**p) {
		if (**p == '#')
			/* comment */
			return _NG_NONE;

		while (**p && _NG_ISSPACE(**p))
			/* skipblank */
			(*p)++;

		if (**p == '(') {
			if ((*ng = getnetgroup(p)) == NULL)
				return _NG_ERROR;
			return _NG_GROUP;
		} else {
			char	*np;
			int	i;

			for (np = *p; **p && !_NG_ISSPACE(**p); (*p)++)
				continue;
			if (np != *p) {
				i = (*p - np) + 1;
				*name = malloc(i);
				if (*name == NULL)
					return _NG_ERROR;
				memcpy(*name, np, i);
				(*name)[i - 1] = '\0';
				return _NG_NAME;
			}
		}
	}
	return _NG_NONE;
}


/*
 * addgroup(): Recursively add all the members of the netgroup to this group
 */
static void
addgroup(char *ypdom, struct stringlist *sl, char *grp)
{
	char		*line, *p;
	struct netgroup	*ng;
	char		*name;

#ifdef DEBUG_NG
	(void) fprintf(stderr, "addgroup(%s)\n", grp);
#endif
	/* check for cycles */
	if (_ng_sl_find(sl, grp) != NULL) {
		warnx("netgroup: Cycle in group `%s'", grp);
		free(grp);
		return;
	}
	if (_ng_sl_add(sl, grp) == -1) {
		free(grp);
		return;
	}

	/* Lookup this netgroup */
	if (!lookup(ypdom, grp, &line, _NG_KEYBYNAME))
		return;

	p = line;

	for (;;) {
		switch (_ng_parse(&p, &name, &ng)) {
		case _NG_NONE:
			/* Done with the line */
			free(line);
			return;

		case _NG_GROUP:
			/* new netgroup */
			/* add to the list */
			ng->ng_next = _nglist;
			_nglist = ng;
			break;

		case _NG_NAME:
			/* netgroup name */
			addgroup(ypdom, sl, name);
			break;

		case _NG_ERROR:
			return;
		}
	}
}


/*
 * in_check(): Compare the spec with the netgroup
 */
static int
in_check(const char *host, const char *user, const char *domain,
    struct netgroup *ng)
{
	if ((host != NULL) && (ng->ng_host != NULL) &&
	    strcmp(ng->ng_host, host) != 0)
		return 0;

	if ((user != NULL) && (ng->ng_user != NULL) &&
	    strcmp(ng->ng_user, user) != 0)
		return 0;

	if ((domain != NULL) && (ng->ng_domain != NULL) &&
	    strcmp(ng->ng_domain, domain) != 0)
		return 0;

	return 1;
}


/*
 * in_find(): Find a match for the host, user, domain spec
 */
static int
in_find(char *ypdom, struct stringlist *sl, char *grp, const char *host,
    const char *user, const char *domain)
{
	char		*line, *p;
	int		 i;
	struct netgroup	*ng;
	char		*name;

#ifdef DEBUG_NG
	(void) fprintf(stderr, "in_find(%s)\n", grp);
#endif
	/* check for cycles */
	if (_ng_sl_find(sl, grp) != NULL) {
		warnx("netgroup: Cycle in group `%s'", grp);
		free(grp);
		return 0;
	}
	if (_ng_sl_add(sl, grp) == -1) {
		free(grp);
		return 0;
	}

	/* Lookup this netgroup */
	if (!lookup(ypdom, grp, &line, _NG_KEYBYNAME))
		return 0;

	p = line;

	for (;;) {
		switch (_ng_parse(&p, &name, &ng)) {
		case _NG_NONE:
			/* Done with the line */
			free(line);
			return 0;

		case _NG_GROUP:
			/* new netgroup */
			i = in_check(host, user, domain, ng);
			free(ng->ng_host);
			free(ng->ng_user);
			free(ng->ng_domain);
			free(ng);
			if (i) {
				free(line);
				return 1;
			}
			break;

		case _NG_NAME:
			/* netgroup name */
			if (in_find(ypdom, sl, name, host, user, domain)) {
				free(line);
				return 1;
			}
			break;

		case _NG_ERROR:
			free(line);
			return 0;
		}
	}
}


/*
 * _ng_makekey(): Make a key from the two names given. The key is of the form
 * <name1>.<name2> Names strings are replaced with * if they are empty;
 */
static char *
_ng_makekey(const char *s1, const char *s2, size_t len)
{
	char *buf = malloc(len);
	int ret;

	if (buf == NULL)
		return NULL;
	ret = snprintf(buf, len, "%s.%s", _NG_STAR(s1), _NG_STAR(s2));
	if (ret < 0 || ret >= len) {
		free(buf);
		return NULL;
	}

	return buf;
}

static void
_ng_print(char *buf, size_t len, const struct netgroup *ng)
{
	(void) snprintf(buf, len, "(%s,%s,%s)", _NG_EMPTY(ng->ng_host),
	    _NG_EMPTY(ng->ng_user), _NG_EMPTY(ng->ng_domain));
}


/*
 * in_lookup1(): Fast lookup for a key in the appropriate map
 */
static char *
in_lookup1(const char *ypdom, const char *key, const char *domain, int map)
{
	char	*line;
	size_t	 len;
	char	*ptr;
	int	 res;

	len = (key ? strlen(key) : 1) + (domain ? strlen(domain) : 1) + 2;
	ptr = _ng_makekey(key, domain, len);
	if (ptr == NULL)
		return NULL;
	res = lookup(ypdom, ptr, &line, map);
	free(ptr);
	return res ? line : NULL;
}


/*
 * in_lookup(): Fast lookup for a key in the appropriate map
 */
static int
in_lookup(const char *ypdom, const char *group, const char *key,
    const char *domain, int map)
{
	size_t	 len;
	char	*ptr, *line;

	if (domain != NULL) {
		/* Domain specified; look in "group.domain" and "*.domain" */
		if ((line = in_lookup1(ypdom, key, domain, map)) == NULL)
			line = in_lookup1(ypdom, NULL, domain, map);
	} else
		line = NULL;

	if (line == NULL) {
		/*
		 * domain not specified or domain lookup failed; look in
		 * "group.*" and "*.*"
		 */
	    if (((line = in_lookup1(ypdom, key, NULL, map)) == NULL) &&
		((line = in_lookup1(ypdom, NULL, NULL, map)) == NULL))
		return 0;
	}

	len = strlen(group);

	for (ptr = line; (ptr = strstr(ptr, group)) != NULL;)
		/* Make sure we did not find a substring */
		if ((ptr != line && ptr[-1] != ',') ||
		    (ptr[len] != '\0' && strchr("\n\t ,", ptr[len]) == NULL))
			ptr++;
		else {
			free(line);
			return 1;
		}

	free(line);
	return 0;
}


void
endnetgrent(void)
{
	for (_nglist = _nghead; _nglist != NULL; _nglist = _nghead) {
		_nghead = _nglist->ng_next;
		free(_nglist->ng_host);
		free(_nglist->ng_user);
		free(_nglist->ng_domain);
		free(_nglist);
	}

	if (_ng_db) {
		(void) (_ng_db->close) (_ng_db);
		_ng_db = NULL;
	}
}
DEF_WEAK(endnetgrent);


void
setnetgrent(const char *ng)
{
	struct stringlist	*sl;
#ifdef YP
	char			*line;
#endif
	char			*ng_copy, *ypdom = NULL;

	/* Cleanup any previous storage */
	if (_nghead != NULL)
		endnetgrent();

	sl = _ng_sl_init();
	if (sl == NULL)
		return;

	if (_ng_db == NULL)
		_ng_db = dbopen(_PATH_NETGROUP_DB, O_RDONLY, 0, DB_HASH, NULL);

#ifdef YP
	/*
	 * We use yp if there is a "+" in the netgroup file, or if there is
	 * no netgroup file at all
	 */
	if (_ng_db == NULL || lookup(NULL, "+", &line, _NG_KEYBYNAME) == 0)
		yp_get_default_domain(&ypdom);
	else
		free(line);
#endif
	ng_copy = strdup(ng);
	if (ng_copy != NULL)
		addgroup(ypdom, sl, ng_copy);
	_nghead = _nglist;
	_ng_sl_free(sl, 1);
}
DEF_WEAK(setnetgrent);


int
getnetgrent(const char **host, const char **user, const char **domain)
{
	if (_nglist == NULL)
		return 0;

	*host   = _nglist->ng_host;
	*user   = _nglist->ng_user;
	*domain = _nglist->ng_domain;

	_nglist = _nglist->ng_next;

	return 1;
}
DEF_WEAK(getnetgrent);


int
innetgr(const char *grp, const char *host, const char *user, const char *domain)
{
	char	*ypdom = NULL, *grpdup;
#ifdef YP
	char	*line = NULL;
#endif
	int	 found;
	struct stringlist *sl;

	if (_ng_db == NULL)
		_ng_db = dbopen(_PATH_NETGROUP_DB, O_RDONLY, 0, DB_HASH, NULL);

#ifdef YP
	/*
	 * We use yp if there is a "+" in the netgroup file, or if there is
	 * no netgroup file at all
	 */
	if (_ng_db == NULL)
		yp_get_default_domain(&ypdom);
	else if (lookup(NULL, "+", &line, _NG_KEYBYNAME) == 0)
		yp_get_default_domain(&ypdom);

	free(line);
#endif

	/* Try the fast lookup first */
	if (host != NULL && user == NULL) {
		if (in_lookup(ypdom, grp, host, domain, _NG_KEYBYHOST))
			return 1;
	} else if (host == NULL && user != NULL) {
		if (in_lookup(ypdom, grp, user, domain, _NG_KEYBYUSER))
			return 1;
	}

	/* Too bad need the slow recursive way */
	sl = _ng_sl_init();
	if (sl == NULL)
		return 0;

	grpdup = strdup(grp);
	if (grpdup == NULL) {
		_ng_sl_free(sl, 1);
		return 0;
	}

	found = in_find(ypdom, sl, grpdup, host, user, domain);
	_ng_sl_free(sl, 1);

	return found;
}
DEF_WEAK(innetgr);


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: getnetgrent.c,v 1.28 2016/09/24 12:43:37 millert Exp $ */
2
3			/*
4			* Copyright (c) 1994 Christos Zoulas
5			* All rights reserved.
6			*
7			* Redistribution and use in source and binary forms, with or without
8			* modification, are permitted provided that the following conditions
9			* are met:
10			* 1. Redistributions of source code must retain the above copyright
11			* notice, this list of conditions and the following disclaimer.
12			* 2. Redistributions in binary form must reproduce the above copyright
13			* notice, this list of conditions and the following disclaimer in the
14			* documentation and/or other materials provided with the distribution.
15			* 3. All advertising materials mentioning features or use of this software
16			* must display the following acknowledgement:
17			* This product includes software developed by Christos Zoulas.
18			* 4. The name of the author may not be used to endorse or promote products
19			* derived from this software without specific prior written permission.
20			*
21			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
22			* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23			* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
25			* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31			* SUCH DAMAGE.
32			*/
33
34			#include <sys/types.h>
35			#include <stdio.h>
36			#include <netgroup.h>
37			#include <string.h>
38			#include <fcntl.h>
39			#include <err.h>
40			#include <ctype.h>
41			#include <stdlib.h>
42			#include <db.h>
43			#ifdef YP
44			#include <rpcsvc/ypclnt.h>
45			#endif
46
47			#define _NG_STAR(s) (((s) == NULL \|\| *(s) == '\0') ? _ngstar : s)
48			#define _NG_EMPTY(s) ((s) == NULL ? "" : s)
49			#define _NG_ISSPACE(p) (isspace((unsigned char) (p)) \|\| (p) == '\n')
50
51			static const char _ngstar[] = "*";
52			static struct netgroup _nghead = (struct netgroup )NULL;
53			static struct netgroup _nglist = (struct netgroup )NULL;
54			static DB *_ng_db;
55
56			/*
57			* Simple string list
58			*/
59			struct stringlist {
60			char **sl_str;
61			size_t sl_max;
62			size_t sl_cur;
63			};
64
65			static struct stringlist *_ng_sl_init(void);
66			static int _ng_sl_add(struct stringlist , char );
67			static void _ng_sl_free(struct stringlist *, int);
68			static char _ng_sl_find(struct stringlist , char *);
69			static char _ng_makekey(const char , const char *, size_t);
70			static int _ng_parse(char , char , struct netgroup **);
71			static void _ng_print(char , size_t, const struct netgroup );
72
73			static int getstring(char , int, char );
74			static struct netgroup getnetgroup(char *);
75			static int lookup(const char , char , char **, int);
76			static void addgroup(char , struct stringlist , char *);
77			static int in_check(const char , const char ,
78			const char , struct netgroup );
79			static int in_find(char , struct stringlist ,
80			char , const char , const char , const char );
81			static char in_lookup1(const char , const char *,
82			const char *, int);
83			static int in_lookup(const char , const char ,
84			const char , const char , int);
85
86			/*
87			* _ng_sl_init(): Initialize a string list
88			*/
89			static struct stringlist *
90			_ng_sl_init(void)
91			{
92			struct stringlist *sl = malloc(sizeof(struct stringlist));
93			if (sl == NULL)
94			return NULL;
95
96			sl->sl_cur = 0;
97			sl->sl_max = 20;
98			sl->sl_str = calloc(sl->sl_max, sizeof(char *));
99			if (sl->sl_str == NULL) {
100			free(sl);
101			return NULL;
102			}
103			return sl;
104			}
105
106
107			/*
108			* _ng_sl_add(): Add an item to the string list
109			*/
110			static int
111			_ng_sl_add(struct stringlist sl, char name)
112			{
113			if (sl->sl_cur == sl->sl_max - 1) {
114			char **slstr;
115
116			sl->sl_max += 20;
117			slstr = reallocarray(sl->sl_str, sl->sl_max, sizeof(char *));
118			if (slstr == NULL) {
119			free(sl->sl_str);
120			sl->sl_str = NULL;
121			return -1;
122			}
123			sl->sl_str = slstr;
124			}
125			sl->sl_str[sl->sl_cur++] = name;
126			return 0;
127			}
128
129
130			/*
131			* _ng_sl_free(): Free a stringlist
132			*/
133			static void
134			_ng_sl_free(struct stringlist *sl, int all)
135			{
136			size_t i;
137
138			if (all)
139			for (i = 0; i < sl->sl_cur; i++)
140			free(sl->sl_str[i]);
141			free(sl->sl_str);
142			free(sl);
143			}
144
145
146			/*
147			* sl_find(): Find a name in the string list
148			*/
149			static char *
150			_ng_sl_find(struct stringlist sl, char name)
151			{
152			size_t i;
153
154			for (i = 0; i < sl->sl_cur; i++)
155			if (strcmp(sl->sl_str[i], name) == 0)
156			return sl->sl_str[i];
157
158			return NULL;
159			}
160
161
162			/*
163			* getstring(): Get a string delimited by the character, skipping leading and
164			* trailing blanks and advancing the pointer
165			*/
166			static int
167			getstring(char pp, int del, char str)
168			{
169			char sp, ep, *dp;
170
171			/* skip leading blanks */
172			for (sp = pp; sp && _NG_ISSPACE(*sp); sp++)
173			continue;
174
175			/* accumulate till delimiter or space */
176			for (ep = sp; ep && ep != del && !_NG_ISSPACE(*ep); ep++)
177			continue;
178
179			/* hunt for the delimiter */
180			for (dp = ep; dp && dp != del && _NG_ISSPACE(*dp); dp++)
181			continue;
182
183			if (*dp != del) {
184			*str = NULL;
185			return 0;
186			}
187
188			*pp = ++dp;
189
190			del = (ep - sp) + 1;
191			if (del > 1) {
192			dp = malloc(del);
193			if (dp == NULL)
194			return 0;
195			memcpy(dp, sp, del);
196			dp[del - 1] = '\0';
197			} else
198			dp = NULL;
199
200			*str = dp;
201			return 1;
202			}
203
204
205			/*
206			* getnetgroup(): Parse a netgroup, and advance the pointer
207			*/
208			static struct netgroup *
209			getnetgroup(char **pp)
210			{
211			struct netgroup *ng = malloc(sizeof(struct netgroup));
212
213			if (ng == NULL)
214			return NULL;
215
216			(pp)++; / skip '(' */
217			if (!getstring(pp, ',', &ng->ng_host))
218			goto badhost;
219
220			if (!getstring(pp, ',', &ng->ng_user))
221			goto baduser;
222
223			if (!getstring(pp, ')', &ng->ng_domain))
224			goto baddomain;
225
226			#ifdef DEBUG_NG
227			{
228			char buf[1024];
229			_ng_print(buf, sizeof(buf), ng);
230			fprintf(stderr, "netgroup %s\n", buf);
231			}
232			#endif
233			return ng;
234
235			baddomain:
236			free(ng->ng_user);
237			baduser:
238			free(ng->ng_host);
239			badhost:
240			free(ng);
241			return NULL;
242			}
243
244
245			/*
246			* lookup(): Find the given key in the database or yp, and return its value
247			* in *line; returns 1 if key was found, 0 otherwise
248			*/
249			static int
250			lookup(const char ypdom, char name, char **line, int bywhat)
251			{
252			int ret;
253			#ifdef YP
254			int i;
255			char *map = NULL;
256			#endif
257
258			if (_ng_db) {
259			DBT key, data;
260			size_t len = strlen(name) + 2;
261			char *ks = malloc(len);
262
263			if (ks == NULL)
264			return 0;
265			ks[0] = bywhat;
266			memcpy(&ks[1], name, len - 1);
267
268			key.data = (u_char *) ks;
269			key.size = len;
270
271			ret = (_ng_db->get)(_ng_db, &key, &data, 0);
272			free(ks);
273			switch (ret) {
274			case 0:
275			*line = strdup(data.data);
276			if (*line == NULL)
277			return 0;
278			return 1;
279
280			case 1:
281			break;
282
283			case -1:
284			return 0;
285			}
286			}
287			#ifdef YP
288			if (ypdom) {
289			switch (bywhat) {
290			case _NG_KEYBYNAME:
291			map = "netgroup";
292			break;
293
294			case _NG_KEYBYUSER:
295			map = "netgroup.byuser";
296			break;
297
298			case _NG_KEYBYHOST:
299			map = "netgroup.byhost";
300			break;
301			}
302
303
304			if (yp_match(ypdom, map, name, strlen(name), line, &i) == 0)
305			return 1;
306			}
307			#endif
308
309			return 0;
310			}
311
312
313			/*
314			* _ng_parse(): Parse a line and return: _NG_ERROR: Syntax Error _NG_NONE:
315			* line was empty or a comment _NG_GROUP: line had a netgroup definition,
316			* returned in ng _NG_NAME: line had a netgroup name, returned in name
317			*
318			* Public since used by netgroup_mkdb
319			*/
320			static int
321			_ng_parse(char p, char name, struct netgroup **ng)
322			{
323			while (**p) {
324			if (**p == '#')
325			/* comment */
326			return _NG_NONE;
327
328			while (p && _NG_ISSPACE(p))
329			/* skipblank */
330			(*p)++;
331
332			if (**p == '(') {
333			if ((*ng = getnetgroup(p)) == NULL)
334			return _NG_ERROR;
335			return _NG_GROUP;
336			} else {
337			char *np;
338			int i;
339
340			for (np = p; p && !_NG_ISSPACE(p); (p)++)
341			continue;
342			if (np != *p) {
343			i = (*p - np) + 1;
344			*name = malloc(i);
345			if (*name == NULL)
346			return _NG_ERROR;
347			memcpy(*name, np, i);
348			(*name)[i - 1] = '\0';
349			return _NG_NAME;
350			}
351			}
352			}
353			return _NG_NONE;
354			}
355
356
357			/*
358			* addgroup(): Recursively add all the members of the netgroup to this group
359			*/
360			static void
361			addgroup(char ypdom, struct stringlist sl, char *grp)
362			{
363			char line, p;
364			struct netgroup *ng;
365			char *name;
366
367			#ifdef DEBUG_NG
368			(void) fprintf(stderr, "addgroup(%s)\n", grp);
369			#endif
370			/* check for cycles */
371			if (_ng_sl_find(sl, grp) != NULL) {
372			warnx("netgroup: Cycle in group `%s'", grp);
373			free(grp);
374			return;
375			}
376			if (_ng_sl_add(sl, grp) == -1) {
377			free(grp);
378			return;
379			}
380
381			/* Lookup this netgroup */
382			if (!lookup(ypdom, grp, &line, _NG_KEYBYNAME))
383			return;
384
385			p = line;
386
387			for (;;) {
388			switch (_ng_parse(&p, &name, &ng)) {
389			case _NG_NONE:
390			/* Done with the line */
391			free(line);
392			return;
393
394			case _NG_GROUP:
395			/* new netgroup */
396			/* add to the list */
397			ng->ng_next = _nglist;
398			_nglist = ng;
399			break;
400
401			case _NG_NAME:
402			/* netgroup name */
403			addgroup(ypdom, sl, name);
404			break;
405
406			case _NG_ERROR:
407			return;
408			}
409			}
410			}
411
412
413			/*
414			* in_check(): Compare the spec with the netgroup
415			*/
416			static int
417			in_check(const char host, const char user, const char *domain,
418			struct netgroup *ng)
419			{
420			if ((host != NULL) && (ng->ng_host != NULL) &&
421			strcmp(ng->ng_host, host) != 0)
422			return 0;
423
424			if ((user != NULL) && (ng->ng_user != NULL) &&
425			strcmp(ng->ng_user, user) != 0)
426			return 0;
427
428			if ((domain != NULL) && (ng->ng_domain != NULL) &&
429			strcmp(ng->ng_domain, domain) != 0)
430			return 0;
431
432			return 1;
433			}
434
435
436			/*
437			* in_find(): Find a match for the host, user, domain spec
438			*/
439			static int
440			in_find(char ypdom, struct stringlist sl, char grp, const char host,
441			const char user, const char domain)
442			{
443			char line, p;
444			int i;
445			struct netgroup *ng;
446			char *name;
447
448			#ifdef DEBUG_NG
449			(void) fprintf(stderr, "in_find(%s)\n", grp);
450			#endif
451			/* check for cycles */
452			if (_ng_sl_find(sl, grp) != NULL) {
453			warnx("netgroup: Cycle in group `%s'", grp);
454			free(grp);
455			return 0;
456			}
457			if (_ng_sl_add(sl, grp) == -1) {
458			free(grp);
459			return 0;
460			}
461
462			/* Lookup this netgroup */
463			if (!lookup(ypdom, grp, &line, _NG_KEYBYNAME))
464			return 0;
465
466			p = line;
467
468			for (;;) {
469			switch (_ng_parse(&p, &name, &ng)) {
470			case _NG_NONE:
471			/* Done with the line */
472			free(line);
473			return 0;
474
475			case _NG_GROUP:
476			/* new netgroup */
477			i = in_check(host, user, domain, ng);
478			free(ng->ng_host);
479			free(ng->ng_user);
480			free(ng->ng_domain);
481			free(ng);
482			if (i) {
483			free(line);
484			return 1;
485			}
486			break;
487
488			case _NG_NAME:
489			/* netgroup name */
490			if (in_find(ypdom, sl, name, host, user, domain)) {
491			free(line);
492			return 1;
493			}
494			break;
495
496			case _NG_ERROR:
497			free(line);
498			return 0;
499			}
500			}
501			}
502
503
504			/*
505			* _ng_makekey(): Make a key from the two names given. The key is of the form
506			* <name1>.<name2> Names strings are replaced with * if they are empty;
507			*/
508			static char *
509			_ng_makekey(const char s1, const char s2, size_t len)
510			{
511			char *buf = malloc(len);
512			int ret;
513
514			if (buf == NULL)
515			return NULL;
516			ret = snprintf(buf, len, "%s.%s", _NG_STAR(s1), _NG_STAR(s2));
517			if (ret < 0 \|\| ret >= len) {
518			free(buf);
519			return NULL;
520			}
521
522			return buf;
523			}
524
525			static void
526			_ng_print(char buf, size_t len, const struct netgroup ng)
527			{
528			(void) snprintf(buf, len, "(%s,%s,%s)", _NG_EMPTY(ng->ng_host),
529			_NG_EMPTY(ng->ng_user), _NG_EMPTY(ng->ng_domain));
530			}
531
532
533			/*
534			* in_lookup1(): Fast lookup for a key in the appropriate map
535			*/
536			static char *
537			in_lookup1(const char ypdom, const char key, const char *domain, int map)
538			{
539			char *line;
540			size_t len;
541			char *ptr;
542			int res;
543
544			len = (key ? strlen(key) : 1) + (domain ? strlen(domain) : 1) + 2;
545			ptr = _ng_makekey(key, domain, len);
546			if (ptr == NULL)
547			return NULL;
548			res = lookup(ypdom, ptr, &line, map);
549			free(ptr);
550			return res ? line : NULL;
551			}
552
553
554			/*
555			* in_lookup(): Fast lookup for a key in the appropriate map
556			*/
557			static int
558			in_lookup(const char ypdom, const char group, const char *key,
559			const char *domain, int map)
560			{
561			size_t len;
562			char ptr, line;
563
564			if (domain != NULL) {
565			/* Domain specified; look in "group.domain" and ".domain" /
566			if ((line = in_lookup1(ypdom, key, domain, map)) == NULL)
567			line = in_lookup1(ypdom, NULL, domain, map);
568			} else
569			line = NULL;
570
571			if (line == NULL) {
572			/*
573			* domain not specified or domain lookup failed; look in
574			* "group." and ".*"
575			*/
576			if (((line = in_lookup1(ypdom, key, NULL, map)) == NULL) &&
577			((line = in_lookup1(ypdom, NULL, NULL, map)) == NULL))
578			return 0;
579			}
580
581			len = strlen(group);
582
583			for (ptr = line; (ptr = strstr(ptr, group)) != NULL;)
584			/* Make sure we did not find a substring */
585			if ((ptr != line && ptr[-1] != ',') \|\|
586			(ptr[len] != '\0' && strchr("\n\t ,", ptr[len]) == NULL))
587			ptr++;
588			else {
589			free(line);
590			return 1;
591			}
592
593			free(line);
594			return 0;
595			}
596
597
598			void
599			endnetgrent(void)
600			{
601			for (_nglist = _nghead; _nglist != NULL; _nglist = _nghead) {
602			_nghead = _nglist->ng_next;
603			free(_nglist->ng_host);
604			free(_nglist->ng_user);
605			free(_nglist->ng_domain);
606			free(_nglist);
607			}
608
609			if (_ng_db) {
610			(void) (_ng_db->close) (_ng_db);
611			_ng_db = NULL;
612			}
613			}
614			DEF_WEAK(endnetgrent);
615
616
617			void
618			setnetgrent(const char *ng)
619			{
620			struct stringlist *sl;
621			#ifdef YP
622			char *line;
623			#endif
624			char ng_copy, ypdom = NULL;
625
626			/* Cleanup any previous storage */
627			if (_nghead != NULL)
628			endnetgrent();
629
630			sl = _ng_sl_init();
631			if (sl == NULL)
632			return;
633
634			if (_ng_db == NULL)
635			_ng_db = dbopen(_PATH_NETGROUP_DB, O_RDONLY, 0, DB_HASH, NULL);
636
637			#ifdef YP
638			/*
639			* We use yp if there is a "+" in the netgroup file, or if there is
640			* no netgroup file at all
641			*/
642			if (_ng_db == NULL \|\| lookup(NULL, "+", &line, _NG_KEYBYNAME) == 0)
643			yp_get_default_domain(&ypdom);
644			else
645			free(line);
646			#endif
647			ng_copy = strdup(ng);
648			if (ng_copy != NULL)
649			addgroup(ypdom, sl, ng_copy);
650			_nghead = _nglist;
651			_ng_sl_free(sl, 1);
652			}
653			DEF_WEAK(setnetgrent);
654
655
656			int
657			getnetgrent(const char host, const char user, const char **domain)
658			{
659			if (_nglist == NULL)
660			return 0;
661
662			*host = _nglist->ng_host;
663			*user = _nglist->ng_user;
664			*domain = _nglist->ng_domain;
665
666			_nglist = _nglist->ng_next;
667
668			return 1;
669			}
670			DEF_WEAK(getnetgrent);
671
672
673			int
674			innetgr(const char grp, const char host, const char user, const char domain)
675			{
676			char ypdom = NULL, grpdup;
677			#ifdef YP
678			char *line = NULL;
679			#endif
680			int found;
681			struct stringlist *sl;
682
683			if (_ng_db == NULL)
684			_ng_db = dbopen(_PATH_NETGROUP_DB, O_RDONLY, 0, DB_HASH, NULL);
685
686			#ifdef YP
687			/*
688			* We use yp if there is a "+" in the netgroup file, or if there is
689			* no netgroup file at all
690			*/
691			if (_ng_db == NULL)
692			yp_get_default_domain(&ypdom);
693			else if (lookup(NULL, "+", &line, _NG_KEYBYNAME) == 0)
694			yp_get_default_domain(&ypdom);
695
696			free(line);
697			#endif
698
699			/* Try the fast lookup first */
700			if (host != NULL && user == NULL) {
701			if (in_lookup(ypdom, grp, host, domain, _NG_KEYBYHOST))
702			return 1;
703			} else if (host == NULL && user != NULL) {
704			if (in_lookup(ypdom, grp, user, domain, _NG_KEYBYUSER))
705			return 1;
706			}
707
708			/* Too bad need the slow recursive way */
709			sl = _ng_sl_init();
710			if (sl == NULL)
711			return 0;
712
713			grpdup = strdup(grp);
714			if (grpdup == NULL) {
715			_ng_sl_free(sl, 1);
716			return 0;
717			}
718
719			found = in_find(ypdom, sl, grpdup, host, user, domain);
720			_ng_sl_free(sl, 1);
721
722			return found;
723			}
724			DEF_WEAK(innetgr);