lookup.subproj/lu_group.c

   1 /*
   2  * Copyright (c) 1999-2007 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
   7  * Reserved.  This file contains Original Code and/or Modifications of
   8  * Original Code as defined in and that are subject to the Apple Public
   9  * Source License Version 1.1 (the "License").  You may not use this file
  10  * except in compliance with the License.  Please obtain a copy of the
  11  * License at http://www.apple.com/publicsource and read it before using
  12  * this file.
  13  *
  14  * The Original Code and all software distributed under the License are
  15  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  16  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  17  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT.  Please see the
  19  * License for the specific language governing rights and limitations
  20  * under the License.
  21  *
  22  * @APPLE_LICENSE_HEADER_END@
  23  */
  24 /*
  25  * Unix group lookup
  26  * Copyright (C) 1989 by NeXT, Inc.
  27  */
  28
  29 #include <stdlib.h>
  30 #include <mach/mach.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <ctype.h>
  34 #include <rpc/types.h>
  35 #include <rpc/xdr.h>
  36 #include <grp.h>
  37 #include <pwd.h>
  38 #include <netinet/in.h>
  39 #include <sys/param.h>
  40 #include <unistd.h>
  41 #include <pthread.h>
  42 #include <errno.h>
  43 #include <servers/bootstrap.h>
  44
  45 #include "_lu_types.h"
  46 #include "lookup.h"
  47 #include "lu_utils.h"
  48 #include "lu_overrides.h"
  49
  50 #define GROUP_CACHE_SIZE 10
  51 #define DEFAULT_GROUP_CACHE_TTL 10
  52
  53 static pthread_mutex_t _group_cache_lock = PTHREAD_MUTEX_INITIALIZER;
  54 static void *_group_cache[GROUP_CACHE_SIZE] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
  55 static unsigned int _group_cache_best_before[GROUP_CACHE_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  56 static unsigned int _group_cache_index = 0;
  57 static unsigned int _group_cache_ttl = DEFAULT_GROUP_CACHE_TTL;
  58
  59 static pthread_mutex_t _group_lock = PTHREAD_MUTEX_INITIALIZER;
  60
  61 /*
  62  * Support for memberd calls
  63  */
  64 #define MEMBERD_NAME "com.apple.memberd"
  65 static mach_port_t mbr_port = MACH_PORT_NULL;
  66 typedef uint32_t GIDArray[16];
  67 extern kern_return_t _mbr_GetGroups(mach_port_t server, uint32_t uid, uint32_t *numGroups, GIDArray gids, security_token_t *token);
  68
  69 #define GR_GET_NAME 1
  70 #define GR_GET_GID 2
  71 #define GR_GET_ENT 3
  72
  73 static void
  74 free_group_data(struct group *g)
  75 {
  76         char **mem;
  77
  78         if (g == NULL) return;
  79
  80         if (g->gr_name != NULL) free(g->gr_name);
  81         if (g->gr_passwd != NULL) free(g->gr_passwd);
  82
  83         mem = g->gr_mem;
  84         if (mem != NULL)
  85         {
  86                 while (*mem != NULL) free(*mem++);
  87                 free(g->gr_mem);
  88         }
  89 }
  90
  91 static void
  92 free_group(struct group *g)
  93 {
  94         if (g == NULL) return;
  95         free_group_data(g);
  96         free(g);
  97  }
  98
  99 static void
 100 free_lu_thread_info_group(void *x)
 101 {
 102         struct lu_thread_info *tdata;
 103
 104         if (x == NULL) return;
 105
 106         tdata = (struct lu_thread_info *)x;
 107
 108         if (tdata->lu_entry != NULL)
 109         {
 110                 free_group((struct group *)tdata->lu_entry);
 111                 tdata->lu_entry = NULL;
 112         }
 113
 114         _lu_data_free_vm_xdr(tdata);
 115
 116         free(tdata);
 117 }
 118
 119 static struct group *
 120 extract_group(XDR *xdr)
 121 {
 122         int i, j, nkeys, nvals, status;
 123         char *key, **vals;
 124         struct group *g;
 125
 126         if (xdr == NULL) return NULL;
 127
 128         if (!xdr_int(xdr, &nkeys)) return NULL;
 129
 130         g = (struct group *)calloc(1, sizeof(struct group));
 131         g->gr_gid = -2;
 132
 133         for (i = 0; i < nkeys; i++)
 134         {
 135                 key = NULL;
 136                 vals = NULL;
 137                 nvals = 0;
 138
 139                 status = _lu_xdr_attribute(xdr, &key, &vals, &nvals);
 140                 if (status < 0)
 141                 {
 142                         free_group(g);
 143                         return NULL;
 144                 }
 145
 146                 if (nvals == 0)
 147                 {
 148                         free(key);
 149                         continue;
 150                 }
 151
 152                 j = 0;
 153
 154                 if ((g->gr_name == NULL) && (!strcmp("name", key)))
 155                 {
 156                         g->gr_name = vals[0];
 157                         j = 1;
 158                 }
 159                 else if ((g->gr_passwd == NULL) && (!strcmp("passwd", key)))
 160                 {
 161                         g->gr_passwd = vals[0];
 162                         j = 1;
 163                 }
 164                 else if ((g->gr_gid == (gid_t)-2) && (!strcmp("gid", key)))
 165                 {
 166                         g->gr_gid = atoi(vals[0]);
 167                         if ((g->gr_gid == 0) && (strcmp(vals[0], "0"))) g->gr_gid = -2;
 168                 }
 169                 else if ((g->gr_mem == NULL) && (!strcmp("users", key)))
 170                 {
 171                         g->gr_mem = vals;
 172                         j = nvals;
 173                         vals = NULL;
 174                 }
 175
 176                 free(key);
 177                 if (vals != NULL)
 178                 {
 179                         for (; j < nvals; j++) free(vals[j]);
 180                         free(vals);
 181                 }
 182         }
 183
 184         if (g->gr_name == NULL) g->gr_name = strdup("");
 185         if (g->gr_passwd == NULL) g->gr_passwd = strdup("");
 186         if (g->gr_mem == NULL) g->gr_mem = (char **)calloc(1, sizeof(char *));
 187
 188         return g;
 189 }
 190
 191 static struct group *
 192 copy_group(struct group *in)
 193 {
 194         struct group *g;
 195         int i, len;
 196
 197         if (in == NULL) return NULL;
 198
 199         g = (struct group *)calloc(1, sizeof(struct group));
 200
 201         g->gr_name = LU_COPY_STRING(in->gr_name);
 202         g->gr_passwd = LU_COPY_STRING(in->gr_passwd);
 203         g->gr_gid = in->gr_gid;
 204
 205         len = 0;
 206         if (in->gr_mem != NULL)
 207         {
 208                 for (len = 0; in->gr_mem[len] != NULL; len++);
 209         }
 210
 211         g->gr_mem = (char **)calloc(len + 1, sizeof(char *));
 212         for (i = 0; i < len; i++)
 213         {
 214                 g->gr_mem[i] = strdup(in->gr_mem[i]);
 215         }
 216
 217         return g;
 218 }
 219
 220 static int
 221 copy_group_r(struct group *in, struct group *out, char *buffer, int buflen)
 222 {
 223         int i, len, hsize;
 224         unsigned long addr;
 225         char *bp, *ap;
 226
 227         if (in == NULL) return -1;
 228         if (out == NULL) return -1;
 229
 230         if (buffer == NULL) buflen = 0;
 231
 232         /* Calculate size of input */
 233         hsize = 0;
 234         if (in->gr_name != NULL) hsize += (strlen(in->gr_name) + 1);
 235         if (in->gr_passwd != NULL) hsize += (strlen(in->gr_passwd) + 1);
 236
 237         /* NULL pointer at end of list */
 238         hsize += sizeof(char *);
 239
 240         len = 0;
 241         if (in->gr_mem != NULL)
 242         {
 243                 for (len = 0; in->gr_mem[len] != NULL; len++)
 244                 {
 245                         hsize += sizeof(char *);
 246                         hsize += (strlen(in->gr_mem[len]) + 1);
 247                 }
 248         }
 249
 250         /* Check buffer space */
 251         if (hsize > buflen) return -1;
 252
 253         /* Copy result into caller's struct group, using buffer for memory */
 254         bp = buffer;
 255
 256         out->gr_name = NULL;
 257         if (in->gr_name != NULL)
 258         {
 259                 out->gr_name = bp;
 260                 hsize = strlen(in->gr_name) + 1;
 261                 memmove(bp, in->gr_name, hsize);
 262                 bp += hsize;
 263         }
 264
 265         out->gr_passwd = NULL;
 266         if (in->gr_passwd != NULL)
 267         {
 268                 out->gr_passwd = bp;
 269                 hsize = strlen(in->gr_passwd) + 1;
 270                 memmove(bp, in->gr_passwd, hsize);
 271                 bp += hsize;
 272         }
 273
 274         out->gr_gid = in->gr_gid;
 275
 276         out->gr_mem = NULL;
 277         ap = bp + ((len + 1) * sizeof(char *));
 278
 279         if (in->gr_mem != NULL)
 280         {
 281                 out->gr_mem = (char **)bp;
 282                 for (i = 0; i < len; i++)
 283                 {
 284                         addr = (unsigned long)ap;
 285                         memmove(bp, &addr, sizeof(unsigned long));
 286                         bp += sizeof(unsigned long);
 287
 288                         hsize = strlen(in->gr_mem[i]) + 1;
 289                         memmove(ap, in->gr_mem[i], hsize);
 290                         ap += hsize;
 291                 }
 292         }
 293
 294         memset(bp, 0, sizeof(unsigned long));
 295         bp = ap;
 296
 297         return 0;
 298 }
 299
 300 static void
 301 recycle_group(struct lu_thread_info *tdata, struct group *in)
 302 {
 303         struct group *g;
 304
 305         if (tdata == NULL) return;
 306         g = (struct group *)tdata->lu_entry;
 307
 308         if (in == NULL)
 309         {
 310                 free_group(g);
 311                 tdata->lu_entry = NULL;
 312         }
 313
 314         if (tdata->lu_entry == NULL)
 315         {
 316                 tdata->lu_entry = in;
 317                 return;
 318         }
 319
 320         free_group_data(g);
 321
 322         g->gr_name = in->gr_name;
 323         g->gr_passwd = in->gr_passwd;
 324         g->gr_gid = in->gr_gid;
 325         g->gr_mem = in->gr_mem;
 326
 327         free(in);
 328 }
 329
 330 __private_extern__ unsigned int
 331 get_group_cache_ttl()
 332 {
 333         return _group_cache_ttl;
 334 }
 335
 336 __private_extern__ void
 337 set_group_cache_ttl(unsigned int ttl)
 338 {
 339         int i;
 340
 341         pthread_mutex_lock(&_group_cache_lock);
 342
 343         _group_cache_ttl = ttl;
 344
 345         if (ttl == 0)
 346         {
 347                 for (i = 0; i < GROUP_CACHE_SIZE; i++)
 348                 {
 349                         if (_group_cache[i] == NULL) continue;
 350
 351                         free_group((struct group *)_group_cache[i]);
 352                         _group_cache[i] = NULL;
 353                         _group_cache_best_before[i] = 0;
 354                 }
 355         }
 356
 357         pthread_mutex_unlock(&_group_cache_lock);
 358 }
 359
 360 static void
 361 cache_group(struct group *gr)
 362 {
 363         struct timeval now;
 364         struct group *grcache;
 365
 366         if (_group_cache_ttl == 0) return;
 367         if (gr == NULL) return;
 368
 369         pthread_mutex_lock(&_group_cache_lock);
 370
 371         grcache = copy_group(gr);
 372
 373         gettimeofday(&now, NULL);
 374
 375         if (_group_cache[_group_cache_index] != NULL)
 376                 free_group((struct group *)_group_cache[_group_cache_index]);
 377
 378         _group_cache[_group_cache_index] = grcache;
 379         _group_cache_best_before[_group_cache_index] = now.tv_sec + _group_cache_ttl;
 380         _group_cache_index = (_group_cache_index + 1) % GROUP_CACHE_SIZE;
 381
 382         pthread_mutex_unlock(&_group_cache_lock);
 383 }
 384
 385 static struct group *
 386 cache_getgrnam(const char *name)
 387 {
 388         int i;
 389         struct group *gr, *res;
 390         struct timeval now;
 391
 392         if (_group_cache_ttl == 0) return NULL;
 393         if (name == NULL) return NULL;
 394
 395         pthread_mutex_lock(&_group_cache_lock);
 396
 397         gettimeofday(&now, NULL);
 398
 399         for (i = 0; i < GROUP_CACHE_SIZE; i++)
 400         {
 401                 if (_group_cache_best_before[i] == 0) continue;
 402                 if ((unsigned int)now.tv_sec > _group_cache_best_before[i]) continue;
 403
 404                 gr = (struct group *)_group_cache[i];
 405
 406                 if (gr->gr_name == NULL) continue;
 407
 408                 if (!strcmp(name, gr->gr_name))
 409                 {
 410                         res = copy_group(gr);
 411                         pthread_mutex_unlock(&_group_cache_lock);
 412                         return res;
 413                 }
 414         }
 415
 416         pthread_mutex_unlock(&_group_cache_lock);
 417         return NULL;
 418 }
 419
 420 static struct group *
 421 cache_getgrgid(int gid)
 422 {
 423         int i;
 424         struct group *gr, *res;
 425         struct timeval now;
 426
 427         if (_group_cache_ttl == 0) return NULL;
 428
 429         pthread_mutex_lock(&_group_cache_lock);
 430
 431         gettimeofday(&now, NULL);
 432
 433         for (i = 0; i < GROUP_CACHE_SIZE; i++)
 434         {
 435                 if (_group_cache_best_before[i] == 0) continue;
 436                 if ((unsigned int)now.tv_sec > _group_cache_best_before[i]) continue;
 437
 438                 gr = (struct group *)_group_cache[i];
 439
 440                 if ((gid_t)gid == gr->gr_gid)
 441                 {
 442                         res = copy_group(gr);
 443                         pthread_mutex_unlock(&_group_cache_lock);
 444                         return res;
 445                 }
 446         }
 447
 448         pthread_mutex_unlock(&_group_cache_lock);
 449         return NULL;
 450 }
 451
 452 static struct group *
 453 lu_getgrgid(int gid)
 454 {
 455         struct group *g;
 456         unsigned int datalen;
 457         XDR inxdr;
 458         static int proc = -1;
 459         int count;
 460         char *lookup_buf;
 461
 462         if (proc < 0)
 463         {
 464                 if (_lookup_link(_lu_port, "getgrgid", &proc) != KERN_SUCCESS)
 465                 {
 466                         return NULL;
 467                 }
 468         }
 469
 470         gid = htonl(gid);
 471         datalen = 0;
 472         lookup_buf = NULL;
 473
 474         if (_lookup_all(_lu_port, proc, (unit *)&gid, 1, &lookup_buf, &datalen) != KERN_SUCCESS)
 475         {
 476                 return NULL;
 477         }
 478
 479         datalen *= BYTES_PER_XDR_UNIT;
 480         if ((lookup_buf == NULL) || (datalen == 0)) return NULL;
 481
 482         xdrmem_create(&inxdr, lookup_buf, datalen, XDR_DECODE);
 483
 484         count = 0;
 485         if (!xdr_int(&inxdr, &count))
 486         {
 487                 xdr_destroy(&inxdr);
 488                 vm_deallocate(mach_task_self(), (vm_address_t)lookup_buf, datalen);
 489                 return NULL;
 490         }
 491
 492         if (count == 0)
 493         {
 494                 xdr_destroy(&inxdr);
 495                 vm_deallocate(mach_task_self(), (vm_address_t)lookup_buf, datalen);
 496                 return NULL;
 497         }
 498
 499         g = extract_group(&inxdr);
 500         xdr_destroy(&inxdr);
 501         vm_deallocate(mach_task_self(), (vm_address_t)lookup_buf, datalen);
 502
 503         return g;
 504 }
 505
 506 static struct group *
 507 lu_getgrnam(const char *name)
 508 {
 509         struct group *g;
 510         unsigned int datalen;
 511         char namebuf[_LU_MAXLUSTRLEN + BYTES_PER_XDR_UNIT];
 512         XDR outxdr;
 513         XDR inxdr;
 514         static int proc = -1;
 515         int count;
 516         char *lookup_buf;
 517
 518         if (proc < 0)
 519         {
 520                 if (_lookup_link(_lu_port, "getgrnam", &proc) != KERN_SUCCESS)
 521                 {
 522                         return NULL;
 523                 }
 524         }
 525
 526         xdrmem_create(&outxdr, namebuf, sizeof(namebuf), XDR_ENCODE);
 527
 528         if (!xdr__lu_string(&outxdr, (_lu_string *)&name))
 529         {
 530                 xdr_destroy(&outxdr);
 531                 return NULL;
 532         }
 533
 534         datalen = 0;
 535         lookup_buf = NULL;
 536
 537         if (_lookup_all(_lu_port, proc, (unit *)namebuf, xdr_getpos(&outxdr) / BYTES_PER_XDR_UNIT, &lookup_buf, &datalen) != KERN_SUCCESS)
 538         {
 539                 return NULL;
 540         }
 541
 542         xdr_destroy(&outxdr);
 543
 544         datalen *= BYTES_PER_XDR_UNIT;
 545         if ((lookup_buf == NULL) || (datalen == 0)) return NULL;
 546
 547         xdrmem_create(&inxdr, lookup_buf, datalen, XDR_DECODE);
 548
 549         count = 0;
 550         if (!xdr_int(&inxdr, &count))
 551         {
 552                 xdr_destroy(&inxdr);
 553                 vm_deallocate(mach_task_self(), (vm_address_t)lookup_buf, datalen);
 554                 return NULL;
 555         }
 556
 557         if (count == 0)
 558         {
 559                 xdr_destroy(&inxdr);
 560                 vm_deallocate(mach_task_self(), (vm_address_t)lookup_buf, datalen);
 561                 return NULL;
 562         }
 563
 564         g = extract_group(&inxdr);
 565         xdr_destroy(&inxdr);
 566         vm_deallocate(mach_task_self(), (vm_address_t)lookup_buf, datalen);
 567
 568         return g;
 569 }
 570
 571 /*
 572  * add a group to a list
 573  *
 574  * if dupok is non-zero, it's OK to add a duplicate entry
 575  * if dupok is zero, we only add the gid if it is new
 576  * (*listcount) is incremented if the gid was added
 577  * returns -1 if adding the gid would overflow the list
 578  *
 579  */
 580 static int
 581 _add_group(int gid, int *list, int *listcount, int max, int dupok, int laststatus)
 582 {
 583         int i, n, addit, status;
 584
 585         if (laststatus != 0) return laststatus;
 586
 587         status = 0;
 588         addit = 1;
 589         n = *listcount;
 590
 591         if (dupok == 0)
 592         {
 593                 for (i = 0; (i < n) && (addit == 1); i++)
 594                 {
 595                         if (list[i] == gid) addit = 0;
 596                 }
 597         }
 598
 599         if (addit == 0) return 0;
 600         if (n >= max) return -1;
 601
 602         list[n] = gid;
 603         *listcount = n + 1;
 604         return 0;
 605 }
 606
 607 int
 608 _old_getgrouplist(const char *uname, int basegid, int *groups, int *grpcnt)
 609 {
 610         struct group *grp;
 611         int i, status, maxgroups;
 612
 613         status = 0;
 614         maxgroups = *grpcnt;
 615         *grpcnt = 0;
 616
 617         /*
 618          * When installing primary group, duplicate it;
 619          * the first element of groups is the effective gid
 620          * and will be overwritten when a setgid file is executed.
 621          */
 622         status = _add_group(basegid, groups, grpcnt, maxgroups, 0, status);
 623         status = _add_group(basegid, groups, grpcnt, maxgroups, 1, status);
 624
 625         /*
 626          * Scan the group file to find additional groups.
 627          */
 628         setgrent();
 629
 630         while ((grp = getgrent()))
 631         {
 632                 if (grp->gr_gid == (gid_t)basegid) continue;
 633                 for (i = 0; grp->gr_mem[i]; i++)
 634                 {
 635                         if (!strcmp(grp->gr_mem[i], uname))
 636                         {
 637                                 status = _add_group(grp->gr_gid, groups, grpcnt, maxgroups, 0, status);
 638                                 break;
 639                         }
 640                 }
 641         }
 642
 643         endgrent();
 644         return status;
 645 }
 646
 647 static int
 648 _mbr_running()
 649 {
 650         kern_return_t status;
 651
 652         status = bootstrap_look_up(bootstrap_port, MEMBERD_NAME, &mbr_port);
 653         if (status != KERN_SUCCESS) return 0;
 654         if (mbr_port == MACH_PORT_NULL) return 0;
 655         return 1;
 656 }
 657
 658 /*
 659  * Guess at the size of a password buffer for getpwnam_r
 660  * pw_name can be MAXLOGNAME + 1         256 - sys/param.h
 661  * pw_passwd can be _PASSWORD_LEN + 1    129 - pwd.h
 662  * pw_dir can be MAXPATHLEN + 1         1025 - sys/syslimits.h
 663  * pw_shell can be MAXPATHLEN +         1025 - sys/syslimits.h
 664  * We allow pw_class and pw_gecos to take a maximum of 4098 bytes (there's no limit on these).
 665  * This adds to 6533 bytes (until one of the constants changes)
 666  */
 667 #define MAXPWBUF (MAXLOGNAME + 1 + _PASSWORD_LEN + 1 + MAXPATHLEN + 1 + MAXPATHLEN + 1 + 4098)
 668 static int
 669 mbr_getgrouplist(const char *name, int basegid, int *groups, int *grpcnt, int dupbase)
 670 {
 671         struct passwd p, *res;
 672         char buf[MAXPWBUF];
 673         kern_return_t kstatus;
 674         uint32_t i, count;
 675         int pwstatus;
 676         GIDArray gids;
 677         int status, maxgroups;
 678         security_token_t token;
 679
 680         status = 0;
 681
 682         if (mbr_port == MACH_PORT_NULL) return status;
 683         if (name == NULL) return status;
 684         if (groups == NULL) return status;
 685         if (grpcnt == NULL) return status;
 686
 687         maxgroups = *grpcnt;
 688         *grpcnt = 0;
 689
 690         status = _add_group(basegid, groups, grpcnt, maxgroups, 0, status);
 691         if (dupbase != 0) status = _add_group(basegid, groups, grpcnt, maxgroups, 1, status);
 692
 693         if (status != 0) return status;
 694
 695         memset(&p, 0, sizeof(struct passwd));
 696         memset(buf, 0, sizeof(buf));
 697         res = NULL;
 698
 699         pwstatus = getpwnam_r(name, &p, buf, MAXPWBUF, &res);
 700         if (pwstatus != 0) return status;
 701         if (res == NULL) return status;
 702
 703         token.val[0] = -1;
 704         token.val[1] = -1;
 705
 706         count = 0;
 707         kstatus = _mbr_GetGroups(mbr_port, p.pw_uid, &count, gids, &token);
 708         if (kstatus != KERN_SUCCESS) return status;
 709         if (token.val[0] != 0) return KERN_FAILURE;
 710
 711         for (i = 0; (i < count) && (status == 0); i++)
 712         {
 713                 status = _add_group(gids[i], groups, grpcnt, maxgroups, 0, status);
 714         }
 715
 716         return status;
 717 }
 718
 719 static int
 720 lu_getgrouplist(const char *name, int basegid, int *groups, int *grpcnt, int dupbase)
 721 {
 722         unsigned int datalen;
 723         XDR outxdr;
 724         XDR inxdr;
 725         static int proc = -1;
 726         char *lookup_buf;
 727         char namebuf[_LU_MAXLUSTRLEN + BYTES_PER_XDR_UNIT];
 728         int gid;
 729         int i, count;
 730         int status, maxgroups;
 731
 732         status = 0;
 733
 734         if (name == NULL) return status;
 735         if (groups == NULL) return status;
 736         if (grpcnt == NULL) return status;
 737
 738         maxgroups = *grpcnt;
 739         *grpcnt = 0;
 740
 741         status = _add_group(basegid, groups, grpcnt, maxgroups, 0, status);
 742         if (dupbase != 0) status = _add_group(basegid, groups, grpcnt, maxgroups, 1, status);
 743
 744         if (status != 0) return status;
 745
 746         if (proc < 0)
 747         {
 748                 if (_lookup_link(_lu_port, "initgroups", &proc) != KERN_SUCCESS) return status;
 749         }
 750
 751         xdrmem_create(&outxdr, namebuf, sizeof(namebuf), XDR_ENCODE);
 752         if (!xdr__lu_string(&outxdr, (_lu_string *)&name))
 753         {
 754                 xdr_destroy(&outxdr);
 755                 return status;
 756         }
 757
 758         datalen = 0;
 759         lookup_buf = NULL;
 760
 761         if (_lookup_all(_lu_port, proc, (unit *)namebuf, xdr_getpos(&outxdr) / BYTES_PER_XDR_UNIT, &lookup_buf, &datalen) != KERN_SUCCESS)
 762         {
 763                 xdr_destroy(&outxdr);
 764                 return status;
 765         }
 766
 767         xdr_destroy(&outxdr);
 768
 769         datalen *= BYTES_PER_XDR_UNIT;
 770         if ((lookup_buf == NULL) || (datalen == 0)) return 0;
 771
 772         xdrmem_create(&inxdr, lookup_buf, datalen, XDR_DECODE);
 773
 774         if (!xdr_int(&inxdr, &count))
 775         {
 776                 xdr_destroy(&inxdr);
 777                 vm_deallocate(mach_task_self(), (vm_address_t)lookup_buf, datalen);
 778                 return status;
 779         }
 780
 781         for (i = 0; (i < count) && (status == 0); i++)
 782         {
 783                 if (!xdr_int(&inxdr, &gid)) break;
 784                 status = _add_group(gid, groups, grpcnt, maxgroups, 0, status);
 785         }
 786
 787         xdr_destroy(&inxdr);
 788         vm_deallocate(mach_task_self(), (vm_address_t)lookup_buf, datalen);
 789
 790         return status;
 791 }
 792
 793 static int
 794 getgrouplist_internal(const char *name, int basegid, int *groups, int *grpcnt, int dupbase)
 795 {
 796         if (_mbr_running())
 797         {
 798                 return mbr_getgrouplist(name, basegid, groups, grpcnt, dupbase);
 799         }
 800
 801         if (_lu_running())
 802         {
 803                 return lu_getgrouplist(name, basegid, groups, grpcnt, dupbase);
 804         }
 805
 806         return _old_getgrouplist(name, basegid, groups, grpcnt);
 807 }
 808
 809 int
 810 getgrouplist(const char *uname, int agroup, int *groups, int *grpcnt)
 811 {
 812         return getgrouplist_internal(uname, agroup, groups, grpcnt, 1);
 813 }
 814
 815 static void
 816 lu_endgrent(void)
 817 {
 818         struct lu_thread_info *tdata;
 819
 820         tdata = _lu_data_create_key(_lu_data_key_group, free_lu_thread_info_group);
 821         _lu_data_free_vm_xdr(tdata);
 822 }
 823
 824 static int
 825 lu_setgrent(void)
 826 {
 827         lu_endgrent();
 828         return 1;
 829 }
 830
 831 static struct group *
 832 lu_getgrent()
 833 {
 834         struct group *g;
 835         static int proc = -1;
 836         struct lu_thread_info *tdata;
 837
 838         tdata = _lu_data_create_key(_lu_data_key_group, free_lu_thread_info_group);
 839         if (tdata == NULL)
 840         {
 841                 tdata = (struct lu_thread_info *)calloc(1, sizeof(struct lu_thread_info));
 842                 _lu_data_set_key(_lu_data_key_group, tdata);
 843         }
 844
 845         if (tdata->lu_vm == NULL)
 846         {
 847                 if (proc < 0)
 848                 {
 849                         if (_lookup_link(_lu_port, "getgrent", &proc) != KERN_SUCCESS)
 850                         {
 851                                 lu_endgrent();
 852                                 return NULL;
 853                         }
 854                 }
 855
 856                 if (_lookup_all(_lu_port, proc, NULL, 0, &(tdata->lu_vm), &(tdata->lu_vm_length)) != KERN_SUCCESS)
 857                 {
 858                         lu_endgrent();
 859                         return NULL;
 860                 }
 861
 862                 /* mig stubs measure size in words (4 bytes) */
 863                 tdata->lu_vm_length *= 4;
 864
 865                 if (tdata->lu_xdr != NULL)
 866                 {
 867                         xdr_destroy(tdata->lu_xdr);
 868                         free(tdata->lu_xdr);
 869                 }
 870                 tdata->lu_xdr = (XDR *)calloc(1, sizeof(XDR));
 871
 872                 xdrmem_create(tdata->lu_xdr, tdata->lu_vm, tdata->lu_vm_length, XDR_DECODE);
 873                 if (!xdr_int(tdata->lu_xdr, &tdata->lu_vm_cursor))
 874                 {
 875                         lu_endgrent();
 876                         return NULL;
 877                 }
 878         }
 879
 880         if (tdata->lu_vm_cursor == 0)
 881         {
 882                 lu_endgrent();
 883                 return NULL;
 884         }
 885
 886         g = extract_group(tdata->lu_xdr);
 887         if (g == NULL)
 888         {
 889                 lu_endgrent();
 890                 return NULL;
 891         }
 892
 893         tdata->lu_vm_cursor--;
 894
 895         return g;
 896 }
 897
 898 static struct group *
 899 getgr_internal(const char *name, gid_t gid, int source)
 900 {
 901         struct group *res = NULL;
 902         int from_cache;
 903
 904         from_cache = 0;
 905         res = NULL;
 906
 907         switch (source)
 908         {
 909                 case GR_GET_NAME:
 910                         res = cache_getgrnam(name);
 911                         break;
 912                 case GR_GET_GID:
 913                         res = cache_getgrgid(gid);
 914                         break;
 915                 default: res = NULL;
 916         }
 917
 918         if (res != NULL)
 919         {
 920                 from_cache = 1;
 921         }
 922         else if (_lu_running())
 923         {
 924                 switch (source)
 925                 {
 926                         case GR_GET_NAME:
 927                                 res = lu_getgrnam(name);
 928                                 break;
 929                         case GR_GET_GID:
 930                                 res = lu_getgrgid(gid);
 931                                 break;
 932                         case GR_GET_ENT:
 933                                 res = lu_getgrent();
 934                                 break;
 935                         default: res = NULL;
 936                 }
 937         }
 938         else
 939         {
 940                 pthread_mutex_lock(&_group_lock);
 941                 switch (source)
 942                 {
 943                         case GR_GET_NAME:
 944                                 res = copy_group(_old_getgrnam(name));
 945                                 break;
 946                         case GR_GET_GID:
 947                                 res = copy_group(_old_getgrgid(gid));
 948                                 break;
 949                         case GR_GET_ENT:
 950                                 res = copy_group(_old_getgrent());
 951                                 break;
 952                         default: res = NULL;
 953                 }
 954                 pthread_mutex_unlock(&_group_lock);
 955         }
 956
 957         if (from_cache == 0) cache_group(res);
 958
 959         return res;
 960 }
 961
 962 static struct group *
 963 getgr(const char *name, gid_t gid, int source)
 964 {
 965         struct group *res = NULL;
 966         struct lu_thread_info *tdata;
 967
 968         tdata = _lu_data_create_key(_lu_data_key_group, free_lu_thread_info_group);
 969         if (tdata == NULL)
 970         {
 971                 tdata = (struct lu_thread_info *)calloc(1, sizeof(struct lu_thread_info));
 972                 _lu_data_set_key(_lu_data_key_group, tdata);
 973         }
 974
 975         res = getgr_internal(name, gid, source);
 976
 977         recycle_group(tdata, res);
 978         return (struct group *)tdata->lu_entry;
 979 }
 980
 981 static int
 982 getgr_r(const char *name, gid_t gid, int source, struct group *grp, char *buffer, size_t bufsize, struct group **result)
 983 {
 984         struct group *res = NULL;
 985         int status;
 986
 987         *result = NULL;
 988         errno = 0;
 989
 990         res = getgr_internal(name, gid, source);
 991         if (res == NULL) return -1;
 992
 993         status = copy_group_r(res, grp, buffer, bufsize);
 994         free_group(res);
 995
 996         if (status != 0)
 997         {
 998                 errno = ERANGE;
 999                 return -1;
1000         }
1001
1002         *result = grp;
1003         return 0;
1004 }
1005
1006 int
1007 initgroups(const char *name, int basegid)
1008 {
1009         int status, ngroups, groups[NGROUPS];
1010
1011         ngroups = NGROUPS;
1012
1013         status = getgrouplist_internal(name, basegid, groups, &ngroups, 0);
1014         if (status < 0) return status;
1015
1016         return setgroups(ngroups, groups);
1017 }
1018
1019 struct group *
1020 getgrnam(const char *name)
1021 {
1022         return getgr(name, -2, GR_GET_NAME);
1023 }
1024
1025 struct group *
1026 getgrgid(gid_t gid)
1027 {
1028         return getgr(NULL, gid, GR_GET_GID);
1029 }
1030
1031 struct group *
1032 getgrent(void)
1033 {
1034         return getgr(NULL, -2, GR_GET_ENT);
1035 }
1036
1037 int
1038 setgrent(void)
1039 {
1040         if (_lu_running()) lu_setgrent();
1041         else _old_setgrent();
1042         return 1;
1043 }
1044
1045 void
1046 endgrent(void)
1047 {
1048         if (_lu_running()) lu_endgrent();
1049         else _old_endgrent();
1050 }
1051
1052 int
1053 getgrnam_r(const char *name, struct group *grp, char *buffer, size_t bufsize, struct group **result)
1054 {
1055         return getgr_r(name, -2, GR_GET_NAME, grp, buffer, bufsize, result);
1056 }
1057
1058 int
1059 getgrgid_r(gid_t gid, struct group *grp, char *buffer, size_t bufsize, struct group **result)
1060 {
1061         return getgr_r(NULL, gid, GR_GET_GID, grp, buffer, bufsize, result);
1062 }