lib/libc/gen/getnetgrent.c

   1 /*
   2  * Copyright (c) 1992, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Rick Macklem at The University of Guelph.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  * $FreeBSD: src/lib/libc/gen/getnetgrent.c,v 1.26 1999/11/04 04:16:27 ache Exp $
  37  * $DragonFly: src/lib/libc/gen/getnetgrent.c,v 1.5 2005/04/25 21:03:46 joerg Exp $
  38  *
  39  * @(#)getnetgrent.c    8.2 (Berkeley) 4/27/95
  40  */
  41
  42 #include <ctype.h>
  43 #include <netdb.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <strings.h>
  47 #include <unistd.h>
  48
  49 #ifdef YP
  50 /*
  51  * Notes:
  52  * We want to be able to use NIS netgroups properly while retaining
  53  * the ability to use a local /etc/netgroup file. Unfortunately, you
  54  * can't really do both at the same time - at least, not efficiently.
  55  * NetBSD deals with this problem by creating a netgroup database
  56  * using Berkeley DB (just like the password database) that allows
  57  * for lookups using netgroup, netgroup.byuser or netgroup.byhost
  58  * searches. This is a neat idea, but I don't have time to implement
  59  * something like that now. (I think ultimately it would be nice
  60  * if we DB-fied the group and netgroup stuff all in one shot, but
  61  * for now I'm satisfied just to have something that works well
  62  * without requiring massive code changes.)
  63  *
  64  * Therefore, to still permit the use of the local file and maintain
  65  * optimum NIS performance, we allow for the following conditions:
  66  *
  67  * - If /etc/netgroup does not exist and NIS is turned on, we use
  68  *   NIS netgroups only.
  69  *
  70  * - If /etc/netgroup exists but is empty, we use NIS netgroups
  71  *   only.
  72  *
  73  * - If /etc/netgroup exists and contains _only_ a '+', we use
  74  *   NIS netgroups only.
  75  *
  76  * - If /etc/netgroup exists, contains locally defined netgroups
  77  *   and a '+', we use a mixture of NIS and the local entries.
  78  *   This method should return the same NIS data as just using
  79  *   NIS alone, but it will be slower if the NIS netgroup database
  80  *   is large (innetgr() in particular will suffer since extra
  81  *   processing has to be done in order to determine memberships
  82  *   using just the raw netgroup data).
  83  *
  84  * - If /etc/netgroup exists and contains only locally defined
  85  *   netgroup entries, we use just those local entries and ignore
  86  *   NIS (this is the original, pre-NIS behavior).
  87  */
  88
  89 #include <rpc/rpc.h>
  90 #include <rpcsvc/yp_prot.h>
  91 #include <rpcsvc/ypclnt.h>
  92 #include <sys/types.h>
  93 #include <sys/stat.h>
  94 #include <sys/param.h>
  95 #include <sys/errno.h>
  96 static char *_netgr_yp_domain;
  97 int _use_only_yp;
  98 static int _netgr_yp_enabled;
  99 static int _yp_innetgr;
 100 #endif
 101
 102 #ifndef _PATH_NETGROUP
 103 #define _PATH_NETGROUP "/etc/netgroup"
 104 #endif
 105
 106 /*
 107  * Static Variables and functions used by setnetgrent(), getnetgrent() and
 108  * endnetgrent().
 109  * There are two linked lists:
 110  * - linelist is just used by setnetgrent() to parse the net group file via.
 111  *   parse_netgrp()
 112  * - netgrp is the list of entries for the current netgroup
 113  */
 114 struct linelist {
 115         struct linelist *l_next;        /* Chain ptr. */
 116         int             l_parsed;       /* Flag for cycles */
 117         char            *l_groupname;   /* Name of netgroup */
 118         char            *l_line;        /* Netgroup entrie(s) to be parsed */
 119 };
 120
 121 struct netgrp {
 122         struct netgrp   *ng_next;       /* Chain ptr */
 123         char            *ng_str[3];     /* Field pointers, see below */
 124 };
 125 #define NG_HOST         0       /* Host name */
 126 #define NG_USER         1       /* User name */
 127 #define NG_DOM          2       /* and Domain name */
 128
 129 static struct linelist  *linehead = NULL;
 130 static struct netgrp    *nextgrp = NULL;
 131 static struct {
 132         struct netgrp   *gr;
 133         char            *grname;
 134 } grouphead = {
 135         NULL,
 136         NULL,
 137 };
 138 static FILE *netf = (FILE *)0;
 139 static int parse_netgrp(const char *);
 140 static struct linelist *read_for_group(const char *);
 141
 142 #define LINSIZ  1024    /* Length of netgroup file line */
 143
 144 /*
 145  * setnetgrent()
 146  * Parse the netgroup file looking for the netgroup and build the list
 147  * of netgrp structures. Let parse_netgrp() and read_for_group() do
 148  * most of the work.
 149  */
 150 void
 151 setnetgrent(const char *group)
 152 {
 153 #ifdef YP
 154         struct stat _yp_statp;
 155         char _yp_plus;
 156 #endif
 157
 158         /* Sanity check */
 159
 160         if (group == NULL || !strlen(group))
 161                 return;
 162
 163         if (grouphead.gr == (struct netgrp *)0 ||
 164                 strcmp(group, grouphead.grname)) {
 165                 endnetgrent();
 166 #ifdef YP
 167                 /* Presumed guilty until proven innocent. */
 168                 _use_only_yp = 0;
 169                 /*
 170                  * If /etc/netgroup doesn't exist or is empty,
 171                  * use NIS exclusively.
 172                  */
 173                 if (((stat(_PATH_NETGROUP, &_yp_statp) < 0) &&
 174                         errno == ENOENT) || _yp_statp.st_size == 0)
 175                         _use_only_yp = _netgr_yp_enabled = 1;
 176                 if ((netf = fopen(_PATH_NETGROUP,"r")) != NULL ||_use_only_yp){
 177                 /*
 178                  * Icky: grab the first character of the netgroup file
 179                  * and turn on NIS if it's a '+'. rewind the stream
 180                  * afterwards so we don't goof up read_for_group() later.
 181                  */
 182                         if (netf) {
 183                                 fscanf(netf, "%c", &_yp_plus);
 184                                 rewind(netf);
 185                                 if (_yp_plus == '+')
 186                                         _use_only_yp = _netgr_yp_enabled = 1;
 187                         }
 188                 /*
 189                  * If we were called specifically for an innetgr()
 190                  * lookup and we're in NIS-only mode, short-circuit
 191                  * parse_netgroup() and cut directly to the chase.
 192                  */
 193                         if (_use_only_yp && _yp_innetgr) {
 194                                 /* dohw! */
 195                                 if (netf != NULL)
 196                                         fclose(netf);
 197                                 return;
 198                         }
 199 #else
 200                 if (netf = fopen(_PATH_NETGROUP, "r")) {
 201 #endif
 202                         if (parse_netgrp(group))
 203                                 endnetgrent();
 204                         else {
 205                                 grouphead.grname = (char *)
 206                                         malloc(strlen(group) + 1);
 207                                 strcpy(grouphead.grname, group);
 208                         }
 209                         if (netf)
 210                                 fclose(netf);
 211                 }
 212         }
 213         nextgrp = grouphead.gr;
 214 }
 215
 216 /*
 217  * Get the next netgroup off the list.
 218  */
 219 int
 220 getnetgrent(char **hostp, char **userp, char **domp)
 221 {
 222 #ifdef YP
 223         _yp_innetgr = 0;
 224 #endif
 225
 226         if (nextgrp) {
 227                 *hostp = nextgrp->ng_str[NG_HOST];
 228                 *userp = nextgrp->ng_str[NG_USER];
 229                 *domp = nextgrp->ng_str[NG_DOM];
 230                 nextgrp = nextgrp->ng_next;
 231                 return (1);
 232         }
 233         return (0);
 234 }
 235
 236 /*
 237  * endnetgrent() - cleanup
 238  */
 239 void
 240 endnetgrent(void)
 241 {
 242         struct linelist *lp, *olp;
 243         struct netgrp *gp, *ogp;
 244
 245         lp = linehead;
 246         while (lp) {
 247                 olp = lp;
 248                 lp = lp->l_next;
 249                 free(olp->l_groupname);
 250                 free(olp->l_line);
 251                 free((char *)olp);
 252         }
 253         linehead = (struct linelist *)0;
 254         if (grouphead.grname) {
 255                 free(grouphead.grname);
 256                 grouphead.grname = (char *)0;
 257         }
 258         gp = grouphead.gr;
 259         while (gp) {
 260                 ogp = gp;
 261                 gp = gp->ng_next;
 262                 if (ogp->ng_str[NG_HOST])
 263                         free(ogp->ng_str[NG_HOST]);
 264                 if (ogp->ng_str[NG_USER])
 265                         free(ogp->ng_str[NG_USER]);
 266                 if (ogp->ng_str[NG_DOM])
 267                         free(ogp->ng_str[NG_DOM]);
 268                 free((char *)ogp);
 269         }
 270         grouphead.gr = (struct netgrp *)0;
 271 #ifdef YP
 272         _netgr_yp_enabled = 0;
 273 #endif
 274 }
 275
 276 #ifdef YP
 277 static int
 278 _listmatch(const char *list, const char *group, int len)
 279 {
 280         const char *ptr = list, *cptr;
 281         int glen = strlen(group);
 282
 283         /* skip possible leading whitespace */
 284         while(isspace((unsigned char)*ptr))
 285                 ptr++;
 286
 287         while (ptr < list + len) {
 288                 cptr = ptr;
 289                 while(*ptr != ','  && *ptr != '\0' && !isspace((unsigned char)*ptr))
 290                         ptr++;
 291                 if (strncmp(cptr, group, glen) == 0 && glen == (ptr - cptr))
 292                         return(1);
 293                 while(*ptr == ','  || isspace((unsigned char)*ptr))
 294                         ptr++;
 295         }
 296
 297         return(0);
 298 }
 299
 300 static int
 301 _buildkey(char **key, const char *str, const char *dom, int *rotation)
 302 {
 303         if (key != NULL)
 304                 free(key);
 305         key = NULL;
 306         (*rotation)++;
 307         if (*rotation > 4)
 308                 return(0);
 309         switch(*rotation) {
 310                 case(1): asprintf(key, "%s.%s", str, dom ? dom : "*");
 311                          break;
 312                 case(2): asprintf(key, "%s.*", str);
 313                          break;
 314                 case(3): asprintf(key, "*.%s", dom ? dom : "*");
 315                          break;
 316                 case(4): asprintf(key, "*.*");
 317                          break;
 318         }
 319         if (key == NULL)
 320                 return(0);
 321         return(1);
 322 }
 323 #endif
 324
 325 /*
 326  * Search for a match in a netgroup.
 327  */
 328 int
 329 innetgr(const char *group, const char *host, const char *user, const char *dom)
 330 {
 331         char *hst, *usr, *dm;
 332 #ifdef YP
 333         char *result;
 334         int resultlen;
 335         int rv;
 336 #endif
 337         /* Sanity check */
 338
 339         if (group == NULL || !strlen(group))
 340                 return (0);
 341
 342 #ifdef YP
 343         _yp_innetgr = 1;
 344 #endif
 345         setnetgrent(group);
 346 #ifdef YP
 347         _yp_innetgr = 0;
 348         /*
 349          * If we're in NIS-only mode, do the search using
 350          * NIS 'reverse netgroup' lookups.
 351          */
 352         if (_use_only_yp) {
 353                 char *_key = NULL;
 354                 int rot = 0, y = 0;
 355
 356                 if(yp_get_default_domain(&_netgr_yp_domain))
 357                         return(0);
 358                 while(_buildkey(&_key, user ? user : host, dom, &rot)) {
 359                         y = yp_match(_netgr_yp_domain, user? "netgroup.byuser":
 360                             "netgroup.byhost", _key, strlen(_key), &result,
 361                                 &resultlen);
 362                         if (y) {
 363                                 /*
 364                                  * If we get an error other than 'no
 365                                  * such key in map' then something is
 366                                  * wrong and we should stop the search.
 367                                  */
 368                                 if (y != YPERR_KEY)
 369                                         break;
 370                         } else {
 371                                 rv = _listmatch(result, group, resultlen);
 372                                 free(result);
 373                                 if (_key != NULL)
 374                                         free(_key);
 375                                 if (rv)
 376                                         return(1);
 377                                 else
 378                                         return(0);
 379                         }
 380                 }
 381                 /*
 382                  * Couldn't match using NIS-exclusive mode. If the error
 383                  * was YPERR_MAP, then the failure happened because there
 384                  * was no netgroup.byhost or netgroup.byuser map. The odds
 385                  * are we are talking to an Sun NIS+ server in YP emulation
 386                  * mode; if this is the case, then we have to do the check
 387                  * the 'old-fashioned' way by grovelling through the netgroup
 388                  * map and resolving memberships on the fly.
 389                  */
 390                 if (_key != NULL)
 391                         free(_key);
 392                 if (y != YPERR_MAP)
 393                         return(0);
 394         }
 395
 396         setnetgrent(group);
 397 #endif /* YP */
 398
 399         while (getnetgrent(&hst, &usr, &dm))
 400                 if ((host == NULL || hst == NULL || !strcmp(host, hst)) &&
 401                     (user == NULL || usr == NULL || !strcmp(user, usr)) &&
 402                     ( dom == NULL ||  dm == NULL || !strcmp(dom, dm))) {
 403                         endnetgrent();
 404                         return (1);
 405                 }
 406         endnetgrent();
 407         return (0);
 408 }
 409
 410 /*
 411  * Parse the netgroup file setting up the linked lists.
 412  */
 413 static int
 414 parse_netgrp(const char *group)
 415 {
 416         char *spos, *epos;
 417         int len, strpos;
 418 #ifdef DEBUG
 419         int fields;
 420 #endif
 421         char *pos, *gpos;
 422         struct netgrp *grp;
 423         struct linelist *lp = linehead;
 424
 425         /*
 426          * First, see if the line has already been read in.
 427          */
 428         while (lp) {
 429                 if (!strcmp(group, lp->l_groupname))
 430                         break;
 431                 lp = lp->l_next;
 432         }
 433         if (lp == (struct linelist *)0 &&
 434             (lp = read_for_group(group)) == (struct linelist *)0)
 435                 return (1);
 436         if (lp->l_parsed) {
 437 #ifdef DEBUG
 438                 /*
 439                  * This error message is largely superflous since the
 440                  * code handles the error condition successfully, and
 441                  * spewing it out from inside libc can actually hose
 442                  * certain programs.
 443                  */
 444                 fprintf(stderr, "Cycle in netgroup %s\n", lp->l_groupname);
 445 #endif
 446                 return (1);
 447         } else
 448                 lp->l_parsed = 1;
 449         pos = lp->l_line;
 450         /* Watch for null pointer dereferences, dammit! */
 451         while (pos != NULL && *pos != '\0') {
 452                 if (*pos == '(') {
 453                         grp = (struct netgrp *)malloc(sizeof (struct netgrp));
 454                         bzero((char *)grp, sizeof (struct netgrp));
 455                         grp->ng_next = grouphead.gr;
 456                         grouphead.gr = grp;
 457                         pos++;
 458                         gpos = strsep(&pos, ")");
 459 #ifdef DEBUG
 460                         fields = 0;
 461 #endif
 462                         for (strpos = 0; strpos < 3; strpos++) {
 463                                 if ((spos = strsep(&gpos, ","))) {
 464 #ifdef DEBUG
 465                                         fields++;
 466 #endif
 467                                         while (*spos == ' ' || *spos == '\t')
 468                                                 spos++;
 469                                         if ((epos = strpbrk(spos, " \t"))) {
 470                                                 *epos = '\0';
 471                                                 len = epos - spos;
 472                                         } else
 473                                                 len = strlen(spos);
 474                                         if (len > 0) {
 475                                                 grp->ng_str[strpos] =  (char *)
 476                                                         malloc(len + 1);
 477                                                 bcopy(spos, grp->ng_str[strpos],
 478                                                         len + 1);
 479                                         }
 480                                 } else {
 481                                         /*
 482                                          * All other systems I've tested
 483                                          * return NULL for empty netgroup
 484                                          * fields. It's up to user programs
 485                                          * to handle the NULLs appropriately.
 486                                          */
 487                                         grp->ng_str[strpos] = NULL;
 488                                 }
 489                         }
 490 #ifdef DEBUG
 491                         /*
 492                          * Note: on other platforms, malformed netgroup
 493                          * entries are not normally flagged. While we
 494                          * can catch bad entries and report them, we should
 495                          * stay silent by default for compatibility's sake.
 496                          */
 497                         if (fields < 3)
 498                                         fprintf(stderr, "Bad entry (%s%s%s%s%s) in netgroup \"%s\"\n",
 499                                                 grp->ng_str[NG_HOST] == NULL ? "" : grp->ng_str[NG_HOST],
 500                                                 grp->ng_str[NG_USER] == NULL ? "" : ",",
 501                                                 grp->ng_str[NG_USER] == NULL ? "" : grp->ng_str[NG_USER],
 502                                                 grp->ng_str[NG_DOM] == NULL ? "" : ",",
 503                                                 grp->ng_str[NG_DOM] == NULL ? "" : grp->ng_str[NG_DOM],
 504                                                 lp->l_groupname);
 505 #endif
 506                 } else {
 507                         spos = strsep(&pos, ", \t");
 508                         if (parse_netgrp(spos))
 509                                 continue;
 510                 }
 511                 if (pos == NULL)
 512                         break;
 513                 while (*pos == ' ' || *pos == ',' || *pos == '\t')
 514                         pos++;
 515         }
 516         return (0);
 517 }
 518
 519 /*
 520  * Read the netgroup file and save lines until the line for the netgroup
 521  * is found. Return 1 if eof is encountered.
 522  */
 523 static struct linelist *
 524 read_for_group(const char *group)
 525 {
 526         char *pos, *spos, *linep = NULL, *olinep = NULL;
 527         int len, olen;
 528         int cont;
 529         struct linelist *lp;
 530         char line[LINSIZ + 2];
 531 #ifdef YP
 532         char *result;
 533         int resultlen;
 534
 535         while (_netgr_yp_enabled || fgets(line, LINSIZ, netf) != NULL) {
 536                 if (_netgr_yp_enabled) {
 537                         if(!_netgr_yp_domain)
 538                                 if(yp_get_default_domain(&_netgr_yp_domain))
 539                                         continue;
 540                         if (yp_match(_netgr_yp_domain, "netgroup", group,
 541                                         strlen(group), &result, &resultlen)) {
 542                                 free(result);
 543                                 if (_use_only_yp)
 544                                         return ((struct linelist *)0);
 545                                 else {
 546                                         _netgr_yp_enabled = 0;
 547                                         continue;
 548                                 }
 549                         }
 550                         snprintf(line, LINSIZ, "%s %s", group, result);
 551                         free(result);
 552                 }
 553 #else
 554         while (fgets(line, LINSIZ, netf) != NULL) {
 555 #endif
 556                 pos = (char *)&line;
 557 #ifdef YP
 558                 if (*pos == '+') {
 559                         _netgr_yp_enabled = 1;
 560                         continue;
 561                 }
 562 #endif
 563                 if (*pos == '#')
 564                         continue;
 565                 while (*pos == ' ' || *pos == '\t')
 566                         pos++;
 567                 spos = pos;
 568                 while (*pos != ' ' && *pos != '\t' && *pos != '\n' &&
 569                         *pos != '\0')
 570                         pos++;
 571                 len = pos - spos;
 572                 while (*pos == ' ' || *pos == '\t')
 573                         pos++;
 574                 if (*pos != '\n' && *pos != '\0') {
 575                         lp = (struct linelist *)malloc(sizeof (*lp));
 576                         lp->l_parsed = 0;
 577                         lp->l_groupname = (char *)malloc(len + 1);
 578                         bcopy(spos, lp->l_groupname, len);
 579                         *(lp->l_groupname + len) = '\0';
 580                         len = strlen(pos);
 581                         olen = 0;
 582
 583                         /*
 584                          * Loop around handling line continuations.
 585                          */
 586                         do {
 587                                 if (*(pos + len - 1) == '\n')
 588                                         len--;
 589                                 if (*(pos + len - 1) == '\\') {
 590                                         len--;
 591                                         cont = 1;
 592                                 } else
 593                                         cont = 0;
 594                                 if (len > 0) {
 595                                         linep = (char *)malloc(olen + len + 1);
 596                                         if (olen > 0) {
 597                                                 bcopy(olinep, linep, olen);
 598                                                 free(olinep);
 599                                         }
 600                                         bcopy(pos, linep + olen, len);
 601                                         olen += len;
 602                                         *(linep + olen) = '\0';
 603                                         olinep = linep;
 604                                 }
 605                                 if (cont) {
 606                                         if (fgets(line, LINSIZ, netf)) {
 607                                                 pos = line;
 608                                                 len = strlen(pos);
 609                                         } else
 610                                                 cont = 0;
 611                                 }
 612                         } while (cont);
 613                         lp->l_line = linep;
 614                         lp->l_next = linehead;
 615                         linehead = lp;
 616
 617                         /*
 618                          * If this is the one we wanted, we are done.
 619                          */
 620                         if (!strcmp(lp->l_groupname, group))
 621                                 return (lp);
 622                 }
 623         }
 624 #ifdef YP
 625         /*
 626          * Yucky. The recursive nature of this whole mess might require
 627          * us to make more than one pass through the netgroup file.
 628          * This might be best left outside the #ifdef YP, but YP is
 629          * defined by default anyway, so I'll leave it like this
 630          * until I know better.
 631          */
 632         rewind(netf);
 633 #endif
 634         return (NULL);
 635 }