lib/libc/gen/getnetgrent.c

   1 /*      $NetBSD: getnetgrent.c,v 1.40 2008/04/05 08:01:54 rtr 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  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  17  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  20  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 #if defined(LIBC_SCCS) && !defined(lint)
  31 __RCSID("$NetBSD: getnetgrent.c,v 1.40 2008/04/05 08:01:54 rtr Exp $");
  32 #endif /* LIBC_SCCS and not lint */
  33
  34 #include "namespace.h"
  35 #include <sys/types.h>
  36
  37 #include <assert.h>
  38 #include <ctype.h>
  39 #include <db.h>
  40 #include <err.h>
  41 #include <fcntl.h>
  42 #define _NETGROUP_PRIVATE
  43 #include <stringlist.h>
  44 #include <netgroup.h>
  45 #include <nsswitch.h>
  46 #include <stdarg.h>
  47 #include <stdio.h>
  48 #include <stdlib.h>
  49 #include <string.h>
  50
  51 #ifdef YP
  52 #include <rpc/rpc.h>
  53 #include <rpcsvc/ypclnt.h>
  54 #include <rpcsvc/yp_prot.h>
  55 #endif
  56
  57 #ifdef __weak_alias
  58 __weak_alias(endnetgrent,_endnetgrent)
  59 __weak_alias(getnetgrent,_getnetgrent)
  60 __weak_alias(innetgr,_innetgr)
  61 __weak_alias(setnetgrent,_setnetgrent)
  62 #endif
  63
  64 #define _NG_STAR(s)     (((s) == NULL || *(s) == '\0') ? _ngstar : s)
  65 #define _NG_EMPTY(s)    ((s) == NULL ? "" : s)
  66 #define _NG_ISSPACE(p)  (isspace((unsigned char) (p)) || (p) == '\n')
  67
  68 static const char _ngstar[] = "*";
  69 static struct netgroup *_nghead = NULL;
  70 static struct netgroup *_nglist = NULL;
  71 static DB *_ng_db;
  72
  73 static int getstring(char **, int, __aconst char **);
  74 static struct netgroup *getnetgroup(char **);
  75 static int lookup(char *, char **, int);
  76 static int addgroup(StringList *, char *);
  77 static int in_check(const char *, const char *, const char *,
  78     struct netgroup *);
  79 static int in_find(StringList *, char *, const char *, const char *,
  80     const char *);
  81 static char *in_lookup1(const char *, const char *, int);
  82 static int in_lookup(const char *, const char *, const char *, int);
  83
  84 #ifdef NSSRC_FILES
  85 static const ns_src default_files_nis[] = {
  86         { NSSRC_FILES,  NS_SUCCESS | NS_NOTFOUND },
  87 #ifdef YP
  88         { NSSRC_NIS,    NS_SUCCESS },
  89 #endif
  90         { 0, 0 },
  91 };
  92 #endif
  93
  94 /*
  95  * getstring(): Get a string delimited by the character, skipping leading and
  96  * trailing blanks and advancing the pointer
  97  */
  98 static int
  99 getstring(char **pp, int del, char __aconst **str)
 100 {
 101         size_t len;
 102         char *sp, *ep, *dp;
 103
 104         _DIAGASSERT(pp != NULL);
 105         _DIAGASSERT(str != NULL);
 106
 107         /* skip leading blanks */
 108         for (sp = *pp; *sp && _NG_ISSPACE(*sp); sp++)
 109                 continue;
 110
 111         /* accumulate till delimiter or space */
 112         for (ep = sp; *ep && *ep != del && !_NG_ISSPACE(*ep); ep++)
 113                 continue;
 114
 115         /* hunt for the delimiter */
 116         for (dp = ep; *dp && *dp != del && _NG_ISSPACE(*dp); dp++)
 117                 continue;
 118
 119         if (*dp != del) {
 120                 *str = NULL;
 121                 return 0;
 122         }
 123
 124         *pp = ++dp;
 125
 126         len = (ep - sp) + 1;
 127         if (len > 1) {
 128                 dp = malloc(len);
 129                 if (dp == NULL)
 130                         return 0;
 131                 (void)memcpy(dp, sp, len);
 132                 dp[len - 1] = '\0';
 133         } else
 134                 dp = NULL;
 135
 136         *str = dp;
 137         return 1;
 138 }
 139
 140
 141 /*
 142  * getnetgroup(): Parse a netgroup, and advance the pointer
 143  */
 144 static struct netgroup *
 145 getnetgroup(pp)
 146         char    **pp;
 147 {
 148         struct netgroup *ng;
 149
 150         _DIAGASSERT(pp != NULL);
 151         _DIAGASSERT(*pp != NULL);
 152
 153         ng = malloc(sizeof(struct netgroup));
 154         if (ng == NULL)
 155                 return NULL;
 156
 157         (*pp)++;        /* skip '(' */
 158         if (!getstring(pp, ',', &ng->ng_host))
 159                 goto badhost;
 160
 161         if (!getstring(pp, ',', &ng->ng_user))
 162                 goto baduser;
 163
 164         if (!getstring(pp, ')', &ng->ng_domain))
 165                 goto baddomain;
 166
 167 #ifdef DEBUG_NG
 168         {
 169                 char buf[1024];
 170                 (void) fprintf(stderr, "netgroup %s\n",
 171                     _ng_print(buf, sizeof(buf), ng));
 172         }
 173 #endif
 174         return ng;
 175
 176 baddomain:
 177         if (ng->ng_user)
 178                 free(ng->ng_user);
 179 baduser:
 180         if (ng->ng_host)
 181                 free(ng->ng_host);
 182 badhost:
 183         free(ng);
 184         return NULL;
 185 }
 186
 187 void
 188 _ng_cycle(const char *grp, const StringList *sl)
 189 {
 190         size_t i;
 191         warnx("netgroup: Cycle in group `%s'", grp);
 192         (void)fprintf(stderr, "groups: ");
 193         for (i = 0; i < sl->sl_cur; i++)
 194                 (void)fprintf(stderr, "%s ", sl->sl_str[i]);
 195         (void)fprintf(stderr, "\n");
 196 }
 197
 198 static int _local_lookup(void *, void *, va_list);
 199
 200 /*ARGSUSED*/
 201 static int
 202 _local_lookup(void *rv, void *cb_data, va_list ap)
 203 {
 204         char     *name = va_arg(ap, char *);
 205         char    **line = va_arg(ap, char **);
 206         int       bywhat = va_arg(ap, int);
 207
 208         DBT      key, data;
 209         size_t   len;
 210         char    *ks;
 211         int      r;
 212
 213         if (_ng_db == NULL)
 214                 return NS_UNAVAIL;
 215
 216         len = strlen(name) + 2;
 217         ks = malloc(len);
 218         if (ks == NULL)
 219                 return NS_UNAVAIL;
 220
 221         ks[0] = bywhat;
 222         (void)memcpy(&ks[1], name, len - 1);
 223
 224         key.data = (u_char *)ks;
 225         key.size = len;
 226
 227         r = (*_ng_db->get)(_ng_db, &key, &data, 0);
 228         free(ks);
 229         switch (r) {
 230         case 0:
 231                 break;
 232         case 1:
 233                 return NS_NOTFOUND;
 234         case -1:
 235                         /* XXX: call endnetgrent() here ? */
 236                 return NS_UNAVAIL;
 237         }
 238
 239         *line = strdup(data.data);
 240         if (*line == NULL)
 241                 return NS_UNAVAIL;
 242         return NS_SUCCESS;
 243 }
 244
 245 #ifdef YP
 246 static int _nis_lookup(void *, void *, va_list);
 247
 248 /*ARGSUSED*/
 249 static int
 250 _nis_lookup(void *rv, void *cb_data, va_list ap)
 251 {
 252         char     *name = va_arg(ap, char *);
 253         char    **line = va_arg(ap, char **);
 254         int       bywhat = va_arg(ap, int);
 255
 256         static char     *__ypdomain;
 257         int              i;
 258         const char      *map = NULL;
 259
 260         if(__ypdomain == NULL) {
 261                 switch (yp_get_default_domain(&__ypdomain)) {
 262                 case 0:
 263                         break;
 264                 case YPERR_RESRC:
 265                         return NS_TRYAGAIN;
 266                 default:
 267                         return NS_UNAVAIL;
 268                 }
 269         }
 270
 271         switch (bywhat) {
 272         case _NG_KEYBYNAME:
 273                 map = "netgroup";
 274                 break;
 275
 276         case _NG_KEYBYUSER:
 277                 map = "netgroup.byuser";
 278                 break;
 279
 280         case _NG_KEYBYHOST:
 281                 map = "netgroup.byhost";
 282                 break;
 283
 284         default:
 285                 abort();
 286         }
 287
 288         *line = NULL;
 289         switch (yp_match(__ypdomain, map, name, (int)strlen(name), line, &i)) {
 290         case 0:
 291                 return NS_SUCCESS;
 292         case YPERR_KEY:
 293                 if (*line)
 294                         free(*line);
 295                 return NS_NOTFOUND;
 296         default:
 297                 if (*line)
 298                         free(*line);
 299                 return NS_UNAVAIL;
 300         }
 301         /* NOTREACHED */
 302 }
 303 #endif
 304
 305 #ifdef NSSRC_FILES
 306 /*
 307  * lookup(): Find the given key in the database or yp, and return its value
 308  * in *line; returns 1 if key was found, 0 otherwise
 309  */
 310 static int
 311 lookup(char *name, char **line, int bywhat)
 312 {
 313         int             r;
 314         static const ns_dtab dtab[] = {
 315                 NS_FILES_CB(_local_lookup, NULL)
 316                 NS_NIS_CB(_nis_lookup, NULL)
 317                 NS_NULL_CB
 318         };
 319
 320         _DIAGASSERT(name != NULL);
 321         _DIAGASSERT(line != NULL);
 322
 323         r = nsdispatch(NULL, dtab, NSDB_NETGROUP, "lookup", default_files_nis,
 324             name, line, bywhat);
 325         return (r == NS_SUCCESS) ? 1 : 0;
 326 }
 327 #else
 328 static int
 329 _local_lookupv(int *rv, void *cbdata, ...)
 330 {
 331         int e;
 332         va_list ap;
 333         va_start(ap, cbdata);
 334         e = _local_lookup(rv, cbdata, ap);
 335         va_end(ap);
 336         return e;
 337 }
 338
 339 static int
 340 lookup(name, line, bywhat)
 341         char     *name;
 342         char    **line;
 343         int       bywhat;
 344 {
 345         return _local_lookupv(NULL, NULL, name, line, bywhat) == NS_SUCCESS;
 346 }
 347 #endif
 348
 349 /*
 350  * _ng_parse(): Parse a line and return: _NG_ERROR: Syntax Error _NG_NONE:
 351  * line was empty or a comment _NG_GROUP: line had a netgroup definition,
 352  * returned in ng _NG_NAME:  line had a netgroup name, returned in name
 353  *
 354  * Public since used by netgroup_mkdb
 355  */
 356 int
 357 _ng_parse(char **p, char **name, struct netgroup **ng)
 358 {
 359
 360         _DIAGASSERT(p != NULL);
 361         _DIAGASSERT(*p != NULL);
 362         _DIAGASSERT(name != NULL);
 363         _DIAGASSERT(ng != NULL);
 364
 365         while (**p) {
 366                 if (**p == '#')
 367                         /* comment */
 368                         return _NG_NONE;
 369
 370                 while (**p && _NG_ISSPACE(**p))
 371                         /* skipblank */
 372                         (*p)++;
 373
 374                 if (**p == '(') {
 375                         if ((*ng = getnetgroup(p)) == NULL)
 376                                 return _NG_ERROR;
 377                         return _NG_GROUP;
 378                 } else {
 379                         char    *np;
 380                         size_t  i;
 381
 382                         for (np = *p; **p && !_NG_ISSPACE(**p); (*p)++)
 383                                 continue;
 384                         if (np != *p) {
 385                                 i = (*p - np) + 1;
 386                                 *name = malloc(i);
 387                                 if (*name == NULL)
 388                                         return _NG_ERROR;
 389                                 (void)memcpy(*name, np, i);
 390                                 (*name)[i - 1] = '\0';
 391                                 return _NG_NAME;
 392                         }
 393                 }
 394         }
 395         return _NG_NONE;
 396 }
 397
 398
 399 /*
 400  * addgroup(): Recursively add all the members of the netgroup to this group.
 401  * returns 0 upon failure, nonzero upon success.
 402  * grp is not a valid pointer after return (either free(3)ed or allocated
 403  * to a stringlist). in either case, it shouldn't be used again.
 404  */
 405 static int
 406 addgroup(StringList *sl, char *grp)
 407 {
 408         char            *line, *p;
 409         struct netgroup *ng;
 410         char            *name;
 411
 412         _DIAGASSERT(sl != NULL);
 413         _DIAGASSERT(grp != NULL);
 414
 415 #ifdef DEBUG_NG
 416         (void)fprintf(stderr, "addgroup(%s)\n", grp);
 417 #endif
 418         /* check for cycles */
 419         if (sl_find(sl, grp) != NULL) {
 420                 _ng_cycle(grp, sl);
 421                 free(grp);
 422                 return 0;
 423         }
 424         if (sl_add(sl, grp) == -1) {
 425                 free(grp);
 426                 return 0;
 427         }
 428
 429         /* Lookup this netgroup */
 430         line = NULL;
 431         if (!lookup(grp, &line, _NG_KEYBYNAME)) {
 432                 if (line)
 433                         free(line);
 434                 return 0;
 435         }
 436
 437         p = line;
 438
 439         for (;;) {
 440                 switch (_ng_parse(&p, &name, &ng)) {
 441                 case _NG_NONE:
 442                         /* Done with the line */
 443                         free(line);
 444                         return 1;
 445
 446                 case _NG_GROUP:
 447                         /* new netgroup */
 448                         /* add to the list */
 449                         ng->ng_next = _nglist;
 450                         _nglist = ng;
 451                         break;
 452
 453                 case _NG_NAME:
 454                         /* netgroup name */
 455                         if (!addgroup(sl, name))
 456                                 return 0;
 457                         break;
 458
 459                 case _NG_ERROR:
 460                         return 0;
 461
 462                 default:
 463                         abort();
 464                 }
 465         }
 466 }
 467
 468
 469 /*
 470  * in_check(): Compare the spec with the netgroup
 471  */
 472 static int
 473 in_check(const char *host, const char *user, const char *domain,
 474     struct netgroup *ng)
 475 {
 476
 477         /* host may be NULL */
 478         /* user may be NULL */
 479         /* domain may be NULL */
 480         _DIAGASSERT(ng != NULL);
 481
 482         if ((host != NULL) && (ng->ng_host != NULL)
 483             && strcmp(ng->ng_host, host) != 0)
 484                 return 0;
 485
 486         if ((user != NULL) && (ng->ng_user != NULL)
 487             && strcmp(ng->ng_user, user) != 0)
 488                 return 0;
 489
 490         if ((domain != NULL) && (ng->ng_domain != NULL)
 491             && strcmp(ng->ng_domain, domain) != 0)
 492                 return 0;
 493
 494         return 1;
 495 }
 496
 497
 498 /*
 499  * in_find(): Find a match for the host, user, domain spec.
 500  * grp is not a valid pointer after return (either free(3)ed or allocated
 501  * to a stringlist). in either case, it shouldn't be used again.
 502  */
 503 static int
 504 in_find(StringList *sl, char *grp, const char *host, const char *user,
 505     const char *domain)
 506 {
 507         char            *line, *p;
 508         int              i;
 509         struct netgroup *ng;
 510         char            *name;
 511
 512         _DIAGASSERT(sl != NULL);
 513         _DIAGASSERT(grp != NULL);
 514         /* host may be NULL */
 515         /* user may be NULL */
 516         /* domain may be NULL */
 517
 518 #ifdef DEBUG_NG
 519         (void)fprintf(stderr, "in_find(%s)\n", grp);
 520 #endif
 521         /* check for cycles */
 522         if (sl_find(sl, grp) != NULL) {
 523                 _ng_cycle(grp, sl);
 524                 free(grp);
 525                 return 0;
 526         }
 527         if (sl_add(sl, grp) == -1) {
 528                 free(grp);
 529                 return 0;
 530         }
 531
 532         /* Lookup this netgroup */
 533         line = NULL;
 534         if (!lookup(grp, &line, _NG_KEYBYNAME)) {
 535                 if (line)
 536                         free(line);
 537                 return 0;
 538         }
 539
 540         p = line;
 541
 542         for (;;) {
 543                 switch (_ng_parse(&p, &name, &ng)) {
 544                 case _NG_NONE:
 545                         /* Done with the line */
 546                         free(line);
 547                         return 0;
 548
 549                 case _NG_GROUP:
 550                         /* new netgroup */
 551                         i = in_check(host, user, domain, ng);
 552                         if (ng->ng_host != NULL)
 553                                 free(ng->ng_host);
 554                         if (ng->ng_user != NULL)
 555                                 free(ng->ng_user);
 556                         if (ng->ng_domain != NULL)
 557                                 free(ng->ng_domain);
 558                         free(ng);
 559                         if (i) {
 560                                 free(line);
 561                                 return 1;
 562                         }
 563                         break;
 564
 565                 case _NG_NAME:
 566                         /* netgroup name */
 567                         if (in_find(sl, name, host, user, domain)) {
 568                                 free(line);
 569                                 return 1;
 570                         }
 571                         break;
 572
 573                 case _NG_ERROR:
 574                         free(line);
 575                         return 0;
 576
 577                 default:
 578                         abort();
 579                 }
 580         }
 581 }
 582
 583 /*
 584  * _ng_makekey(): Make a key from the two names given. The key is of the form
 585  * <name1>.<name2> Names strings are replaced with * if they are empty;
 586  * Returns NULL if there's a problem.
 587  */
 588 char *
 589 _ng_makekey(const char *s1, const char *s2, size_t len)
 590 {
 591         char *buf;
 592
 593         /* s1 may be NULL */
 594         /* s2 may be NULL */
 595
 596         buf = malloc(len);
 597         if (buf != NULL)
 598                 (void)snprintf(buf, len, "%s.%s", _NG_STAR(s1), _NG_STAR(s2));
 599         return buf;
 600 }
 601
 602 void
 603 _ng_print(char *buf, size_t len, const struct netgroup *ng)
 604 {
 605         _DIAGASSERT(buf != NULL);
 606         _DIAGASSERT(ng != NULL);
 607
 608         (void)snprintf(buf, len, "(%s,%s,%s)", _NG_EMPTY(ng->ng_host),
 609             _NG_EMPTY(ng->ng_user), _NG_EMPTY(ng->ng_domain));
 610 }
 611
 612
 613 /*
 614  * in_lookup1(): Fast lookup for a key in the appropriate map
 615  */
 616 static char *
 617 in_lookup1(const char *key, const char *domain, int map)
 618 {
 619         char    *line;
 620         size_t   len;
 621         char    *ptr;
 622         int      res;
 623
 624         /* key may be NULL */
 625         /* domain may be NULL */
 626
 627         len = (key ? strlen(key) : 1) + (domain ? strlen(domain) : 1) + 2;
 628         ptr = _ng_makekey(key, domain, len);
 629         if (ptr == NULL)
 630                 return NULL;
 631         res = lookup(ptr, &line, map);
 632         free(ptr);
 633         return res ? line : NULL;
 634 }
 635
 636
 637 /*
 638  * in_lookup(): Fast lookup for a key in the appropriate map
 639  */
 640 static int
 641 in_lookup(const char *group, const char *key, const char *domain, int map)
 642 {
 643         size_t   len;
 644         char    *ptr, *line;
 645
 646         _DIAGASSERT(group != NULL);
 647         /* key may be NULL */
 648         /* domain may be NULL */
 649
 650         if (domain != NULL) {
 651                 /* Domain specified; look in "group.domain" and "*.domain" */
 652                 if ((line = in_lookup1(key, domain, map)) == NULL)
 653                         line = in_lookup1(NULL, domain, map);
 654         } else
 655                 line = NULL;
 656
 657         if (line == NULL) {
 658             /*
 659              * domain not specified or domain lookup failed; look in
 660              * "group.*" and "*.*"
 661              */
 662             if (((line = in_lookup1(key, NULL, map)) == NULL) &&
 663                 ((line = in_lookup1(NULL, NULL, map)) == NULL))
 664                 return 0;
 665         }
 666
 667         len = strlen(group);
 668
 669         for (ptr = line; (ptr = strstr(ptr, group)) != NULL;)
 670                 /* Make sure we did not find a substring */
 671                 if ((ptr != line && ptr[-1] != ',') ||
 672                     (ptr[len] != '\0' && strchr("\n\t ,", ptr[len]) == NULL))
 673                         ptr++;
 674                 else {
 675                         free(line);
 676                         return 1;
 677                 }
 678
 679         free(line);
 680         return 0;
 681 }
 682
 683 /*ARGSUSED*/
 684 static int
 685 _local_endnetgrent(void *rv, void *cb_data, va_list ap)
 686 {
 687         for (_nglist = _nghead; _nglist != NULL; _nglist = _nghead) {
 688                 _nghead = _nglist->ng_next;
 689                 if (_nglist->ng_host != NULL)
 690                         free(_nglist->ng_host);
 691                 if (_nglist->ng_user != NULL)
 692                         free(_nglist->ng_user);
 693                 if (_nglist->ng_domain != NULL)
 694                         free(_nglist->ng_domain);
 695                 free(_nglist);
 696         }
 697
 698         if (_ng_db) {
 699                 (void)(*_ng_db->close)(_ng_db);
 700                 _ng_db = NULL;
 701         }
 702
 703         return NS_SUCCESS;
 704 }
 705
 706 /*ARGSUSED*/
 707 static int
 708 _local_setnetgrent(void *rv, void *cb_data, va_list ap)
 709 {
 710         const char      *ng = va_arg(ap, const char *);
 711         StringList      *sl;
 712         char            *ng_copy;
 713
 714         _DIAGASSERT(ng != NULL);
 715
 716         sl = sl_init();
 717         if (sl == NULL)
 718                 return NS_TRYAGAIN;
 719
 720         /* Cleanup any previous storage */
 721         if (_nghead != NULL)
 722                 endnetgrent();
 723
 724         if (_ng_db == NULL)
 725                 _ng_db = dbopen(_PATH_NETGROUP_DB, O_RDONLY, 0, DB_HASH, NULL);
 726
 727         ng_copy = strdup(ng);
 728         if (ng_copy != NULL)
 729                 addgroup(sl, ng_copy);
 730         _nghead = _nglist;
 731         sl_free(sl, 1);
 732
 733         return NS_SUCCESS;
 734 }
 735
 736 /*ARGSUSED*/
 737 static int
 738 _local_getnetgrent(void *rv, void *cb_data, va_list ap)
 739 {
 740         int *retval = va_arg(ap, int *);
 741         const char **host = va_arg(ap, const char **);
 742         const char **user = va_arg(ap, const char **);
 743         const char **domain = va_arg(ap, const char **);
 744
 745         _DIAGASSERT(host != NULL);
 746         _DIAGASSERT(user != NULL);
 747         _DIAGASSERT(domain != NULL);
 748
 749         *retval = 0;
 750
 751         if (_nglist == NULL)
 752                 return NS_TRYAGAIN;
 753
 754         *host   = _nglist->ng_host;
 755         *user   = _nglist->ng_user;
 756         *domain = _nglist->ng_domain;
 757
 758         _nglist = _nglist->ng_next;
 759
 760         *retval = 1;
 761
 762         return NS_SUCCESS;
 763 }
 764
 765 /*ARGSUSED*/
 766 static int
 767 _local_innetgr(void *rv, void *cb_data, va_list ap)
 768 {
 769         int *retval = va_arg(ap, int *);
 770         const char *grp = va_arg(ap, const char *);
 771         const char *host = va_arg(ap, const char *);
 772         const char *user = va_arg(ap, const char *);
 773         const char *domain = va_arg(ap, const char *);
 774
 775         int      found;
 776         StringList *sl;
 777         char *grcpy;
 778
 779         _DIAGASSERT(grp != NULL);
 780         /* host may be NULL */
 781         /* user may be NULL */
 782         /* domain may be NULL */
 783
 784         if (_ng_db == NULL)
 785                 _ng_db = dbopen(_PATH_NETGROUP_DB, O_RDONLY, 0, DB_HASH, NULL);
 786
 787         /* Try the fast lookup first */
 788         if (host != NULL && user == NULL) {
 789                 if (in_lookup(grp, host, domain, _NG_KEYBYHOST)) {
 790                         *retval = 1;
 791                         return NS_SUCCESS;
 792                 }
 793         } else if (host == NULL && user != NULL) {
 794                 if (in_lookup(grp, user, domain, _NG_KEYBYUSER)) {
 795                         *retval = 1;
 796                         return NS_SUCCESS;
 797                 }
 798         }
 799         /* If a domainname is given, we would have found a match */
 800         if (domain != NULL) {
 801                 *retval = 0;
 802                 return NS_SUCCESS;
 803         }
 804
 805         /* Too bad need the slow recursive way */
 806         sl = sl_init();
 807         if (sl == NULL) {
 808                 *retval = 0;
 809                 return NS_SUCCESS;
 810         }
 811         if ((grcpy = strdup(grp)) == NULL) {
 812                 sl_free(sl, 1);
 813                 *retval = 0;
 814                 return NS_SUCCESS;
 815         }
 816         found = in_find(sl, grcpy, host, user, domain);
 817         sl_free(sl, 1);
 818
 819         *retval = found;
 820         return NS_SUCCESS;
 821 }
 822
 823 #ifdef YP
 824
 825 /*ARGSUSED*/
 826 static int
 827 _nis_endnetgrent(void *rv, void *cb_data, va_list ap)
 828 {
 829         return _local_endnetgrent(rv, cb_data, ap);
 830 }
 831
 832 /*ARGSUSED*/
 833 static int
 834 _nis_setnetgrent(void *rv, void *cb_data, va_list ap)
 835 {
 836         return _local_setnetgrent(rv, cb_data, ap);
 837 }
 838
 839 /*ARGSUSED*/
 840 static int
 841 _nis_getnetgrent(void *rv, void *cb_data, va_list ap)
 842 {
 843         return _local_getnetgrent(rv, cb_data, ap);
 844 }
 845
 846 /*ARGSUSED*/
 847 static int
 848 _nis_innetgr(void *rv, void *cb_data, va_list ap)
 849 {
 850         return _local_innetgr(rv, cb_data, ap);
 851 }
 852
 853 #endif
 854
 855
 856 #ifdef NSSRC_FILES
 857 void
 858 endnetgrent(void)
 859 {
 860         static const ns_dtab dtab[] = {
 861                 NS_FILES_CB(_local_endnetgrent, NULL)
 862                 NS_NIS_CB(_nis_endnetgrent, NULL)
 863                 NS_NULL_CB
 864         };
 865
 866         (void) nsdispatch(NULL, dtab, NSDB_NETGROUP, "endnetgrent",
 867                           __nsdefaultcompat);
 868 }
 869 #else
 870 static int
 871 _local_endnetgrentv(int *rv, void *cbdata, ...)
 872 {
 873         int e;
 874         va_list ap;
 875         va_start(ap, cbdata);
 876         e = _local_endnetgrent(rv, cbdata, ap);
 877         va_end(ap);
 878         return e;
 879 }
 880
 881 void
 882 endnetgrent(void)
 883 {
 884         (void)_local_endnetgrentv(NULL, NULL, NULL);
 885 }
 886 #endif
 887
 888 #ifdef NSSRC_FILES
 889 void
 890 setnetgrent(const char *ng)
 891 {
 892         static const ns_dtab dtab[] = {
 893                 NS_FILES_CB(_local_setnetgrent, NULL)
 894                 NS_NIS_CB(_nis_setnetgrent, NULL)
 895                 NS_NULL_CB
 896         };
 897
 898         (void) nsdispatch(NULL, dtab, NSDB_NETGROUP, "setnetgrent",
 899                            __nsdefaultnis, ng);
 900 }
 901 #else
 902 static int
 903 _local_setnetgrentv(int *rv, void *cbdata, ...)
 904 {
 905         int e;
 906         va_list ap;
 907         va_start(ap, cbdata);
 908         e = _local_setnetgrent(rv, cbdata, ap);
 909         va_end(ap);
 910         return e;
 911 }
 912
 913 void
 914 setnetgrent(const char *ng)
 915 {
 916         (void) _local_setnetgrentv(NULL, NULL,ng);
 917 }
 918
 919 #endif
 920
 921 #ifdef NSSRC_FILES
 922 int
 923 getnetgrent(const char **host, const char **user, const char **domain)
 924 {
 925         int     r, retval;
 926         static const ns_dtab dtab[] = {
 927                 NS_FILES_CB(_local_getnetgrent, NULL)
 928                 NS_NIS_CB(_nis_getnetgrent, NULL)
 929                 NS_NULL_CB
 930         };
 931
 932         r = nsdispatch(NULL, dtab, NSDB_NETGROUP, "getnetgrent",
 933                        __nsdefaultnis, &retval, host, user, domain);
 934
 935         return (r == NS_SUCCESS) ? retval : 0;
 936 }
 937 #else
 938 static int
 939 _local_getnetgrentv(int *rv, void *cbdata, ...)
 940 {
 941         int e;
 942         va_list ap;
 943         va_start(ap, cbdata);
 944         e = _local_getnetgrent(rv, cbdata, ap);
 945         va_end(ap);
 946         return e;
 947 }
 948
 949 int
 950 getnetgrent(const char **host, const char **user, const char **domain)
 951 {
 952         return _local_getnetgrentv(NULL, NULL, host, user, domain) == NS_SUCCESS;
 953 }
 954 #endif
 955
 956 #ifdef NSSRC_FILES
 957 int
 958 innetgr(const char *grp, const char *host, const char *user,
 959         const char *domain)
 960 {
 961         int     r, retval;
 962         static const ns_dtab dtab[] = {
 963                 NS_FILES_CB(_local_innetgr, NULL)
 964                 NS_NIS_CB(_nis_innetgr, NULL)
 965                 NS_NULL_CB
 966         };
 967
 968         r = nsdispatch(NULL, dtab, NSDB_NETGROUP, "innetgr",
 969                        __nsdefaultnis, &retval, grp, host, user, domain);
 970
 971         return (r == NS_SUCCESS) ? retval : 0;
 972 }
 973 #else
 974 static int
 975 _local_innetgrv(int *rv, void *cbdata, ...)
 976 {
 977         int e;
 978         va_list ap;
 979         va_start(ap, cbdata);
 980         e = _local_innetgr(rv, cbdata, ap);
 981         va_end(ap);
 982         return e;
 983 }
 984
 985 int
 986 innetgr(const char *grp, const char *host, const char *user,
 987         const char *domain)
 988 {
 989         return _local_innetgrv(NULL, NULL, grp, host, user, domain) == NS_SUCCESS;
 990 }
 991 #endif