cpdup(1): Move version and authors info to cpdup.h and bump version
[dragonfly.git] / libexec / revnetgroup / parse_netgroup.c
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.
16  * 3. Neither the name of the University nor the names of its contributors
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.
31  *
32  * $FreeBSD: src/libexec/revnetgroup/parse_netgroup.c,v 1.7 1999/08/28 00:09:48 peter Exp $
33  * $DragonFly: src/libexec/revnetgroup/parse_netgroup.c,v 1.4 2008/11/19 17:46:55 swildner Exp $
34  */
35
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>
44 #include <string.h>
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  */
57 struct 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
64 struct 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
72 static struct linelist  *linehead = NULL;
73 static struct netgrp    *nextgrp = NULL;
74 static struct {
75         struct netgrp   *gr;
76         char            *grname;
77 } grouphead = {
78         NULL,
79         NULL,
80 };
81 static int parse_netgrp(char *);
82 static struct linelist *read_for_group(char *);
83 extern 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  */
91 void
92 __setnetgrent(char *group)
93 {
94         /* Sanity check */
95
96         if (group == NULL || !strlen(group))
97                 return;
98
99         if (grouphead.gr == NULL ||
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  */
116 int
117 __getnetgrent(char **hostp, char **userp, char **domp)
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  */
132 void
133 __endnetgrent(void)
134 {
135         struct linelist *lp, *olp;
136         struct netgrp *gp, *ogp;
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         }
146         linehead = NULL;
147         if (grouphead.grname) {
148                 free(grouphead.grname);
149                 grouphead.grname = NULL;
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         }
163         grouphead.gr = NULL;
164 }
165
166 /*
167  * Parse the netgroup file setting up the linked lists.
168  */
169 static int
170 parse_netgrp(char *group)
171 {
172         char *spos, *epos;
173         int len, strpos;
174 #ifdef DEBUG
175         int fields;
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         }
189         if (lp == NULL &&
190             (lp = read_for_group(group)) == NULL)
191                 return (1);
192         if (lp->l_parsed) {
193 #ifdef DEBUG
194                 /*
195                  * This error message is largely superfluous since the
196                  * code handles the error condition successfully, and
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  */
279 static struct linelist *
280 read_for_group(char *group)
281 {
282         char *pos, *spos, *linep = NULL, *olinep = NULL;
283         int len, olen;
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         }
356         return (NULL);
357 }