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. 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.
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
32 * @(#)getnetgrent.c 8.2 (Berkeley) 4/27/95
33 * $FreeBSD: src/lib/libc/gen/getnetgrent.c,v 1.35 2007/01/09 00:27:54 imp Exp $
46 * We want to be able to use NIS netgroups properly while retaining
47 * the ability to use a local /etc/netgroup file. Unfortunately, you
48 * can't really do both at the same time - at least, not efficiently.
49 * NetBSD deals with this problem by creating a netgroup database
50 * using Berkeley DB (just like the password database) that allows
51 * for lookups using netgroup, netgroup.byuser or netgroup.byhost
52 * searches. This is a neat idea, but I don't have time to implement
53 * something like that now. (I think ultimately it would be nice
54 * if we DB-fied the group and netgroup stuff all in one shot, but
55 * for now I'm satisfied just to have something that works well
56 * without requiring massive code changes.)
58 * Therefore, to still permit the use of the local file and maintain
59 * optimum NIS performance, we allow for the following conditions:
61 * - If /etc/netgroup does not exist and NIS is turned on, we use
64 * - If /etc/netgroup exists but is empty, we use NIS netgroups
67 * - If /etc/netgroup exists and contains _only_ a '+', we use
70 * - If /etc/netgroup exists, contains locally defined netgroups
71 * and a '+', we use a mixture of NIS and the local entries.
72 * This method should return the same NIS data as just using
73 * NIS alone, but it will be slower if the NIS netgroup database
74 * is large (innetgr() in particular will suffer since extra
75 * processing has to be done in order to determine memberships
76 * using just the raw netgroup data).
78 * - If /etc/netgroup exists and contains only locally defined
79 * netgroup entries, we use just those local entries and ignore
80 * NIS (this is the original, pre-NIS behavior).
84 #include <rpcsvc/yp_prot.h>
85 #include <rpcsvc/ypclnt.h>
86 #include <sys/types.h>
88 #include <sys/param.h>
89 #include <sys/errno.h>
90 static char *_netgr_yp_domain
;
92 static int _netgr_yp_enabled
;
93 static int _yp_innetgr
;
96 #ifndef _PATH_NETGROUP
97 #define _PATH_NETGROUP "/etc/netgroup"
101 * Static Variables and functions used by setnetgrent(), getnetgrent() and
103 * There are two linked lists:
104 * - linelist is just used by setnetgrent() to parse the net group file via.
106 * - netgrp is the list of entries for the current netgroup
109 struct linelist
*l_next
; /* Chain ptr. */
110 int l_parsed
; /* Flag for cycles */
111 char *l_groupname
; /* Name of netgroup */
112 char *l_line
; /* Netgroup entrie(s) to be parsed */
116 struct netgrp
*ng_next
; /* Chain ptr */
117 char *ng_str
[3]; /* Field pointers, see below */
119 #define NG_HOST 0 /* Host name */
120 #define NG_USER 1 /* User name */
121 #define NG_DOM 2 /* and Domain name */
123 static struct linelist
*linehead
= NULL
;
124 static struct netgrp
*nextgrp
= NULL
;
132 static FILE *netf
= NULL
;
134 static int parse_netgrp(const char *);
135 static struct linelist
*read_for_group(const char *);
137 #define LINSIZ 1024 /* Length of netgroup file line */
141 * Parse the netgroup file looking for the netgroup and build the list
142 * of netgrp structures. Let parse_netgrp() and read_for_group() do
146 setnetgrent(const char *group
)
149 struct stat _yp_statp
;
155 if (group
== NULL
|| !strlen(group
))
158 if (grouphead
.gr
== NULL
||
159 strcmp(group
, grouphead
.grname
)) {
162 /* Presumed guilty until proven innocent. */
165 * If /etc/netgroup doesn't exist or is empty,
166 * use NIS exclusively.
168 if (((stat(_PATH_NETGROUP
, &_yp_statp
) < 0) &&
169 errno
== ENOENT
) || _yp_statp
.st_size
== 0)
170 _use_only_yp
= _netgr_yp_enabled
= 1;
171 if ((netf
= fopen(_PATH_NETGROUP
,"r")) != NULL
||_use_only_yp
){
173 * Icky: grab the first character of the netgroup file
174 * and turn on NIS if it's a '+'. rewind the stream
175 * afterwards so we don't goof up read_for_group() later.
178 fscanf(netf
, "%c", &_yp_plus
);
181 _use_only_yp
= _netgr_yp_enabled
= 1;
184 * If we were called specifically for an innetgr()
185 * lookup and we're in NIS-only mode, short-circuit
186 * parse_netgroup() and cut directly to the chase.
188 if (_use_only_yp
&& _yp_innetgr
) {
195 if ((netf
= fopen(_PATH_NETGROUP
, "r"))) {
197 if (parse_netgrp(group
))
200 grouphead
.grname
= (char *)
201 malloc(strlen(group
) + 1);
202 strcpy(grouphead
.grname
, group
);
208 nextgrp
= grouphead
.gr
;
212 * Get the next netgroup off the list.
215 getnetgrent(char **hostp
, char **userp
, char **domp
)
222 *hostp
= nextgrp
->ng_str
[NG_HOST
];
223 *userp
= nextgrp
->ng_str
[NG_USER
];
224 *domp
= nextgrp
->ng_str
[NG_DOM
];
225 nextgrp
= nextgrp
->ng_next
;
232 * endnetgrent() - cleanup
237 struct linelist
*lp
, *olp
;
238 struct netgrp
*gp
, *ogp
;
244 free(olp
->l_groupname
);
249 if (grouphead
.grname
) {
250 free(grouphead
.grname
);
251 grouphead
.grname
= NULL
;
257 if (ogp
->ng_str
[NG_HOST
])
258 free(ogp
->ng_str
[NG_HOST
]);
259 if (ogp
->ng_str
[NG_USER
])
260 free(ogp
->ng_str
[NG_USER
]);
261 if (ogp
->ng_str
[NG_DOM
])
262 free(ogp
->ng_str
[NG_DOM
]);
268 _netgr_yp_enabled
= 0;
274 _listmatch(const char *list
, const char *group
, int len
)
276 const char *ptr
= list
;
278 int glen
= strlen(group
);
280 /* skip possible leading whitespace */
281 while(isspace((unsigned char)*ptr
))
284 while (ptr
< list
+ len
) {
286 while(*ptr
!= ',' && *ptr
!= '\0' && !isspace((unsigned char)*ptr
))
288 if (strncmp(cptr
, group
, glen
) == 0 && glen
== (ptr
- cptr
))
290 while(*ptr
== ',' || isspace((unsigned char)*ptr
))
298 _revnetgr_lookup(char *lookupdom
, char *map
, const char *str
,
299 const char *dom
, const char *group
)
302 char key
[MAXHOSTNAMELEN
];
306 for (rot
= 0; ; rot
++) {
308 case(0): snprintf(key
, MAXHOSTNAMELEN
, "%s.%s",
309 str
, dom
?dom
:lookupdom
);
311 case(1): snprintf(key
, MAXHOSTNAMELEN
, "%s.*",
314 case(2): snprintf(key
, MAXHOSTNAMELEN
, "*.%s",
317 case(3): snprintf(key
, MAXHOSTNAMELEN
, "*.*");
321 y
= yp_match(lookupdom
, map
, key
, strlen(key
), &result
,
324 rv
= _listmatch(result
, group
, resultlen
);
327 } else if (y
!= YPERR_KEY
) {
329 * If we get an error other than 'no
330 * such key in map' then something is
331 * wrong and we should stop the search.
340 * Search for a match in a netgroup.
343 innetgr(const char *group
, const char *host
, const char *user
, const char *dom
)
345 char *hst
, *usr
, *dm
;
348 if (group
== NULL
|| !strlen(group
))
358 * If we're in NIS-only mode, do the search using
359 * NIS 'reverse netgroup' lookups.
361 * What happens with 'reverse netgroup' lookups:
363 * 1) try 'reverse netgroup' lookup
364 * 1.a) if host is specified and user is null:
365 * look in netgroup.byhost
366 * (try host.domain, host.*, *.domain or *.*)
367 * if found, return yes
368 * 1.b) if user is specified and host is null:
369 * look in netgroup.byuser
370 * (try host.domain, host.*, *.domain or *.*)
371 * if found, return yes
372 * 1.c) if both host and user are specified,
373 * don't do 'reverse netgroup' lookup. It won't work.
374 * 1.d) if neither host ane user are specified (why?!?)
375 * don't do 'reverse netgroup' lookup either.
376 * 2) if domain is specified and 'reverse lookup' is done:
377 * 'reverse lookup' was authoritative. bye bye.
378 * 3) otherwise, too bad, try it the slow way.
380 if (_use_only_yp
&& (host
== NULL
) != (user
== NULL
)) {
382 if(yp_get_default_domain(&_netgr_yp_domain
))
384 ret
= _revnetgr_lookup(_netgr_yp_domain
,
385 host
?"netgroup.byhost":"netgroup.byuser",
386 host
?host
:user
, dom
, group
);
389 else if (ret
== 0 && dom
!= NULL
)
396 while (getnetgrent(&hst
, &usr
, &dm
))
397 if ((host
== NULL
|| hst
== NULL
|| !strcmp(host
, hst
)) &&
398 (user
== NULL
|| usr
== NULL
|| !strcmp(user
, usr
)) &&
399 ( dom
== NULL
|| dm
== NULL
|| !strcmp(dom
, dm
))) {
408 * Parse the netgroup file setting up the linked lists.
411 parse_netgrp(const char *group
)
420 struct linelist
*lp
= linehead
;
423 * First, see if the line has already been read in.
426 if (!strcmp(group
, lp
->l_groupname
))
431 (lp
= read_for_group(group
)) == NULL
)
436 * This error message is largely superflous since the
437 * code handles the error condition successfully, and
438 * spewing it out from inside libc can actually hose
441 fprintf(stderr
, "Cycle in netgroup %s\n", lp
->l_groupname
);
447 /* Watch for null pointer dereferences, dammit! */
448 while (pos
!= NULL
&& *pos
!= '\0') {
450 grp
= (struct netgrp
*)malloc(sizeof (struct netgrp
));
451 bzero((char *)grp
, sizeof (struct netgrp
));
452 grp
->ng_next
= grouphead
.gr
;
455 gpos
= strsep(&pos
, ")");
459 for (strpos
= 0; strpos
< 3; strpos
++) {
460 if ((spos
= strsep(&gpos
, ","))) {
464 while (*spos
== ' ' || *spos
== '\t')
466 if ((epos
= strpbrk(spos
, " \t"))) {
472 grp
->ng_str
[strpos
] = (char *)
474 bcopy(spos
, grp
->ng_str
[strpos
],
479 * All other systems I've tested
480 * return NULL for empty netgroup
481 * fields. It's up to user programs
482 * to handle the NULLs appropriately.
484 grp
->ng_str
[strpos
] = NULL
;
489 * Note: on other platforms, malformed netgroup
490 * entries are not normally flagged. While we
491 * can catch bad entries and report them, we should
492 * stay silent by default for compatibility's sake.
495 fprintf(stderr
, "Bad entry (%s%s%s%s%s) in netgroup \"%s\"\n",
496 grp
->ng_str
[NG_HOST
] == NULL
? "" : grp
->ng_str
[NG_HOST
],
497 grp
->ng_str
[NG_USER
] == NULL
? "" : ",",
498 grp
->ng_str
[NG_USER
] == NULL
? "" : grp
->ng_str
[NG_USER
],
499 grp
->ng_str
[NG_DOM
] == NULL
? "" : ",",
500 grp
->ng_str
[NG_DOM
] == NULL
? "" : grp
->ng_str
[NG_DOM
],
504 spos
= strsep(&pos
, ", \t");
505 if (parse_netgrp(spos
))
510 while (*pos
== ' ' || *pos
== ',' || *pos
== '\t')
517 * Read the netgroup file and save lines until the line for the netgroup
518 * is found. Return 1 if eof is encountered.
520 static struct linelist
*
521 read_for_group(const char *group
)
523 char *pos
, *spos
, *linep
= NULL
, *olinep
= NULL
;
527 char line
[LINSIZ
+ 2];
532 while (_netgr_yp_enabled
|| fgets(line
, LINSIZ
, netf
) != NULL
) {
533 if (_netgr_yp_enabled
) {
534 if(!_netgr_yp_domain
)
535 if(yp_get_default_domain(&_netgr_yp_domain
))
537 if (yp_match(_netgr_yp_domain
, "netgroup", group
,
538 strlen(group
), &result
, &resultlen
)) {
543 _netgr_yp_enabled
= 0;
547 snprintf(line
, LINSIZ
, "%s %s", group
, result
);
551 while (fgets(line
, LINSIZ
, netf
) != NULL
) {
556 _netgr_yp_enabled
= 1;
562 while (*pos
== ' ' || *pos
== '\t')
565 while (*pos
!= ' ' && *pos
!= '\t' && *pos
!= '\n' &&
569 while (*pos
== ' ' || *pos
== '\t')
571 if (*pos
!= '\n' && *pos
!= '\0') {
572 lp
= (struct linelist
*)malloc(sizeof (*lp
));
574 lp
->l_groupname
= (char *)malloc(len
+ 1);
575 bcopy(spos
, lp
->l_groupname
, len
);
576 *(lp
->l_groupname
+ len
) = '\0';
581 * Loop around handling line continuations.
584 if (*(pos
+ len
- 1) == '\n')
586 if (*(pos
+ len
- 1) == '\\') {
592 linep
= (char *)malloc(olen
+ len
+ 1);
594 bcopy(olinep
, linep
, olen
);
597 bcopy(pos
, linep
+ olen
, len
);
599 *(linep
+ olen
) = '\0';
603 if (fgets(line
, LINSIZ
, netf
)) {
611 lp
->l_next
= linehead
;
615 * If this is the one we wanted, we are done.
617 if (!strcmp(lp
->l_groupname
, group
))
623 * Yucky. The recursive nature of this whole mess might require
624 * us to make more than one pass through the netgroup file.
625 * This might be best left outside the #ifdef YP, but YP is
626 * defined by default anyway, so I'll leave it like this
627 * until I know better.