2 * Copyright (c) 1992, 1993
3 * The Regents of the University of California. All rights reserved.
5 * This code is derived from software contributed to Berkeley by
6 * Rick Macklem at The University of Guelph.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by the University of
19 * California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 static const char rcsid[] =
39 "$FreeBSD: src/libexec/revnetgroup/parse_netgroup.c,v 1.7 1999/08/28 00:09:48 peter Exp $";
43 * This is a specially hacked-up version of getnetgrent.c used to parse
44 * data from the stored hash table of netgroup info rather than from a
45 * file. It's used mainly for the parse_netgroup() function. All the YP
46 * stuff and file support has been stripped out since it isn't needed.
56 * Static Variables and functions used by setnetgrent(), getnetgrent() and
58 * There are two linked lists:
59 * - linelist is just used by setnetgrent() to parse the net group file via.
61 * - netgrp is the list of entries for the current netgroup
64 struct linelist *l_next; /* Chain ptr. */
65 int l_parsed; /* Flag for cycles */
66 char *l_groupname; /* Name of netgroup */
67 char *l_line; /* Netgroup entrie(s) to be parsed */
71 struct netgrp *ng_next; /* Chain ptr */
72 char *ng_str[3]; /* Field pointers, see below */
74 #define NG_HOST 0 /* Host name */
75 #define NG_USER 1 /* User name */
76 #define NG_DOM 2 /* and Domain name */
78 static struct linelist *linehead = (struct linelist *)0;
79 static struct netgrp *nextgrp = (struct netgrp *)0;
87 static int parse_netgrp();
88 static struct linelist *read_for_group();
89 void __setnetgrent(), __endnetgrent();
91 extern struct group_entry *gtable[];
95 * Parse the netgroup file looking for the netgroup and build the list
96 * of netgrp structures. Let parse_netgrp() and read_for_group() do
105 if (group == NULL || !strlen(group))
108 if (grouphead.gr == (struct netgrp *)0 ||
109 strcmp(group, grouphead.grname)) {
111 if (parse_netgrp(group))
114 grouphead.grname = (char *)
115 malloc(strlen(group) + 1);
116 strcpy(grouphead.grname, group);
119 nextgrp = grouphead.gr;
123 * Get the next netgroup off the list.
126 __getnetgrent(hostp, userp, domp)
127 char **hostp, **userp, **domp;
130 *hostp = nextgrp->ng_str[NG_HOST];
131 *userp = nextgrp->ng_str[NG_USER];
132 *domp = nextgrp->ng_str[NG_DOM];
133 nextgrp = nextgrp->ng_next;
140 * __endnetgrent() - cleanup
145 register struct linelist *lp, *olp;
146 register struct netgrp *gp, *ogp;
152 free(olp->l_groupname);
156 linehead = (struct linelist *)0;
157 if (grouphead.grname) {
158 free(grouphead.grname);
159 grouphead.grname = (char *)0;
165 if (ogp->ng_str[NG_HOST])
166 free(ogp->ng_str[NG_HOST]);
167 if (ogp->ng_str[NG_USER])
168 free(ogp->ng_str[NG_USER]);
169 if (ogp->ng_str[NG_DOM])
170 free(ogp->ng_str[NG_DOM]);
173 grouphead.gr = (struct netgrp *)0;
177 * Parse the netgroup file setting up the linked lists.
183 register char *spos, *epos;
184 register int len, strpos;
190 struct linelist *lp = linehead;
193 * First, see if the line has already been read in.
196 if (!strcmp(group, lp->l_groupname))
200 if (lp == (struct linelist *)0 &&
201 (lp = read_for_group(group)) == (struct linelist *)0)
206 * This error message is largely superflous since the
207 * code handles the error condition sucessfully, and
208 * spewing it out from inside libc can actually hose
211 warnx("cycle in netgroup %s", lp->l_groupname);
217 /* Watch for null pointer dereferences, dammit! */
218 while (pos != NULL && *pos != '\0') {
220 grp = (struct netgrp *)malloc(sizeof (struct netgrp));
221 bzero((char *)grp, sizeof (struct netgrp));
222 grp->ng_next = grouphead.gr;
225 gpos = strsep(&pos, ")");
229 for (strpos = 0; strpos < 3; strpos++) {
230 if ((spos = strsep(&gpos, ","))) {
234 while (*spos == ' ' || *spos == '\t')
236 if ((epos = strpbrk(spos, " \t"))) {
242 grp->ng_str[strpos] = (char *)
244 bcopy(spos, grp->ng_str[strpos],
249 * All other systems I've tested
250 * return NULL for empty netgroup
251 * fields. It's up to user programs
252 * to handle the NULLs appropriately.
254 grp->ng_str[strpos] = NULL;
259 * Note: on other platforms, malformed netgroup
260 * entries are not normally flagged. While we
261 * can catch bad entries and report them, we should
262 * stay silent by default for compatibility's sake.
265 warnx("bad entry (%s%s%s%s%s) in netgroup \"%s\"",
266 grp->ng_str[NG_HOST] == NULL ? "" : grp->ng_str[NG_HOST],
267 grp->ng_str[NG_USER] == NULL ? "" : ",",
268 grp->ng_str[NG_USER] == NULL ? "" : grp->ng_str[NG_USER],
269 grp->ng_str[NG_DOM] == NULL ? "" : ",",
270 grp->ng_str[NG_DOM] == NULL ? "" : grp->ng_str[NG_DOM],
274 spos = strsep(&pos, ", \t");
275 if (parse_netgrp(spos))
278 /* Watch for null pointer dereferences, dammit! */
280 while (*pos == ' ' || *pos == ',' || *pos == '\t')
287 * Read the netgroup file and save lines until the line for the netgroup
288 * is found. Return 1 if eof is encountered.
290 static struct linelist *
291 read_for_group(group)
294 register char *pos, *spos, *linep = NULL, *olinep = NULL;
295 register int len, olen;
298 char line[LINSIZ + 1];
301 data = lookup (gtable, group);
302 sprintf(line, "%s %s", group, data);
308 while (*pos == ' ' || *pos == '\t')
311 while (*pos != ' ' && *pos != '\t' && *pos != '\n' &&
315 while (*pos == ' ' || *pos == '\t')
317 if (*pos != '\n' && *pos != '\0') {
318 lp = (struct linelist *)malloc(sizeof (*lp));
320 lp->l_groupname = (char *)malloc(len + 1);
321 bcopy(spos, lp->l_groupname, len);
322 *(lp->l_groupname + len) = '\0';
326 * Loop around handling line continuations.
329 if (*(pos + len - 1) == '\n')
331 if (*(pos + len - 1) == '\\') {
337 linep = (char *)malloc(olen + len + 1);
339 bcopy(olinep, linep, olen);
342 bcopy(pos, linep + olen, len);
344 *(linep + olen) = '\0';
349 if (fgets(line, LINSIZ, netf)) {
358 lp->l_next = linehead;
362 * If this is the one we wanted, we are done.
364 if (!strcmp(lp->l_groupname, group))
368 return ((struct linelist *)0);