cpdup(1): Move version and authors info to cpdup.h and bump version
[dragonfly.git] / libexec / revnetgroup / parse_netgroup.c
CommitLineData
984263bc
MD
1/*
2 * Copyright (c) 1992, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * Rick Macklem at The University of Guelph.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
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.
dc71b7ab 16 * 3. Neither the name of the University nor the names of its contributors
984263bc
MD
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
1de703da
MD
31 *
32 * $FreeBSD: src/libexec/revnetgroup/parse_netgroup.c,v 1.7 1999/08/28 00:09:48 peter Exp $
f8ff296d 33 * $DragonFly: src/libexec/revnetgroup/parse_netgroup.c,v 1.4 2008/11/19 17:46:55 swildner Exp $
984263bc
MD
34 */
35
984263bc
MD
36/*
37 * This is a specially hacked-up version of getnetgrent.c used to parse
38 * data from the stored hash table of netgroup info rather than from a
39 * file. It's used mainly for the parse_netgroup() function. All the YP
40 * stuff and file support has been stripped out since it isn't needed.
41 */
42
43#include <stdio.h>
d5c90ae7 44#include <string.h>
984263bc
MD
45#include <stdlib.h>
46#include <unistd.h>
47#include "hash.h"
48
49/*
50 * Static Variables and functions used by setnetgrent(), getnetgrent() and
51 * __endnetgrent().
52 * There are two linked lists:
53 * - linelist is just used by setnetgrent() to parse the net group file via.
54 * parse_netgrp()
55 * - netgrp is the list of entries for the current netgroup
56 */
57struct linelist {
58 struct linelist *l_next; /* Chain ptr. */
59 int l_parsed; /* Flag for cycles */
60 char *l_groupname; /* Name of netgroup */
61 char *l_line; /* Netgroup entrie(s) to be parsed */
62};
63
64struct netgrp {
65 struct netgrp *ng_next; /* Chain ptr */
66 char *ng_str[3]; /* Field pointers, see below */
67};
68#define NG_HOST 0 /* Host name */
69#define NG_USER 1 /* User name */
70#define NG_DOM 2 /* and Domain name */
71
60233e58
SW
72static struct linelist *linehead = NULL;
73static struct netgrp *nextgrp = NULL;
984263bc
MD
74static struct {
75 struct netgrp *gr;
76 char *grname;
77} grouphead = {
60233e58
SW
78 NULL,
79 NULL,
984263bc 80};
f8ff296d
SW
81static int parse_netgrp(char *);
82static struct linelist *read_for_group(char *);
984263bc
MD
83extern struct group_entry *gtable[];
84
85/*
86 * setnetgrent()
87 * Parse the netgroup file looking for the netgroup and build the list
88 * of netgrp structures. Let parse_netgrp() and read_for_group() do
89 * most of the work.
90 */
91void
f8ff296d 92__setnetgrent(char *group)
984263bc
MD
93{
94 /* Sanity check */
95
96 if (group == NULL || !strlen(group))
97 return;
98
60233e58 99 if (grouphead.gr == NULL ||
984263bc
MD
100 strcmp(group, grouphead.grname)) {
101 __endnetgrent();
102 if (parse_netgrp(group))
103 __endnetgrent();
104 else {
105 grouphead.grname = (char *)
106 malloc(strlen(group) + 1);
107 strcpy(grouphead.grname, group);
108 }
109 }
110 nextgrp = grouphead.gr;
111}
112
113/*
114 * Get the next netgroup off the list.
115 */
116int
f8ff296d 117__getnetgrent(char **hostp, char **userp, char **domp)
984263bc
MD
118{
119 if (nextgrp) {
120 *hostp = nextgrp->ng_str[NG_HOST];
121 *userp = nextgrp->ng_str[NG_USER];
122 *domp = nextgrp->ng_str[NG_DOM];
123 nextgrp = nextgrp->ng_next;
124 return (1);
125 }
126 return (0);
127}
128
129/*
130 * __endnetgrent() - cleanup
131 */
132void
f8ff296d 133__endnetgrent(void)
984263bc 134{
f8ff296d
SW
135 struct linelist *lp, *olp;
136 struct netgrp *gp, *ogp;
984263bc
MD
137
138 lp = linehead;
139 while (lp) {
140 olp = lp;
141 lp = lp->l_next;
142 free(olp->l_groupname);
143 free(olp->l_line);
144 free((char *)olp);
145 }
60233e58 146 linehead = NULL;
984263bc
MD
147 if (grouphead.grname) {
148 free(grouphead.grname);
60233e58 149 grouphead.grname = NULL;
984263bc
MD
150 }
151 gp = grouphead.gr;
152 while (gp) {
153 ogp = gp;
154 gp = gp->ng_next;
155 if (ogp->ng_str[NG_HOST])
156 free(ogp->ng_str[NG_HOST]);
157 if (ogp->ng_str[NG_USER])
158 free(ogp->ng_str[NG_USER]);
159 if (ogp->ng_str[NG_DOM])
160 free(ogp->ng_str[NG_DOM]);
161 free((char *)ogp);
162 }
60233e58 163 grouphead.gr = NULL;
984263bc
MD
164}
165
166/*
167 * Parse the netgroup file setting up the linked lists.
168 */
169static int
f8ff296d 170parse_netgrp(char *group)
984263bc 171{
f8ff296d
SW
172 char *spos, *epos;
173 int len, strpos;
984263bc 174#ifdef DEBUG
f8ff296d 175 int fields;
984263bc
MD
176#endif
177 char *pos, *gpos;
178 struct netgrp *grp;
179 struct linelist *lp = linehead;
180
181 /*
182 * First, see if the line has already been read in.
183 */
184 while (lp) {
185 if (!strcmp(group, lp->l_groupname))
186 break;
187 lp = lp->l_next;
188 }
60233e58
SW
189 if (lp == NULL &&
190 (lp = read_for_group(group)) == NULL)
984263bc
MD
191 return (1);
192 if (lp->l_parsed) {
193#ifdef DEBUG
194 /*
d0d91865
MD
195 * This error message is largely superfluous since the
196 * code handles the error condition successfully, and
984263bc
MD
197 * spewing it out from inside libc can actually hose
198 * certain programs.
199 */
200 warnx("cycle in netgroup %s", lp->l_groupname);
201#endif
202 return (1);
203 } else
204 lp->l_parsed = 1;
205 pos = lp->l_line;
206 /* Watch for null pointer dereferences, dammit! */
207 while (pos != NULL && *pos != '\0') {
208 if (*pos == '(') {
209 grp = (struct netgrp *)malloc(sizeof (struct netgrp));
210 bzero((char *)grp, sizeof (struct netgrp));
211 grp->ng_next = grouphead.gr;
212 grouphead.gr = grp;
213 pos++;
214 gpos = strsep(&pos, ")");
215#ifdef DEBUG
216 fields = 0;
217#endif
218 for (strpos = 0; strpos < 3; strpos++) {
219 if ((spos = strsep(&gpos, ","))) {
220#ifdef DEBUG
221 fields++;
222#endif
223 while (*spos == ' ' || *spos == '\t')
224 spos++;
225 if ((epos = strpbrk(spos, " \t"))) {
226 *epos = '\0';
227 len = epos - spos;
228 } else
229 len = strlen(spos);
230 if (len > 0) {
231 grp->ng_str[strpos] = (char *)
232 malloc(len + 1);
233 bcopy(spos, grp->ng_str[strpos],
234 len + 1);
235 }
236 } else {
237 /*
238 * All other systems I've tested
239 * return NULL for empty netgroup
240 * fields. It's up to user programs
241 * to handle the NULLs appropriately.
242 */
243 grp->ng_str[strpos] = NULL;
244 }
245 }
246#ifdef DEBUG
247 /*
248 * Note: on other platforms, malformed netgroup
249 * entries are not normally flagged. While we
250 * can catch bad entries and report them, we should
251 * stay silent by default for compatibility's sake.
252 */
253 if (fields < 3)
254 warnx("bad entry (%s%s%s%s%s) in netgroup \"%s\"",
255 grp->ng_str[NG_HOST] == NULL ? "" : grp->ng_str[NG_HOST],
256 grp->ng_str[NG_USER] == NULL ? "" : ",",
257 grp->ng_str[NG_USER] == NULL ? "" : grp->ng_str[NG_USER],
258 grp->ng_str[NG_DOM] == NULL ? "" : ",",
259 grp->ng_str[NG_DOM] == NULL ? "" : grp->ng_str[NG_DOM],
260 lp->l_groupname);
261#endif
262 } else {
263 spos = strsep(&pos, ", \t");
264 if (parse_netgrp(spos))
265 continue;
266 }
267 /* Watch for null pointer dereferences, dammit! */
268 if (pos != NULL)
269 while (*pos == ' ' || *pos == ',' || *pos == '\t')
270 pos++;
271 }
272 return (0);
273}
274
275/*
276 * Read the netgroup file and save lines until the line for the netgroup
277 * is found. Return 1 if eof is encountered.
278 */
279static struct linelist *
f8ff296d 280read_for_group(char *group)
984263bc 281{
f8ff296d
SW
282 char *pos, *spos, *linep = NULL, *olinep = NULL;
283 int len, olen;
984263bc
MD
284 int cont;
285 struct linelist *lp;
286 char line[LINSIZ + 1];
287 char *data = NULL;
288
289 data = lookup (gtable, group);
290 sprintf(line, "%s %s", group, data);
291 pos = (char *)&line;
292#ifdef CANT_HAPPEN
293 if (*pos == '#')
294 continue;
295#endif
296 while (*pos == ' ' || *pos == '\t')
297 pos++;
298 spos = pos;
299 while (*pos != ' ' && *pos != '\t' && *pos != '\n' &&
300 *pos != '\0')
301 pos++;
302 len = pos - spos;
303 while (*pos == ' ' || *pos == '\t')
304 pos++;
305 if (*pos != '\n' && *pos != '\0') {
306 lp = (struct linelist *)malloc(sizeof (*lp));
307 lp->l_parsed = 0;
308 lp->l_groupname = (char *)malloc(len + 1);
309 bcopy(spos, lp->l_groupname, len);
310 *(lp->l_groupname + len) = '\0';
311 len = strlen(pos);
312 olen = 0;
313 /*
314 * Loop around handling line continuations.
315 */
316 do {
317 if (*(pos + len - 1) == '\n')
318 len--;
319 if (*(pos + len - 1) == '\\') {
320 len--;
321 cont = 1;
322 } else
323 cont = 0;
324 if (len > 0) {
325 linep = (char *)malloc(olen + len + 1);
326 if (olen > 0) {
327 bcopy(olinep, linep, olen);
328 free(olinep);
329 }
330 bcopy(pos, linep + olen, len);
331 olen += len;
332 *(linep + olen) = '\0';
333 olinep = linep;
334 }
335#ifdef CANT_HAPPEN
336 if (cont) {
337 if (fgets(line, LINSIZ, netf)) {
338 pos = line;
339 len = strlen(pos);
340 } else
341 cont = 0;
342 }
343#endif
344 } while (cont);
345 lp->l_line = linep;
346 lp->l_next = linehead;
347 linehead = lp;
348#ifdef CANT_HAPPEN
349 /*
350 * If this is the one we wanted, we are done.
351 */
352 if (!strcmp(lp->l_groupname, group))
353#endif
354 return (lp);
355 }
60233e58 356 return (NULL);
984263bc 357}