Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/netgroup_mkdb/stringlist.c	Lines:	0	87	0.0 %
Date:	2017-11-07	Branches:	0	100	0.0 %


/*	$OpenBSD: stringlist.c,v 1.3 2015/12/19 20:37:11 mmcc 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 <stdlib.h>
#include <ctype.h>
#include "stringlist.h"

static const char _ngstar[] = "*";

static int		getstring(char **, int, char **);
static struct netgroup	*getnetgroup(char **);

/*
 * _ng_sl_init(): Initialize a string list
 */
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
 */
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
 */
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
 */
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;
}

/*
 * _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
 */
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;
}

/*
 * _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;
 */
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;
}

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));
}

/*
 * 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;
}

/*
 * 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;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: stringlist.c,v 1.3 2015/12/19 20:37:11 mmcc 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 <stdlib.h>
39			#include <ctype.h>
40			#include "stringlist.h"
41
42			static const char _ngstar[] = "*";
43
44			static int getstring(char , int, char );
45			static struct netgroup getnetgroup(char *);
46
47			/*
48			* _ng_sl_init(): Initialize a string list
49			*/
50			struct stringlist *
51			_ng_sl_init(void)
52			{
53			struct stringlist *sl = malloc(sizeof(struct stringlist));
54			if (sl == NULL)
55			return NULL;
56
57			sl->sl_cur = 0;
58			sl->sl_max = 20;
59			sl->sl_str = calloc(sl->sl_max, sizeof(char *));
60			if (sl->sl_str == NULL) {
61			free(sl);
62			return NULL;
63			}
64			return sl;
65			}
66
67
68			/*
69			* _ng_sl_add(): Add an item to the string list
70			*/
71			int
72			_ng_sl_add(struct stringlist sl, char name)
73			{
74			if (sl->sl_cur == sl->sl_max - 1) {
75			char **slstr;
76
77			sl->sl_max += 20;
78			slstr = reallocarray(sl->sl_str, sl->sl_max, sizeof(char *));
79			if (slstr == NULL) {
80			free(sl->sl_str);
81			sl->sl_str = NULL;
82			return -1;
83			}
84			sl->sl_str = slstr;
85			}
86			sl->sl_str[sl->sl_cur++] = name;
87			return 0;
88			}
89
90
91			/*
92			* _ng_sl_free(): Free a stringlist
93			*/
94			void
95			_ng_sl_free(struct stringlist *sl, int all)
96			{
97			size_t i;
98
99			if (all)
100			for (i = 0; i < sl->sl_cur; i++)
101			free(sl->sl_str[i]);
102			free(sl->sl_str);
103			free(sl);
104			}
105
106
107			/*
108			* sl_find(): Find a name in the string list
109			*/
110			char *
111			_ng_sl_find(struct stringlist sl, char name)
112			{
113			size_t i;
114
115			for (i = 0; i < sl->sl_cur; i++)
116			if (strcmp(sl->sl_str[i], name) == 0)
117			return sl->sl_str[i];
118
119			return NULL;
120			}
121
122			/*
123			* _ng_parse(): Parse a line and return: _NG_ERROR: Syntax Error _NG_NONE:
124			* line was empty or a comment _NG_GROUP: line had a netgroup definition,
125			* returned in ng _NG_NAME: line had a netgroup name, returned in name
126			*
127			* Public since used by netgroup_mkdb
128			*/
129			int
130			_ng_parse(char p, char name, struct netgroup **ng)
131			{
132			while (**p) {
133			if (**p == '#')
134			/* comment */
135			return _NG_NONE;
136
137			while (p && _NG_ISSPACE(p))
138			/* skipblank */
139			(*p)++;
140
141			if (**p == '(') {
142			if ((*ng = getnetgroup(p)) == NULL)
143			return _NG_ERROR;
144			return _NG_GROUP;
145			} else {
146			char *np;
147			int i;
148
149			for (np = p; p && !_NG_ISSPACE(p); (p)++)
150			continue;
151			if (np != *p) {
152			i = (*p - np) + 1;
153			*name = malloc(i);
154			if (*name == NULL)
155			return _NG_ERROR;
156			memcpy(*name, np, i);
157			(*name)[i - 1] = '\0';
158			return _NG_NAME;
159			}
160			}
161			}
162			return _NG_NONE;
163			}
164
165			/*
166			* _ng_makekey(): Make a key from the two names given. The key is of the form
167			* <name1>.<name2> Names strings are replaced with * if they are empty;
168			*/
169			char *
170			_ng_makekey(const char s1, const char s2, size_t len)
171			{
172			char *buf = malloc(len);
173			int ret;
174
175			if (buf == NULL)
176			return NULL;
177			ret = snprintf(buf, len, "%s.%s", _NG_STAR(s1), _NG_STAR(s2));
178			if (ret < 0 \|\| ret >= len) {
179			free(buf);
180			return NULL;
181			}
182
183			return buf;
184			}
185
186			void
187			_ng_print(char buf, size_t len, const struct netgroup ng)
188			{
189			(void) snprintf(buf, len, "(%s,%s,%s)", _NG_EMPTY(ng->ng_host),
190			_NG_EMPTY(ng->ng_user), _NG_EMPTY(ng->ng_domain));
191			}
192
193			/*
194			* getnetgroup(): Parse a netgroup, and advance the pointer
195			*/
196			static struct netgroup *
197			getnetgroup(char **pp)
198			{
199			struct netgroup *ng = malloc(sizeof(struct netgroup));
200
201			if (ng == NULL)
202			return NULL;
203
204			(pp)++; / skip '(' */
205			if (!getstring(pp, ',', &ng->ng_host))
206			goto badhost;
207
208			if (!getstring(pp, ',', &ng->ng_user))
209			goto baduser;
210
211			if (!getstring(pp, ')', &ng->ng_domain))
212			goto baddomain;
213
214			#ifdef DEBUG_NG
215			{
216			char buf[1024];
217			_ng_print(buf, sizeof(buf), ng);
218			fprintf(stderr, "netgroup %s\n", buf);
219			}
220			#endif
221			return ng;
222
223			baddomain:
224			free(ng->ng_user);
225			baduser:
226			free(ng->ng_host);
227			badhost:
228			free(ng);
229			return NULL;
230			}
231
232			/*
233			* getstring(): Get a string delimited by the character, skipping leading and
234			* trailing blanks and advancing the pointer
235			*/
236			static int
237			getstring(char pp, int del, char str)
238			{
239			char sp, ep, *dp;
240
241			/* skip leading blanks */
242			for (sp = pp; sp && _NG_ISSPACE(*sp); sp++)
243			continue;
244
245			/* accumulate till delimiter or space */
246			for (ep = sp; ep && ep != del && !_NG_ISSPACE(*ep); ep++)
247			continue;
248
249			/* hunt for the delimiter */
250			for (dp = ep; dp && dp != del && _NG_ISSPACE(*dp); dp++)
251			continue;
252
253			if (*dp != del) {
254			*str = NULL;
255			return 0;
256			}
257
258			*pp = ++dp;
259
260			del = (ep - sp) + 1;
261			if (del > 1) {
262			dp = malloc(del);
263			if (dp == NULL)
264			return 0;
265			memcpy(dp, sp, del);
266			dp[del - 1] = '\0';
267			} else
268			dp = NULL;
269
270			*str = dp;
271			return 1;
272			}