lib/libc/gen/getgrent.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2003 Networks Associates Technology, Inc.
   5  * All rights reserved.
   6  *
   7  * This software was developed for the FreeBSD Project by
   8  * Jacques A. Vidrine, Safeport Network Services, and Network
   9  * Associates Laboratories, the Security Research Division of Network
  10  * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035
  11  * ("CBOSS"), as part of the DARPA CHATS research program.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  */
  35 #include <sys/cdefs.h>
  36 __FBSDID("$FreeBSD$");
  37
  38 #include "namespace.h"
  39 #include <sys/param.h>
  40 #ifdef YP
  41 #include <rpc/rpc.h>
  42 #include <rpcsvc/yp_prot.h>
  43 #include <rpcsvc/ypclnt.h>
  44 #endif
  45 #include <assert.h>
  46 #include <ctype.h>
  47 #include <errno.h>
  48 #ifdef HESIOD
  49 #include <hesiod.h>
  50 #endif
  51 #include <grp.h>
  52 #include <nsswitch.h>
  53 #include <pthread.h>
  54 #include <pthread_np.h>
  55 #include <stdio.h>
  56 #include <stdlib.h>
  57 #include <string.h>
  58 #include <syslog.h>
  59 #include <unistd.h>
  60 #include "un-namespace.h"
  61 #include "libc_private.h"
  62 #include "nss_tls.h"
  63 #ifdef NS_CACHING
  64 #include "nscache.h"
  65 #endif
  66
  67 enum constants {
  68         GRP_STORAGE_INITIAL     = 1 << 10, /* 1 KByte */
  69         GRP_STORAGE_MAX         = 1 << 20, /* 1 MByte */
  70         SETGRENT                = 1,
  71         ENDGRENT                = 2,
  72         HESIOD_NAME_MAX         = 256,
  73 };
  74
  75 static const ns_src defaultsrc[] = {
  76         { NSSRC_COMPAT, NS_SUCCESS },
  77         { NULL, 0 }
  78 };
  79
  80 int      __getgroupmembership(const char *, gid_t, gid_t *, int, int *);
  81 int      __gr_match_entry(const char *, size_t, enum nss_lookup_type,
  82             const char *, gid_t);
  83 int      __gr_parse_entry(char *, size_t, struct group *, char *, size_t,
  84             int *);
  85
  86 static  int      is_comment_line(const char *, size_t);
  87
  88 union key {
  89         const char      *name;
  90         gid_t            gid;
  91 };
  92 static  struct group *getgr(int (*)(union key, struct group *, char *, size_t,
  93                     struct group **), union key);
  94 static  int      wrap_getgrnam_r(union key, struct group *, char *, size_t,
  95                     struct group **);
  96 static  int      wrap_getgrgid_r(union key, struct group *, char *, size_t,
  97                     struct group **);
  98 static  int      wrap_getgrent_r(union key, struct group *, char *, size_t,
  99                     struct group **);
 100
 101 struct files_state {
 102         FILE    *fp;
 103         int      stayopen;
 104 };
 105 static  void     files_endstate(void *);
 106 NSS_TLS_HANDLING(files);
 107 static  int      files_setgrent(void *, void *, va_list);
 108 static  int      files_group(void *, void *, va_list);
 109
 110
 111 #ifdef HESIOD
 112 struct dns_state {
 113         long    counter;
 114 };
 115 static  void     dns_endstate(void *);
 116 NSS_TLS_HANDLING(dns);
 117 static  int      dns_setgrent(void *, void *, va_list);
 118 static  int      dns_group(void *, void *, va_list);
 119 #endif
 120
 121
 122 #ifdef YP
 123 struct nis_state {
 124         char     domain[MAXHOSTNAMELEN];
 125         int      done;
 126         char    *key;
 127         int      keylen;
 128 };
 129 static  void     nis_endstate(void *);
 130 NSS_TLS_HANDLING(nis);
 131 static  int      nis_setgrent(void *, void *, va_list);
 132 static  int      nis_group(void *, void *, va_list);
 133 #endif
 134
 135 struct compat_state {
 136         FILE    *fp;
 137         int      stayopen;
 138         char    *name;
 139         enum _compat {
 140                 COMPAT_MODE_OFF = 0,
 141                 COMPAT_MODE_ALL,
 142                 COMPAT_MODE_NAME
 143         }        compat;
 144 };
 145 static  void     compat_endstate(void *);
 146 NSS_TLS_HANDLING(compat);
 147 static  int      compat_setgrent(void *, void *, va_list);
 148 static  int      compat_group(void *, void *, va_list);
 149
 150 static  int     gr_addgid(gid_t, gid_t *, int, int *);
 151 static  int     getgroupmembership_fallback(void *, void *, va_list);
 152
 153 #ifdef NS_CACHING
 154 static  int      grp_id_func(char *, size_t *, va_list, void *);
 155 static  int      grp_marshal_func(char *, size_t *, void *, va_list, void *);
 156 static  int      grp_unmarshal_func(char *, size_t, void *, va_list, void *);
 157
 158 static int
 159 grp_id_func(char *buffer, size_t *buffer_size, va_list ap, void *cache_mdata)
 160 {
 161         char    *name;
 162         gid_t   gid;
 163
 164         size_t  desired_size, size;
 165         int     res = NS_UNAVAIL;
 166         enum nss_lookup_type lookup_type;
 167
 168
 169         lookup_type = (enum nss_lookup_type)(uintptr_t)cache_mdata;
 170         switch (lookup_type) {
 171         case nss_lt_name:
 172                 name = va_arg(ap, char *);
 173                 size = strlen(name);
 174                 desired_size = sizeof(enum nss_lookup_type) + size + 1;
 175                 if (desired_size > *buffer_size) {
 176                         res = NS_RETURN;
 177                         goto fin;
 178                 }
 179
 180                 memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type));
 181                 memcpy(buffer + sizeof(enum nss_lookup_type), name, size + 1);
 182
 183                 res = NS_SUCCESS;
 184                 break;
 185         case nss_lt_id:
 186                 gid = va_arg(ap, gid_t);
 187                 desired_size = sizeof(enum nss_lookup_type) + sizeof(gid_t);
 188                 if (desired_size > *buffer_size) {
 189                         res = NS_RETURN;
 190                         goto fin;
 191                 }
 192
 193                 memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type));
 194                 memcpy(buffer + sizeof(enum nss_lookup_type), &gid,
 195                     sizeof(gid_t));
 196
 197                 res = NS_SUCCESS;
 198                 break;
 199         default:
 200                 /* should be unreachable */
 201                 return (NS_UNAVAIL);
 202         }
 203
 204 fin:
 205         *buffer_size = desired_size;
 206         return (res);
 207 }
 208
 209 static int
 210 grp_marshal_func(char *buffer, size_t *buffer_size, void *retval, va_list ap,
 211     void *cache_mdata)
 212 {
 213         char *name __unused;
 214         gid_t gid __unused;
 215         struct group *grp;
 216         char *orig_buf __unused;
 217         size_t orig_buf_size __unused;
 218         struct group new_grp;
 219         size_t desired_size, size, mem_size;
 220         char *p, **mem;
 221
 222         switch ((enum nss_lookup_type)(uintptr_t)cache_mdata) {
 223         case nss_lt_name:
 224                 name = va_arg(ap, char *);
 225                 break;
 226         case nss_lt_id:
 227                 gid = va_arg(ap, gid_t);
 228                 break;
 229         case nss_lt_all:
 230                 break;
 231         default:
 232                 /* should be unreachable */
 233                 return (NS_UNAVAIL);
 234         }
 235
 236         grp = va_arg(ap, struct group *);
 237         orig_buf = va_arg(ap, char *);
 238         orig_buf_size = va_arg(ap, size_t);
 239
 240         desired_size = _ALIGNBYTES + sizeof(struct group) + sizeof(char *);
 241
 242         if (grp->gr_name != NULL)
 243                 desired_size += strlen(grp->gr_name) + 1;
 244         if (grp->gr_passwd != NULL)
 245                 desired_size += strlen(grp->gr_passwd) + 1;
 246
 247         if (grp->gr_mem != NULL) {
 248                 mem_size = 0;
 249                 for (mem = grp->gr_mem; *mem; ++mem) {
 250                         desired_size += strlen(*mem) + 1;
 251                         ++mem_size;
 252                 }
 253
 254                 desired_size += _ALIGNBYTES + (mem_size + 1) * sizeof(char *);
 255         }
 256
 257         if (desired_size > *buffer_size) {
 258                 /* this assignment is here for future use */
 259                 *buffer_size = desired_size;
 260                 return (NS_RETURN);
 261         }
 262
 263         memcpy(&new_grp, grp, sizeof(struct group));
 264         memset(buffer, 0, desired_size);
 265
 266         *buffer_size = desired_size;
 267         p = buffer + sizeof(struct group) + sizeof(char *);
 268         memcpy(buffer + sizeof(struct group), &p, sizeof(char *));
 269         p = (char *)_ALIGN(p);
 270
 271         if (new_grp.gr_name != NULL) {
 272                 size = strlen(new_grp.gr_name);
 273                 memcpy(p, new_grp.gr_name, size);
 274                 new_grp.gr_name = p;
 275                 p += size + 1;
 276         }
 277
 278         if (new_grp.gr_passwd != NULL) {
 279                 size = strlen(new_grp.gr_passwd);
 280                 memcpy(p, new_grp.gr_passwd, size);
 281                 new_grp.gr_passwd = p;
 282                 p += size + 1;
 283         }
 284
 285         if (new_grp.gr_mem != NULL) {
 286                 p = (char *)_ALIGN(p);
 287                 memcpy(p, new_grp.gr_mem, sizeof(char *) * mem_size);
 288                 new_grp.gr_mem = (char **)p;
 289                 p += sizeof(char *) * (mem_size + 1);
 290
 291                 for (mem = new_grp.gr_mem; *mem; ++mem) {
 292                         size = strlen(*mem);
 293                         memcpy(p, *mem, size);
 294                         *mem = p;
 295                         p += size + 1;
 296                 }
 297         }
 298
 299         memcpy(buffer, &new_grp, sizeof(struct group));
 300         return (NS_SUCCESS);
 301 }
 302
 303 static int
 304 grp_unmarshal_func(char *buffer, size_t buffer_size, void *retval, va_list ap,
 305     void *cache_mdata)
 306 {
 307         char *name __unused;
 308         gid_t gid __unused;
 309         struct group *grp;
 310         char *orig_buf;
 311         size_t orig_buf_size;
 312         int *ret_errno;
 313
 314         char *p;
 315         char **mem;
 316
 317         switch ((enum nss_lookup_type)(uintptr_t)cache_mdata) {
 318         case nss_lt_name:
 319                 name = va_arg(ap, char *);
 320                 break;
 321         case nss_lt_id:
 322                 gid = va_arg(ap, gid_t);
 323                 break;
 324         case nss_lt_all:
 325                 break;
 326         default:
 327                 /* should be unreachable */
 328                 return (NS_UNAVAIL);
 329         }
 330
 331         grp = va_arg(ap, struct group *);
 332         orig_buf = va_arg(ap, char *);
 333         orig_buf_size = va_arg(ap, size_t);
 334         ret_errno = va_arg(ap, int *);
 335
 336         if (orig_buf_size + sizeof(struct group) + sizeof(char *) < buffer_size)
 337         {
 338                 *ret_errno = ERANGE;
 339                 return (NS_RETURN);
 340         } else if (buffer_size < sizeof(struct group) + sizeof(char *)) {
 341                 /*
 342                  * nscd(8) sometimes returns buffer_size=1 for nonexistent
 343                  * entries.
 344                  */
 345                 *ret_errno = 0;
 346                 return (NS_NOTFOUND);
 347         }
 348
 349         memcpy(grp, buffer, sizeof(struct group));
 350         memcpy(&p, buffer + sizeof(struct group), sizeof(char *));
 351
 352         if (orig_buf_size + sizeof(struct group) + sizeof(char *) +
 353             _ALIGN(p) - (size_t)p < buffer_size) {
 354                 *ret_errno = ERANGE;
 355                 return (NS_RETURN);
 356         }
 357
 358         orig_buf = (char *)_ALIGN(orig_buf);
 359         memcpy(orig_buf, buffer + sizeof(struct group) + sizeof(char *) +
 360             _ALIGN(p) - (size_t)p,
 361             buffer_size - sizeof(struct group) - sizeof(char *) -
 362             _ALIGN(p) + (size_t)p);
 363         p = (char *)_ALIGN(p);
 364
 365         NS_APPLY_OFFSET(grp->gr_name, orig_buf, p, char *);
 366         NS_APPLY_OFFSET(grp->gr_passwd, orig_buf, p, char *);
 367         if (grp->gr_mem != NULL) {
 368                 NS_APPLY_OFFSET(grp->gr_mem, orig_buf, p, char **);
 369
 370                 for (mem = grp->gr_mem; *mem; ++mem)
 371                         NS_APPLY_OFFSET(*mem, orig_buf, p, char *);
 372         }
 373
 374         if (retval != NULL)
 375                 *((struct group **)retval) = grp;
 376
 377         return (NS_SUCCESS);
 378 }
 379
 380 NSS_MP_CACHE_HANDLING(group);
 381 #endif /* NS_CACHING */
 382
 383 #ifdef NS_CACHING
 384 static const nss_cache_info setgrent_cache_info = NS_MP_CACHE_INFO_INITIALIZER(
 385         group, (void *)nss_lt_all,
 386         NULL, NULL);
 387 #endif
 388
 389 static const ns_dtab setgrent_dtab[] = {
 390         { NSSRC_FILES, files_setgrent, (void *)SETGRENT },
 391 #ifdef HESIOD
 392         { NSSRC_DNS, dns_setgrent, (void *)SETGRENT },
 393 #endif
 394 #ifdef YP
 395         { NSSRC_NIS, nis_setgrent, (void *)SETGRENT },
 396 #endif
 397         { NSSRC_COMPAT, compat_setgrent, (void *)SETGRENT },
 398 #ifdef NS_CACHING
 399         NS_CACHE_CB(&setgrent_cache_info)
 400 #endif
 401         { NULL, NULL, NULL }
 402 };
 403
 404 #ifdef NS_CACHING
 405 static const nss_cache_info endgrent_cache_info = NS_MP_CACHE_INFO_INITIALIZER(
 406         group, (void *)nss_lt_all,
 407         NULL, NULL);
 408 #endif
 409
 410 static const ns_dtab endgrent_dtab[] = {
 411         { NSSRC_FILES, files_setgrent, (void *)ENDGRENT },
 412 #ifdef HESIOD
 413         { NSSRC_DNS, dns_setgrent, (void *)ENDGRENT },
 414 #endif
 415 #ifdef YP
 416         { NSSRC_NIS, nis_setgrent, (void *)ENDGRENT },
 417 #endif
 418         { NSSRC_COMPAT, compat_setgrent, (void *)ENDGRENT },
 419 #ifdef NS_CACHING
 420         NS_CACHE_CB(&endgrent_cache_info)
 421 #endif
 422         { NULL, NULL, NULL }
 423 };
 424
 425 #ifdef NS_CACHING
 426 static const nss_cache_info getgrent_r_cache_info = NS_MP_CACHE_INFO_INITIALIZER(
 427         group, (void *)nss_lt_all,
 428         grp_marshal_func, grp_unmarshal_func);
 429 #endif
 430
 431 static const ns_dtab getgrent_r_dtab[] = {
 432         { NSSRC_FILES, files_group, (void *)nss_lt_all },
 433 #ifdef HESIOD
 434         { NSSRC_DNS, dns_group, (void *)nss_lt_all },
 435 #endif
 436 #ifdef YP
 437         { NSSRC_NIS, nis_group, (void *)nss_lt_all },
 438 #endif
 439         { NSSRC_COMPAT, compat_group, (void *)nss_lt_all },
 440 #ifdef NS_CACHING
 441         NS_CACHE_CB(&getgrent_r_cache_info)
 442 #endif
 443         { NULL, NULL, NULL }
 444 };
 445
 446 static int
 447 gr_addgid(gid_t gid, gid_t *groups, int maxgrp, int *grpcnt)
 448 {
 449         int     ret, dupc;
 450
 451         for (dupc = 1; dupc < MIN(maxgrp, *grpcnt); dupc++) {
 452                 if (groups[dupc] == gid)
 453                         return 1;
 454         }
 455
 456         ret = 1;
 457         if (*grpcnt < maxgrp)
 458                 groups[*grpcnt] = gid;
 459         else
 460                 ret = 0;
 461
 462         (*grpcnt)++;
 463
 464         return ret;
 465 }
 466
 467 static int
 468 getgroupmembership_fallback(void *retval, void *mdata, va_list ap)
 469 {
 470         const ns_src src[] = {
 471                 { mdata, NS_SUCCESS },
 472                 { NULL, 0}
 473         };
 474         struct group    grp;
 475         struct group    *grp_p;
 476         char            *buf;
 477         size_t          bufsize;
 478         const char      *uname;
 479         gid_t           *groups;
 480         gid_t           agroup;
 481         int             maxgrp, *grpcnt;
 482         int             i, rv, ret_errno;
 483
 484         /*
 485          * As this is a fallback method, only provided src
 486          * list will be respected during methods search.
 487          */
 488         assert(src[0].name != NULL);
 489
 490         uname = va_arg(ap, const char *);
 491         agroup = va_arg(ap, gid_t);
 492         groups = va_arg(ap, gid_t *);
 493         maxgrp = va_arg(ap, int);
 494         grpcnt = va_arg(ap, int *);
 495
 496         rv = NS_UNAVAIL;
 497
 498         buf = malloc(GRP_STORAGE_INITIAL);
 499         if (buf == NULL)
 500                 goto out;
 501
 502         bufsize = GRP_STORAGE_INITIAL;
 503
 504         gr_addgid(agroup, groups, maxgrp, grpcnt);
 505
 506         _nsdispatch(NULL, setgrent_dtab, NSDB_GROUP, "setgrent", src, 0);
 507         for (;;) {
 508                 do {
 509                         ret_errno = 0;
 510                         grp_p = NULL;
 511                         rv = _nsdispatch(&grp_p, getgrent_r_dtab, NSDB_GROUP,
 512                             "getgrent_r", src, &grp, buf, bufsize, &ret_errno);
 513
 514                         if (grp_p == NULL && ret_errno == ERANGE) {
 515                                 free(buf);
 516                                 if ((bufsize << 1) > GRP_STORAGE_MAX) {
 517                                         buf = NULL;
 518                                         errno = ERANGE;
 519                                         goto out;
 520                                 }
 521
 522                                 bufsize <<= 1;
 523                                 buf = malloc(bufsize);
 524                                 if (buf == NULL) {
 525                                         goto out;
 526                                 }
 527                         }
 528                 } while (grp_p == NULL && ret_errno == ERANGE);
 529
 530                 if (ret_errno != 0) {
 531                         errno = ret_errno;
 532                         goto out;
 533                 }
 534
 535                 if (grp_p == NULL)
 536                         break;
 537
 538                 for (i = 0; grp.gr_mem[i]; i++) {
 539                         if (strcmp(grp.gr_mem[i], uname) == 0)
 540                             gr_addgid(grp.gr_gid, groups, maxgrp, grpcnt);
 541                 }
 542         }
 543
 544         _nsdispatch(NULL, endgrent_dtab, NSDB_GROUP, "endgrent", src);
 545 out:
 546         free(buf);
 547         return (rv);
 548 }
 549
 550 void
 551 setgrent(void)
 552 {
 553         (void)_nsdispatch(NULL, setgrent_dtab, NSDB_GROUP, "setgrent", defaultsrc, 0);
 554 }
 555
 556
 557 int
 558 setgroupent(int stayopen)
 559 {
 560         (void)_nsdispatch(NULL, setgrent_dtab, NSDB_GROUP, "setgrent", defaultsrc,
 561             stayopen);
 562         return (1);
 563 }
 564
 565
 566 void
 567 endgrent(void)
 568 {
 569         (void)_nsdispatch(NULL, endgrent_dtab, NSDB_GROUP, "endgrent", defaultsrc);
 570 }
 571
 572
 573 int
 574 getgrent_r(struct group *grp, char *buffer, size_t bufsize,
 575     struct group **result)
 576 {
 577         int     rv, ret_errno;
 578
 579         ret_errno = 0;
 580         *result = NULL;
 581         rv = _nsdispatch(result, getgrent_r_dtab, NSDB_GROUP, "getgrent_r", defaultsrc,
 582             grp, buffer, bufsize, &ret_errno);
 583         if (rv == NS_SUCCESS)
 584                 return (0);
 585         else
 586                 return (ret_errno);
 587 }
 588
 589
 590 int
 591 getgrnam_r(const char *name, struct group *grp, char *buffer, size_t bufsize,
 592     struct group **result)
 593 {
 594 #ifdef NS_CACHING
 595         static const nss_cache_info cache_info =
 596                 NS_COMMON_CACHE_INFO_INITIALIZER(
 597                 group, (void *)nss_lt_name,
 598                 grp_id_func, grp_marshal_func, grp_unmarshal_func);
 599 #endif
 600
 601         static const ns_dtab dtab[] = {
 602                 { NSSRC_FILES, files_group, (void *)nss_lt_name },
 603 #ifdef HESIOD
 604                 { NSSRC_DNS, dns_group, (void *)nss_lt_name },
 605 #endif
 606 #ifdef YP
 607                 { NSSRC_NIS, nis_group, (void *)nss_lt_name },
 608 #endif
 609                 { NSSRC_COMPAT, compat_group, (void *)nss_lt_name },
 610 #ifdef NS_CACHING
 611                 NS_CACHE_CB(&cache_info)
 612 #endif
 613                 { NULL, NULL, NULL }
 614         };
 615         int     rv, ret_errno;
 616
 617         ret_errno = 0;
 618         *result = NULL;
 619         rv = _nsdispatch(result, dtab, NSDB_GROUP, "getgrnam_r", defaultsrc,
 620             name, grp, buffer, bufsize, &ret_errno);
 621         if (rv == NS_SUCCESS)
 622                 return (0);
 623         else
 624                 return (ret_errno);
 625 }
 626
 627
 628 int
 629 getgrgid_r(gid_t gid, struct group *grp, char *buffer, size_t bufsize,
 630     struct group **result)
 631 {
 632 #ifdef NS_CACHING
 633         static const nss_cache_info cache_info =
 634                 NS_COMMON_CACHE_INFO_INITIALIZER(
 635                 group, (void *)nss_lt_id,
 636                 grp_id_func, grp_marshal_func, grp_unmarshal_func);
 637 #endif
 638
 639         static const ns_dtab dtab[] = {
 640                 { NSSRC_FILES, files_group, (void *)nss_lt_id },
 641 #ifdef HESIOD
 642                 { NSSRC_DNS, dns_group, (void *)nss_lt_id },
 643 #endif
 644 #ifdef YP
 645                 { NSSRC_NIS, nis_group, (void *)nss_lt_id },
 646 #endif
 647                 { NSSRC_COMPAT, compat_group, (void *)nss_lt_id },
 648 #ifdef NS_CACHING
 649                 NS_CACHE_CB(&cache_info)
 650 #endif
 651                 { NULL, NULL, NULL }
 652         };
 653         int     rv, ret_errno;
 654
 655         ret_errno = 0;
 656         *result = NULL;
 657         rv = _nsdispatch(result, dtab, NSDB_GROUP, "getgrgid_r", defaultsrc,
 658             gid, grp, buffer, bufsize, &ret_errno);
 659         if (rv == NS_SUCCESS)
 660                 return (0);
 661         else
 662                 return (ret_errno);
 663 }
 664
 665
 666
 667 int
 668 __getgroupmembership(const char *uname, gid_t agroup, gid_t *groups,
 669         int maxgrp, int *grpcnt)
 670 {
 671         static const ns_dtab dtab[] = {
 672                 NS_FALLBACK_CB(getgroupmembership_fallback)
 673                 { NULL, NULL, NULL }
 674         };
 675
 676         assert(uname != NULL);
 677         /* groups may be NULL if just sizing when invoked with maxgrp = 0 */
 678         assert(grpcnt != NULL);
 679
 680         *grpcnt = 0;
 681         (void)_nsdispatch(NULL, dtab, NSDB_GROUP, "getgroupmembership",
 682             defaultsrc, uname, agroup, groups, maxgrp, grpcnt);
 683
 684         /* too many groups found? */
 685         return (*grpcnt > maxgrp ? -1 : 0);
 686 }
 687
 688
 689 static struct group      grp;
 690 static char             *grp_storage;
 691 static size_t            grp_storage_size;
 692
 693 static struct group *
 694 getgr(int (*fn)(union key, struct group *, char *, size_t, struct group **),
 695     union key key)
 696 {
 697         int              rv;
 698         struct group    *res;
 699
 700         if (grp_storage == NULL) {
 701                 grp_storage = malloc(GRP_STORAGE_INITIAL);
 702                 if (grp_storage == NULL)
 703                         return (NULL);
 704                 grp_storage_size = GRP_STORAGE_INITIAL;
 705         }
 706         do {
 707                 rv = fn(key, &grp, grp_storage, grp_storage_size, &res);
 708                 if (res == NULL && rv == ERANGE) {
 709                         free(grp_storage);
 710                         if ((grp_storage_size << 1) > GRP_STORAGE_MAX) {
 711                                 grp_storage = NULL;
 712                                 errno = ERANGE;
 713                                 return (NULL);
 714                         }
 715                         grp_storage_size <<= 1;
 716                         grp_storage = malloc(grp_storage_size);
 717                         if (grp_storage == NULL)
 718                                 return (NULL);
 719                 }
 720         } while (res == NULL && rv == ERANGE);
 721         if (rv != 0)
 722                 errno = rv;
 723         return (res);
 724 }
 725
 726
 727 static int
 728 wrap_getgrnam_r(union key key, struct group *grp, char *buffer, size_t bufsize,
 729     struct group **res)
 730 {
 731         return (getgrnam_r(key.name, grp, buffer, bufsize, res));
 732 }
 733
 734
 735 static int
 736 wrap_getgrgid_r(union key key, struct group *grp, char *buffer, size_t bufsize,
 737     struct group **res)
 738 {
 739         return (getgrgid_r(key.gid, grp, buffer, bufsize, res));
 740 }
 741
 742
 743 static int
 744 wrap_getgrent_r(union key key __unused, struct group *grp, char *buffer,
 745     size_t bufsize, struct group **res)
 746 {
 747         return (getgrent_r(grp, buffer, bufsize, res));
 748 }
 749
 750
 751 struct group *
 752 getgrnam(const char *name)
 753 {
 754         union key key;
 755
 756         key.name = name;
 757         return (getgr(wrap_getgrnam_r, key));
 758 }
 759
 760
 761 struct group *
 762 getgrgid(gid_t gid)
 763 {
 764         union key key;
 765
 766         key.gid = gid;
 767         return (getgr(wrap_getgrgid_r, key));
 768 }
 769
 770
 771 struct group *
 772 getgrent(void)
 773 {
 774         union key key;
 775
 776         key.gid = 0; /* not used */
 777         return (getgr(wrap_getgrent_r, key));
 778 }
 779
 780
 781 static int
 782 is_comment_line(const char *s, size_t n)
 783 {
 784         const char      *eom;
 785
 786         eom = &s[n];
 787
 788         for (; s < eom; s++)
 789                 if (*s == '#' || !isspace((unsigned char)*s))
 790                         break;
 791         return (*s == '#' || s == eom);
 792 }
 793
 794
 795 /*
 796  * files backend
 797  */
 798 static void
 799 files_endstate(void *p)
 800 {
 801
 802         if (p == NULL)
 803                 return;
 804         if (((struct files_state *)p)->fp != NULL)
 805                 fclose(((struct files_state *)p)->fp);
 806         free(p);
 807 }
 808
 809
 810 static int
 811 files_setgrent(void *retval, void *mdata, va_list ap)
 812 {
 813         struct files_state *st;
 814         int              rv, stayopen;
 815
 816         rv = files_getstate(&st);
 817         if (rv != 0)
 818                 return (NS_UNAVAIL);
 819         switch ((enum constants)(uintptr_t)mdata) {
 820         case SETGRENT:
 821                 stayopen = va_arg(ap, int);
 822                 if (st->fp != NULL)
 823                         rewind(st->fp);
 824                 else if (stayopen)
 825                         st->fp = fopen(_PATH_GROUP, "re");
 826                 st->stayopen = stayopen;
 827                 break;
 828         case ENDGRENT:
 829                 if (st->fp != NULL) {
 830                         fclose(st->fp);
 831                         st->fp = NULL;
 832                 }
 833                 break;
 834         default:
 835                 break;
 836         }
 837         return (NS_UNAVAIL);
 838 }
 839
 840
 841 static int
 842 files_group(void *retval, void *mdata, va_list ap)
 843 {
 844         struct files_state      *st;
 845         enum nss_lookup_type     how;
 846         const char              *name, *line;
 847         struct group            *grp;
 848         gid_t                    gid;
 849         char                    *buffer;
 850         size_t                   bufsize, linesize;
 851         off_t                    pos;
 852         int                      fresh, rv, stayopen, *errnop;
 853
 854         fresh = 0;
 855         name = NULL;
 856         gid = (gid_t)-1;
 857         how = (enum nss_lookup_type)(uintptr_t)mdata;
 858         switch (how) {
 859         case nss_lt_name:
 860                 name = va_arg(ap, const char *);
 861                 break;
 862         case nss_lt_id:
 863                 gid = va_arg(ap, gid_t);
 864                 break;
 865         case nss_lt_all:
 866                 break;
 867         default:
 868                 return (NS_NOTFOUND);
 869         }
 870         grp = va_arg(ap, struct group *);
 871         buffer = va_arg(ap, char *);
 872         bufsize = va_arg(ap, size_t);
 873         errnop = va_arg(ap, int *);
 874         *errnop = files_getstate(&st);
 875         if (*errnop != 0)
 876                 return (NS_UNAVAIL);
 877         if (st->fp == NULL) {
 878                 st->fp = fopen(_PATH_GROUP, "re");
 879                 if (st->fp == NULL) {
 880                         *errnop = errno;
 881                         return (NS_UNAVAIL);
 882                 }
 883                 fresh = 1;
 884         }
 885         stayopen = (how == nss_lt_all || !fresh) ? 1 : st->stayopen;
 886         if (stayopen)
 887                 pos = ftello(st->fp);
 888         if (how != nss_lt_all && !fresh)
 889                 rewind(st->fp);
 890         rv = NS_NOTFOUND;
 891         while ((line = fgetln(st->fp, &linesize)) != NULL) {
 892                 if (line[linesize-1] == '\n')
 893                         linesize--;
 894                 rv = __gr_match_entry(line, linesize, how, name, gid);
 895                 if (rv != NS_SUCCESS)
 896                         continue;
 897                 /* We need room at least for the line, a string NUL
 898                  * terminator, alignment padding, and one (char *)
 899                  * pointer for the member list terminator.
 900                  */
 901                 if (bufsize <= linesize + _ALIGNBYTES + sizeof(char *)) {
 902                         *errnop = ERANGE;
 903                         rv = NS_RETURN;
 904                         break;
 905                 }
 906                 memcpy(buffer, line, linesize);
 907                 buffer[linesize] = '\0';
 908                 rv = __gr_parse_entry(buffer, linesize, grp,
 909                     &buffer[linesize + 1], bufsize - linesize - 1, errnop);
 910                 if (rv & NS_TERMINATE)
 911                         break;
 912                 if (how == nss_lt_all)
 913                         pos = ftello(st->fp);
 914         }
 915         if (st->fp != NULL && !stayopen) {
 916                 fclose(st->fp);
 917                 st->fp = NULL;
 918         }
 919         if (st->fp != NULL && how != nss_lt_all)
 920                 fseeko(st->fp, pos, SEEK_SET);
 921         if (rv == NS_SUCCESS && retval != NULL)
 922                 *(struct group **)retval = grp;
 923         else if (rv == NS_RETURN && *errnop == ERANGE && st->fp != NULL)
 924                 fseeko(st->fp, pos, SEEK_SET);
 925         return (rv);
 926 }
 927
 928
 929 #ifdef HESIOD
 930 /*
 931  * dns backend
 932  */
 933 static void
 934 dns_endstate(void *p)
 935 {
 936
 937         free(p);
 938 }
 939
 940
 941 static int
 942 dns_setgrent(void *retval, void *cb_data, va_list ap)
 943 {
 944         struct dns_state        *st;
 945         int                      rv;
 946
 947         rv = dns_getstate(&st);
 948         if (rv != 0)
 949                 return (NS_UNAVAIL);
 950         st->counter = 0;
 951         return (NS_UNAVAIL);
 952 }
 953
 954
 955 static int
 956 dns_group(void *retval, void *mdata, va_list ap)
 957 {
 958         char                     buf[HESIOD_NAME_MAX];
 959         struct dns_state        *st;
 960         struct group            *grp;
 961         const char              *name, *label;
 962         void                    *ctx;
 963         char                    *buffer, **hes;
 964         size_t                   bufsize, adjsize, linesize;
 965         gid_t                    gid;
 966         enum nss_lookup_type     how;
 967         int                      rv, *errnop;
 968
 969         ctx = NULL;
 970         hes = NULL;
 971         name = NULL;
 972         gid = (gid_t)-1;
 973         how = (enum nss_lookup_type)(uintptr_t)mdata;
 974         switch (how) {
 975         case nss_lt_name:
 976                 name = va_arg(ap, const char *);
 977                 break;
 978         case nss_lt_id:
 979                 gid = va_arg(ap, gid_t);
 980                 break;
 981         case nss_lt_all:
 982                 break;
 983         }
 984         grp     = va_arg(ap, struct group *);
 985         buffer  = va_arg(ap, char *);
 986         bufsize = va_arg(ap, size_t);
 987         errnop  = va_arg(ap, int *);
 988         *errnop = dns_getstate(&st);
 989         if (*errnop != 0)
 990                 return (NS_UNAVAIL);
 991         if (hesiod_init(&ctx) != 0) {
 992                 *errnop = errno;
 993                 rv = NS_UNAVAIL;
 994                 goto fin;
 995         }
 996         do {
 997                 rv = NS_NOTFOUND;
 998                 switch (how) {
 999                 case nss_lt_name:
1000                         label = name;
1001                         break;
1002                 case nss_lt_id:
1003                         if (snprintf(buf, sizeof(buf), "%lu",
1004                             (unsigned long)gid) >= sizeof(buf))
1005                                 goto fin;
1006                         label = buf;
1007                         break;
1008                 case nss_lt_all:
1009                         if (st->counter < 0)
1010                                 goto fin;
1011                         if (snprintf(buf, sizeof(buf), "group-%ld",
1012                             st->counter++) >= sizeof(buf))
1013                                 goto fin;
1014                         label = buf;
1015                         break;
1016                 }
1017                 hes = hesiod_resolve(ctx, label,
1018                     how == nss_lt_id ? "gid" : "group");
1019                 if ((how == nss_lt_id && hes == NULL &&
1020                     (hes = hesiod_resolve(ctx, buf, "group")) == NULL) ||
1021                     hes == NULL) {
1022                         if (how == nss_lt_all)
1023                                 st->counter = -1;
1024                         if (errno != ENOENT)
1025                                 *errnop = errno;
1026                         goto fin;
1027                 }
1028                 rv = __gr_match_entry(hes[0], strlen(hes[0]), how, name, gid);
1029                 if (rv != NS_SUCCESS) {
1030                         hesiod_free_list(ctx, hes);
1031                         hes = NULL;
1032                         continue;
1033                 }
1034                 /* We need room at least for the line, a string NUL
1035                  * terminator, alignment padding, and one (char *)
1036                  * pointer for the member list terminator.
1037                  */
1038                 adjsize = bufsize - _ALIGNBYTES - sizeof(char *);
1039                 linesize = strlcpy(buffer, hes[0], adjsize);
1040                 if (linesize >= adjsize) {
1041                         *errnop = ERANGE;
1042                         rv = NS_RETURN;
1043                         goto fin;
1044                 }
1045                 hesiod_free_list(ctx, hes);
1046                 hes = NULL;
1047                 rv = __gr_parse_entry(buffer, linesize, grp,
1048                     &buffer[linesize + 1], bufsize - linesize - 1, errnop);
1049         } while (how == nss_lt_all && !(rv & NS_TERMINATE));
1050 fin:
1051         if (hes != NULL)
1052                 hesiod_free_list(ctx, hes);
1053         if (ctx != NULL)
1054                 hesiod_end(ctx);
1055         if (rv == NS_SUCCESS && retval != NULL)
1056                 *(struct group **)retval = grp;
1057         return (rv);
1058 }
1059 #endif /* HESIOD */
1060
1061
1062 #ifdef YP
1063 /*
1064  * nis backend
1065  */
1066 static void
1067 nis_endstate(void *p)
1068 {
1069
1070         if (p == NULL)
1071                 return;
1072         free(((struct nis_state *)p)->key);
1073         free(p);
1074 }
1075
1076
1077 static int
1078 nis_setgrent(void *retval, void *cb_data, va_list ap)
1079 {
1080         struct nis_state        *st;
1081         int                      rv;
1082
1083         rv = nis_getstate(&st);
1084         if (rv != 0)
1085                 return (NS_UNAVAIL);
1086         st->done = 0;
1087         free(st->key);
1088         st->key = NULL;
1089         return (NS_UNAVAIL);
1090 }
1091
1092
1093 static int
1094 nis_group(void *retval, void *mdata, va_list ap)
1095 {
1096         char             *map;
1097         struct nis_state *st;
1098         struct group    *grp;
1099         const char      *name;
1100         char            *buffer, *key, *result;
1101         size_t           bufsize;
1102         gid_t            gid;
1103         enum nss_lookup_type how;
1104         int             *errnop, keylen, resultlen, rv;
1105
1106         name = NULL;
1107         gid = (gid_t)-1;
1108         how = (enum nss_lookup_type)(uintptr_t)mdata;
1109         switch (how) {
1110         case nss_lt_name:
1111                 name = va_arg(ap, const char *);
1112                 map = "group.byname";
1113                 break;
1114         case nss_lt_id:
1115                 gid = va_arg(ap, gid_t);
1116                 map = "group.bygid";
1117                 break;
1118         case nss_lt_all:
1119                 map = "group.byname";
1120                 break;
1121         }
1122         grp     = va_arg(ap, struct group *);
1123         buffer  = va_arg(ap, char *);
1124         bufsize = va_arg(ap, size_t);
1125         errnop  = va_arg(ap, int *);
1126         *errnop = nis_getstate(&st);
1127         if (*errnop != 0)
1128                 return (NS_UNAVAIL);
1129         if (st->domain[0] == '\0') {
1130                 if (getdomainname(st->domain, sizeof(st->domain)) != 0) {
1131                         *errnop = errno;
1132                         return (NS_UNAVAIL);
1133                 }
1134         }
1135         result = NULL;
1136         do {
1137                 rv = NS_NOTFOUND;
1138                 switch (how) {
1139                 case nss_lt_name:
1140                         if (strlcpy(buffer, name, bufsize) >= bufsize)
1141                                 goto erange;
1142                         break;
1143                 case nss_lt_id:
1144                         if (snprintf(buffer, bufsize, "%lu",
1145                             (unsigned long)gid) >= bufsize)
1146                                 goto erange;
1147                         break;
1148                 case nss_lt_all:
1149                         if (st->done)
1150                                 goto fin;
1151                         break;
1152                 }
1153                 result = NULL;
1154                 if (how == nss_lt_all) {
1155                         if (st->key == NULL)
1156                                 rv = yp_first(st->domain, map, &st->key,
1157                                     &st->keylen, &result, &resultlen);
1158                         else {
1159                                 key = st->key;
1160                                 keylen = st->keylen;
1161                                 st->key = NULL;
1162                                 rv = yp_next(st->domain, map, key, keylen,
1163                                     &st->key, &st->keylen, &result,
1164                                     &resultlen);
1165                                 free(key);
1166                         }
1167                         if (rv != 0) {
1168                                 free(result);
1169                                 free(st->key);
1170                                 st->key = NULL;
1171                                 if (rv == YPERR_NOMORE) {
1172                                         st->done = 1;
1173                                         rv = NS_NOTFOUND;
1174                                 } else
1175                                         rv = NS_UNAVAIL;
1176                                 goto fin;
1177                         }
1178                 } else {
1179                         rv = yp_match(st->domain, map, buffer, strlen(buffer),
1180                             &result, &resultlen);
1181                         if (rv == YPERR_KEY) {
1182                                 rv = NS_NOTFOUND;
1183                                 continue;
1184                         } else if (rv != 0) {
1185                                 free(result);
1186                                 rv = NS_UNAVAIL;
1187                                 continue;
1188                         }
1189                 }
1190                 /* We need room at least for the line, a string NUL
1191                  * terminator, alignment padding, and one (char *)
1192                  * pointer for the member list terminator.
1193                  */
1194                 if (resultlen >= bufsize - _ALIGNBYTES - sizeof(char *)) {
1195                         free(result);
1196                         goto erange;
1197                 }
1198                 memcpy(buffer, result, resultlen);
1199                 buffer[resultlen] = '\0';
1200                 free(result);
1201                 rv = __gr_match_entry(buffer, resultlen, how, name, gid);
1202                 if (rv == NS_SUCCESS)
1203                         rv = __gr_parse_entry(buffer, resultlen, grp,
1204                             &buffer[resultlen+1], bufsize - resultlen - 1,
1205                             errnop);
1206         } while (how == nss_lt_all && !(rv & NS_TERMINATE));
1207 fin:
1208         if (rv == NS_SUCCESS && retval != NULL)
1209                 *(struct group **)retval = grp;
1210         return (rv);
1211 erange:
1212         *errnop = ERANGE;
1213         return (NS_RETURN);
1214 }
1215 #endif /* YP */
1216
1217
1218
1219 /*
1220  * compat backend
1221  */
1222 static void
1223 compat_endstate(void *p)
1224 {
1225         struct compat_state *st;
1226
1227         if (p == NULL)
1228                 return;
1229         st = (struct compat_state *)p;
1230         free(st->name);
1231         if (st->fp != NULL)
1232                 fclose(st->fp);
1233         free(p);
1234 }
1235
1236
1237 static int
1238 compat_setgrent(void *retval, void *mdata, va_list ap)
1239 {
1240         static const ns_src compatsrc[] = {
1241 #ifdef YP
1242                 { NSSRC_NIS, NS_SUCCESS },
1243 #endif
1244                 { NULL, 0 }
1245         };
1246         ns_dtab dtab[] = {
1247 #ifdef HESIOD
1248                 { NSSRC_DNS, dns_setgrent, NULL },
1249 #endif
1250 #ifdef YP
1251                 { NSSRC_NIS, nis_setgrent, NULL },
1252 #endif
1253                 { NULL, NULL, NULL }
1254         };
1255         struct compat_state *st;
1256         int              rv, stayopen;
1257
1258 #define set_setent(x, y) do {                                   \
1259         int i;                                                  \
1260         for (i = 0; i < (int)(nitems(x) - 1); i++)              \
1261                 x[i].mdata = (void *)y;                         \
1262 } while (0)
1263
1264         rv = compat_getstate(&st);
1265         if (rv != 0)
1266                 return (NS_UNAVAIL);
1267         switch ((enum constants)(uintptr_t)mdata) {
1268         case SETGRENT:
1269                 stayopen = va_arg(ap, int);
1270                 if (st->fp != NULL)
1271                         rewind(st->fp);
1272                 else if (stayopen)
1273                         st->fp = fopen(_PATH_GROUP, "re");
1274                 st->stayopen = stayopen;
1275                 set_setent(dtab, mdata);
1276                 (void)_nsdispatch(NULL, dtab, NSDB_GROUP_COMPAT, "setgrent",
1277                     compatsrc, 0);
1278                 break;
1279         case ENDGRENT:
1280                 if (st->fp != NULL) {
1281                         fclose(st->fp);
1282                         st->fp = NULL;
1283                 }
1284                 set_setent(dtab, mdata);
1285                 (void)_nsdispatch(NULL, dtab, NSDB_GROUP_COMPAT, "endgrent",
1286                     compatsrc, 0);
1287                 break;
1288         default:
1289                 break;
1290         }
1291         st->compat = COMPAT_MODE_OFF;
1292         free(st->name);
1293         st->name = NULL;
1294         return (NS_UNAVAIL);
1295 #undef set_setent
1296 }
1297
1298
1299 static int
1300 compat_group(void *retval, void *mdata, va_list ap)
1301 {
1302         static const ns_src compatsrc[] = {
1303 #ifdef YP
1304                 { NSSRC_NIS, NS_SUCCESS },
1305 #endif
1306                 { NULL, 0 }
1307         };
1308         ns_dtab dtab[] = {
1309 #ifdef YP
1310                 { NSSRC_NIS, nis_group, NULL },
1311 #endif
1312 #ifdef HESIOD
1313                 { NSSRC_DNS, dns_group, NULL },
1314 #endif
1315                 { NULL, NULL, NULL }
1316         };
1317         struct compat_state     *st;
1318         enum nss_lookup_type     how;
1319         const char              *name, *line;
1320         struct group            *grp;
1321         gid_t                    gid;
1322         char                    *buffer, *p;
1323         void                    *discard;
1324         size_t                   bufsize, linesize;
1325         off_t                    pos;
1326         int                      fresh, rv, stayopen, *errnop;
1327
1328 #define set_lookup_type(x, y) do {                              \
1329         int i;                                                  \
1330         for (i = 0; i < (int)(nitems(x) - 1); i++)              \
1331                 x[i].mdata = (void *)y;                         \
1332 } while (0)
1333
1334         fresh = 0;
1335         name = NULL;
1336         gid = (gid_t)-1;
1337         how = (enum nss_lookup_type)(uintptr_t)mdata;
1338         switch (how) {
1339         case nss_lt_name:
1340                 name = va_arg(ap, const char *);
1341                 break;
1342         case nss_lt_id:
1343                 gid = va_arg(ap, gid_t);
1344                 break;
1345         case nss_lt_all:
1346                 break;
1347         default:
1348                 return (NS_NOTFOUND);
1349         }
1350         grp = va_arg(ap, struct group *);
1351         buffer = va_arg(ap, char *);
1352         bufsize = va_arg(ap, size_t);
1353         errnop = va_arg(ap, int *);
1354         *errnop = compat_getstate(&st);
1355         if (*errnop != 0)
1356                 return (NS_UNAVAIL);
1357         if (st->fp == NULL) {
1358                 st->fp = fopen(_PATH_GROUP, "re");
1359                 if (st->fp == NULL) {
1360                         *errnop = errno;
1361                         rv = NS_UNAVAIL;
1362                         goto fin;
1363                 }
1364                 fresh = 1;
1365         }
1366         stayopen = (how == nss_lt_all || !fresh) ? 1 : st->stayopen;
1367         if (stayopen)
1368                 pos = ftello(st->fp);
1369         if (how != nss_lt_all && !fresh)
1370                 rewind(st->fp);
1371 docompat:
1372         switch (st->compat) {
1373         case COMPAT_MODE_ALL:
1374                 set_lookup_type(dtab, how);
1375                 switch (how) {
1376                 case nss_lt_all:
1377                         rv = _nsdispatch(&discard, dtab, NSDB_GROUP_COMPAT,
1378                             "getgrent_r", compatsrc, grp, buffer, bufsize,
1379                             errnop);
1380                         break;
1381                 case nss_lt_id:
1382                         rv = _nsdispatch(&discard, dtab, NSDB_GROUP_COMPAT,
1383                             "getgrgid_r", compatsrc, gid, grp, buffer, bufsize,
1384                             errnop);
1385                         break;
1386                 case nss_lt_name:
1387                         rv = _nsdispatch(&discard, dtab, NSDB_GROUP_COMPAT,
1388                             "getgrnam_r", compatsrc, name, grp, buffer,
1389                             bufsize, errnop);
1390                         break;
1391                 }
1392                 if (rv & NS_TERMINATE)
1393                         goto fin;
1394                 st->compat = COMPAT_MODE_OFF;
1395                 break;
1396         case COMPAT_MODE_NAME:
1397                 set_lookup_type(dtab, nss_lt_name);
1398                 rv = _nsdispatch(&discard, dtab, NSDB_GROUP_COMPAT,
1399                     "getgrnam_r", compatsrc, st->name, grp, buffer, bufsize,
1400                     errnop);
1401                 switch (rv) {
1402                 case NS_SUCCESS:
1403                         switch (how) {
1404                         case nss_lt_name:
1405                                 if (strcmp(name, grp->gr_name) != 0)
1406                                         rv = NS_NOTFOUND;
1407                                 break;
1408                         case nss_lt_id:
1409                                 if (gid != grp->gr_gid)
1410                                         rv = NS_NOTFOUND;
1411                                 break;
1412                         default:
1413                                 break;
1414                         }
1415                         break;
1416                 case NS_RETURN:
1417                         goto fin;
1418                 default:
1419                         break;
1420                 }
1421                 free(st->name);
1422                 st->name = NULL;
1423                 st->compat = COMPAT_MODE_OFF;
1424                 if (rv == NS_SUCCESS)
1425                         goto fin;
1426                 break;
1427         default:
1428                 break;
1429         }
1430         rv = NS_NOTFOUND;
1431         while ((line = fgetln(st->fp, &linesize)) != NULL) {
1432                 if (line[linesize-1] == '\n')
1433                         linesize--;
1434                 if (linesize > 2 && line[0] == '+') {
1435                         p = memchr(&line[1], ':', linesize);
1436                         if (p == NULL || p == &line[1])
1437                                 st->compat = COMPAT_MODE_ALL;
1438                         else {
1439                                 st->name = malloc(p - line);
1440                                 if (st->name == NULL) {
1441                                         syslog(LOG_ERR,
1442                                          "getgrent memory allocation failure");
1443                                         *errnop = ENOMEM;
1444                                         rv = NS_UNAVAIL;
1445                                         break;
1446                                 }
1447                                 memcpy(st->name, &line[1], p - line - 1);
1448                                 st->name[p - line - 1] = '\0';
1449                                 st->compat = COMPAT_MODE_NAME;
1450                         }
1451                         goto docompat;
1452                 }
1453                 rv = __gr_match_entry(line, linesize, how, name, gid);
1454                 if (rv != NS_SUCCESS)
1455                         continue;
1456                 /* We need room at least for the line, a string NUL
1457                  * terminator, alignment padding, and one (char *)
1458                  * pointer for the member list terminator.
1459                  */
1460                 if (bufsize <= linesize + _ALIGNBYTES + sizeof(char *)) {
1461                         *errnop = ERANGE;
1462                         rv = NS_RETURN;
1463                         break;
1464                 }
1465                 memcpy(buffer, line, linesize);
1466                 buffer[linesize] = '\0';
1467                 rv = __gr_parse_entry(buffer, linesize, grp,
1468                     &buffer[linesize + 1], bufsize - linesize - 1, errnop);
1469                 if (rv & NS_TERMINATE)
1470                         break;
1471                 if (how == nss_lt_all)
1472                         pos = ftello(st->fp);
1473         }
1474 fin:
1475         if (st->fp != NULL && !stayopen) {
1476                 fclose(st->fp);
1477                 st->fp = NULL;
1478         }
1479         if (st->fp != NULL && how != nss_lt_all)
1480                 fseeko(st->fp, pos, SEEK_SET);
1481         if (rv == NS_SUCCESS && retval != NULL)
1482                 *(struct group **)retval = grp;
1483         else if (rv == NS_RETURN && *errnop == ERANGE && st->fp != NULL)
1484                 fseeko(st->fp, pos, SEEK_SET);
1485         return (rv);
1486 #undef set_lookup_type
1487 }
1488
1489
1490 /*
1491  * common group line matching and parsing
1492  */
1493 int
1494 __gr_match_entry(const char *line, size_t linesize, enum nss_lookup_type how,
1495     const char *name, gid_t gid)
1496 {
1497         size_t           namesize;
1498         const char      *p, *eol;
1499         char            *q;
1500         unsigned long    n;
1501         int              i, needed;
1502
1503         if (linesize == 0 || is_comment_line(line, linesize))
1504                 return (NS_NOTFOUND);
1505         switch (how) {
1506         case nss_lt_name:       needed = 1; break;
1507         case nss_lt_id:         needed = 2; break;
1508         default:                needed = 2; break;
1509         }
1510         eol = &line[linesize];
1511         for (p = line, i = 0; i < needed && p < eol; p++)
1512                 if (*p == ':')
1513                         i++;
1514         if (i < needed)
1515                 return (NS_NOTFOUND);
1516         switch (how) {
1517         case nss_lt_name:
1518                 namesize = strlen(name);
1519                 if (namesize + 1 == (size_t)(p - line) &&
1520                     memcmp(line, name, namesize) == 0)
1521                         return (NS_SUCCESS);
1522                 break;
1523         case nss_lt_id:
1524                 n = strtoul(p, &q, 10);
1525                 if (q < eol && *q == ':' && gid == (gid_t)n)
1526                         return (NS_SUCCESS);
1527                 break;
1528         case nss_lt_all:
1529                 return (NS_SUCCESS);
1530         default:
1531                 break;
1532         }
1533         return (NS_NOTFOUND);
1534 }
1535
1536
1537 int
1538 __gr_parse_entry(char *line, size_t linesize, struct group *grp, char *membuf,
1539     size_t membufsize, int *errnop)
1540 {
1541         char           *s_gid, *s_mem, *p, **members;
1542         unsigned long   n;
1543         int             maxmembers;
1544
1545         memset(grp, 0, sizeof(*grp));
1546         members = (char **)_ALIGN(membuf);
1547         membufsize -= (char *)members - membuf;
1548         maxmembers = membufsize / sizeof(*members);
1549         if (maxmembers <= 0 ||
1550             (grp->gr_name = strsep(&line, ":")) == NULL ||
1551             grp->gr_name[0] == '\0' ||
1552             (grp->gr_passwd = strsep(&line, ":")) == NULL ||
1553             (s_gid = strsep(&line, ":")) == NULL ||
1554             s_gid[0] == '\0')
1555                 return (NS_NOTFOUND);
1556         s_mem = line;
1557         n = strtoul(s_gid, &s_gid, 10);
1558         if (s_gid[0] != '\0')
1559                 return (NS_NOTFOUND);
1560         grp->gr_gid = (gid_t)n;
1561         grp->gr_mem = members;
1562         while (maxmembers > 1 && s_mem != NULL) {
1563                 p = strsep(&s_mem, ",");
1564                 if (p != NULL && *p != '\0') {
1565                         *members++ = p;
1566                         maxmembers--;
1567                 }
1568         }
1569         *members = NULL;
1570         if (s_mem == NULL)
1571                 return (NS_SUCCESS);
1572         else {
1573                 *errnop = ERANGE;
1574                 return (NS_RETURN);
1575         }
1576 }
1577
1578