lib/libc/gen/getgrent.c

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