nis/nss_compat/compat-spwd.c

   1 /* Copyright (C) 1996-1999, 2001-2006, 2007 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1996.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <ctype.h>
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <netdb.h>
  24 #include <nss.h>
  25 #include <nsswitch.h>
  26 #include <shadow.h>
  27 #include <stdio_ext.h>
  28 #include <string.h>
  29 #include <rpc/types.h>
  30 #include <rpcsvc/ypclnt.h>
  31 #include <bits/libc-lock.h>
  32 #include <kernel-features.h>
  33
  34 #include "netgroup.h"
  35
  36 static service_user *ni;
  37 static enum nss_status (*nss_setspent) (int stayopen);
  38 static enum nss_status (*nss_getspnam_r) (const char *name, struct spwd * sp,
  39                                           char *buffer, size_t buflen,
  40                                           int *errnop);
  41 static enum nss_status (*nss_getspent_r) (struct spwd * sp, char *buffer,
  42                                           size_t buflen, int *errnop);
  43 static enum nss_status (*nss_endspent) (void);
  44
  45 /* Get the declaration of the parser function.  */
  46 #define ENTNAME spent
  47 #define STRUCTURE spwd
  48 #define EXTERN_PARSER
  49 #include <nss/nss_files/files-parse.c>
  50
  51 /* Structure for remembering -@netgroup and -user members ... */
  52 #define BLACKLIST_INITIAL_SIZE 512
  53 #define BLACKLIST_INCREMENT 256
  54 struct blacklist_t
  55 {
  56   char *data;
  57   int current;
  58   int size;
  59 };
  60
  61 struct ent_t
  62 {
  63   bool netgroup;
  64   bool files;
  65   bool first;
  66   enum nss_status setent_status;
  67   FILE *stream;
  68   struct blacklist_t blacklist;
  69   struct spwd pwd;
  70   struct __netgrent netgrdata;
  71 };
  72 typedef struct ent_t ent_t;
  73
  74 static ent_t ext_ent = { false, true, false, NSS_STATUS_SUCCESS, NULL,
  75                          { NULL, 0, 0},
  76                          { NULL, NULL, 0, 0, 0, 0, 0, 0, 0}};
  77
  78 /* Protect global state against multiple changers.  */
  79 __libc_lock_define_initialized (static, lock)
  80
  81 /* Positive if O_CLOEXEC is supported, negative if it is not supported,
  82    zero if it is still undecided.  This variable is shared with the
  83    other compat functions.  */
  84 #ifdef __ASSUME_O_CLOEXEC
  85 # define __compat_have_cloexec 1
  86 #else
  87 # ifdef O_CLOEXEC
  88 extern int __compat_have_cloexec;
  89 # else
  90 #  define __compat_have_cloexec -1
  91 # endif
  92 #endif
  93
  94 /* Prototypes for local functions.  */
  95 static void blacklist_store_name (const char *, ent_t *);
  96 static int in_blacklist (const char *, int, ent_t *);
  97
  98 /* Initialize the NSS interface/functions. The calling function must
  99    hold the lock.  */
 100 static void
 101 init_nss_interface (void)
 102 {
 103   if (__nss_database_lookup ("shadow_compat", "passwd_compat",
 104                              "nis", &ni) >= 0)
 105     {
 106       nss_setspent = __nss_lookup_function (ni, "setspent");
 107       nss_getspnam_r = __nss_lookup_function (ni, "getspnam_r");
 108       nss_getspent_r = __nss_lookup_function (ni, "getspent_r");
 109       nss_endspent = __nss_lookup_function (ni, "endspent");
 110     }
 111 }
 112
 113 static void
 114 give_spwd_free (struct spwd *pwd)
 115 {
 116   if (pwd->sp_namp != NULL)
 117     free (pwd->sp_namp);
 118   if (pwd->sp_pwdp != NULL)
 119     free (pwd->sp_pwdp);
 120
 121   memset (pwd, '\0', sizeof (struct spwd));
 122   pwd->sp_warn = -1;
 123   pwd->sp_inact = -1;
 124   pwd->sp_expire = -1;
 125   pwd->sp_flag = ~0ul;
 126 }
 127
 128 static int
 129 spwd_need_buflen (struct spwd *pwd)
 130 {
 131   int len = 0;
 132
 133   if (pwd->sp_pwdp != NULL)
 134     len += strlen (pwd->sp_pwdp) + 1;
 135
 136   return len;
 137 }
 138
 139 static void
 140 copy_spwd_changes (struct spwd *dest, struct spwd *src,
 141                    char *buffer, size_t buflen)
 142 {
 143   if (src->sp_pwdp != NULL && strlen (src->sp_pwdp))
 144     {
 145       if (buffer == NULL)
 146         dest->sp_pwdp = strdup (src->sp_pwdp);
 147       else if (dest->sp_pwdp &&
 148                strlen (dest->sp_pwdp) >= strlen (src->sp_pwdp))
 149         strcpy (dest->sp_pwdp, src->sp_pwdp);
 150       else
 151         {
 152           dest->sp_pwdp = buffer;
 153           strcpy (dest->sp_pwdp, src->sp_pwdp);
 154           buffer += strlen (dest->sp_pwdp) + 1;
 155           buflen = buflen - (strlen (dest->sp_pwdp) + 1);
 156         }
 157     }
 158   if (src->sp_lstchg != 0)
 159     dest->sp_lstchg = src->sp_lstchg;
 160   if (src->sp_min != 0)
 161     dest->sp_min = src->sp_min;
 162   if (src->sp_max != 0)
 163     dest->sp_max = src->sp_max;
 164   if (src->sp_warn != -1)
 165     dest->sp_warn = src->sp_warn;
 166   if (src->sp_inact != -1)
 167     dest->sp_inact = src->sp_inact;
 168   if (src->sp_expire != -1)
 169     dest->sp_expire = src->sp_expire;
 170   if (src->sp_flag != ~0ul)
 171     dest->sp_flag = src->sp_flag;
 172 }
 173
 174 static enum nss_status
 175 internal_setspent (ent_t *ent, int stayopen)
 176 {
 177   enum nss_status status = NSS_STATUS_SUCCESS;
 178
 179   ent->first = ent->netgroup = 0;
 180   ent->files = true;
 181
 182   /* If something was left over free it.  */
 183   if (ent->netgroup)
 184     __internal_endnetgrent (&ent->netgrdata);
 185
 186   if (ent->blacklist.data != NULL)
 187     {
 188       ent->blacklist.current = 1;
 189       ent->blacklist.data[0] = '|';
 190       ent->blacklist.data[1] = '\0';
 191     }
 192   else
 193     ent->blacklist.current = 0;
 194
 195   if (ent->stream == NULL)
 196     {
 197       ent->stream = fopen ("/etc/shadow", "rme");
 198
 199       if (ent->stream == NULL)
 200         status = errno == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
 201       else
 202         {
 203           /* We have to make sure the file is  `closed on exec'.  */
 204           int result = 0;
 205
 206           if (__compat_have_cloexec <= 0)
 207             {
 208               int flags;
 209               result = flags = fcntl (fileno_unlocked (ent->stream), F_GETFD,
 210                                       0);
 211               if (result >= 0)
 212                 {
 213 #if defined O_CLOEXEC && !defined __ASSUME_O_CLOEXEC
 214                   if (__compat_have_cloexec == 0)
 215                     __compat_have_cloexec = (flags & FD_CLOEXEC) ? 1 : -1;
 216
 217                   if (__compat_have_cloexec < 0)
 218 #endif
 219                     {
 220                       flags |= FD_CLOEXEC;
 221                       result = fcntl (fileno_unlocked (ent->stream), F_SETFD,
 222                                       flags);
 223                     }
 224                 }
 225             }
 226
 227           if (result < 0)
 228             {
 229               /* Something went wrong.  Close the stream and return a
 230                  failure.  */
 231               fclose (ent->stream);
 232               ent->stream = NULL;
 233               status = NSS_STATUS_UNAVAIL;
 234             }
 235           else
 236             /* We take care of locking ourself.  */
 237             __fsetlocking (ent->stream, FSETLOCKING_BYCALLER);
 238         }
 239     }
 240   else
 241     rewind (ent->stream);
 242
 243   give_spwd_free (&ent->pwd);
 244
 245   if (status == NSS_STATUS_SUCCESS && nss_setspent)
 246     ent->setent_status = nss_setspent (stayopen);
 247
 248   return status;
 249 }
 250
 251
 252 enum nss_status
 253 _nss_compat_setspent (int stayopen)
 254 {
 255   enum nss_status result;
 256
 257   __libc_lock_lock (lock);
 258
 259   if (ni == NULL)
 260     init_nss_interface ();
 261
 262   result = internal_setspent (&ext_ent, stayopen);
 263
 264   __libc_lock_unlock (lock);
 265
 266   return result;
 267 }
 268
 269
 270 static enum nss_status
 271 internal_endspent (ent_t *ent)
 272 {
 273   if (nss_endspent)
 274     nss_endspent ();
 275
 276   if (ent->stream != NULL)
 277     {
 278       fclose (ent->stream);
 279       ent->stream = NULL;
 280     }
 281
 282   if (ent->netgroup)
 283     __internal_endnetgrent (&ent->netgrdata);
 284
 285   ent->first = ent->netgroup = false;
 286   ent->files = true;
 287
 288   if (ent->blacklist.data != NULL)
 289     {
 290       ent->blacklist.current = 1;
 291       ent->blacklist.data[0] = '|';
 292       ent->blacklist.data[1] = '\0';
 293     }
 294   else
 295     ent->blacklist.current = 0;
 296
 297   give_spwd_free (&ent->pwd);
 298
 299   return NSS_STATUS_SUCCESS;
 300 }
 301
 302 enum nss_status
 303 _nss_compat_endspent (void)
 304 {
 305   enum nss_status result;
 306
 307   __libc_lock_lock (lock);
 308
 309   result = internal_endspent (&ext_ent);
 310
 311   __libc_lock_unlock (lock);
 312
 313   return result;
 314 }
 315
 316
 317 static enum nss_status
 318 getspent_next_nss_netgr (const char *name, struct spwd *result, ent_t *ent,
 319                          char *group, char *buffer, size_t buflen,
 320                          int *errnop)
 321 {
 322   char *curdomain, *host, *user, *domain, *p2;
 323   size_t p2len;
 324
 325   if (!nss_getspnam_r)
 326     return NSS_STATUS_UNAVAIL;
 327
 328   /* If the setpwent call failed, say so.  */
 329   if (ent->setent_status != NSS_STATUS_SUCCESS)
 330     return ent->setent_status;
 331
 332   if (yp_get_default_domain (&curdomain) != YPERR_SUCCESS)
 333     {
 334       ent->netgroup = false;
 335       ent->first = false;
 336       give_spwd_free (&ent->pwd);
 337       return NSS_STATUS_UNAVAIL;
 338     }
 339
 340   if (ent->first == true)
 341     {
 342       memset (&ent->netgrdata, 0, sizeof (struct __netgrent));
 343       __internal_setnetgrent (group, &ent->netgrdata);
 344       ent->first = false;
 345     }
 346
 347   while (1)
 348     {
 349       char *saved_cursor;
 350       enum nss_status status;
 351
 352       saved_cursor = ent->netgrdata.cursor;
 353       status = __internal_getnetgrent_r (&host, &user, &domain,
 354                                          &ent->netgrdata, buffer, buflen,
 355                                          errnop);
 356       if (status != 1)
 357         {
 358           __internal_endnetgrent (&ent->netgrdata);
 359           ent->netgroup = false;
 360           give_spwd_free (&ent->pwd);
 361           return NSS_STATUS_RETURN;
 362         }
 363
 364       if (user == NULL || user[0] == '-')
 365         continue;
 366
 367       if (domain != NULL && strcmp (curdomain, domain) != 0)
 368         continue;
 369
 370       /* If name != NULL, we are called from getpwnam */
 371       if (name != NULL)
 372         if (strcmp (user, name) != 0)
 373           continue;
 374
 375       p2len = spwd_need_buflen (&ent->pwd);
 376       if (p2len > buflen)
 377         {
 378           *errnop = ERANGE;
 379           return NSS_STATUS_TRYAGAIN;
 380         }
 381       p2 = buffer + (buflen - p2len);
 382       buflen -= p2len;
 383
 384       if (nss_getspnam_r (user, result, buffer, buflen, errnop) !=
 385           NSS_STATUS_SUCCESS)
 386         continue;
 387
 388       if (!in_blacklist (result->sp_namp, strlen (result->sp_namp), ent))
 389         {
 390           /* Store the User in the blacklist for possible the "+" at the
 391              end of /etc/passwd */
 392           blacklist_store_name (result->sp_namp, ent);
 393           copy_spwd_changes (result, &ent->pwd, p2, p2len);
 394           break;
 395         }
 396     }
 397
 398   return NSS_STATUS_SUCCESS;
 399 }
 400
 401
 402 static enum nss_status
 403 getspent_next_nss (struct spwd *result, ent_t *ent,
 404                    char *buffer, size_t buflen, int *errnop)
 405 {
 406   enum nss_status status;
 407   char *p2;
 408   size_t p2len;
 409
 410   if (!nss_getspent_r)
 411     return NSS_STATUS_UNAVAIL;
 412
 413   p2len = spwd_need_buflen (&ent->pwd);
 414   if (p2len > buflen)
 415     {
 416       *errnop = ERANGE;
 417       return NSS_STATUS_TRYAGAIN;
 418     }
 419   p2 = buffer + (buflen - p2len);
 420   buflen -= p2len;
 421   do
 422     {
 423       if ((status = nss_getspent_r (result, buffer, buflen, errnop)) !=
 424           NSS_STATUS_SUCCESS)
 425         return status;
 426     }
 427   while (in_blacklist (result->sp_namp, strlen (result->sp_namp), ent));
 428
 429   copy_spwd_changes (result, &ent->pwd, p2, p2len);
 430
 431   return NSS_STATUS_SUCCESS;
 432 }
 433
 434
 435 /* This function handle the +user entrys in /etc/shadow */
 436 static enum nss_status
 437 getspnam_plususer (const char *name, struct spwd *result, ent_t *ent,
 438                    char *buffer, size_t buflen, int *errnop)
 439 {
 440   if (!nss_getspnam_r)
 441     return NSS_STATUS_UNAVAIL;
 442
 443   struct spwd pwd;
 444   memset (&pwd, '\0', sizeof (struct spwd));
 445   pwd.sp_warn = -1;
 446   pwd.sp_inact = -1;
 447   pwd.sp_expire = -1;
 448   pwd.sp_flag = ~0ul;
 449
 450   copy_spwd_changes (&pwd, result, NULL, 0);
 451
 452   size_t plen = spwd_need_buflen (&pwd);
 453   if (plen > buflen)
 454     {
 455       *errnop = ERANGE;
 456       return NSS_STATUS_TRYAGAIN;
 457     }
 458   char *p = buffer + (buflen - plen);
 459   buflen -= plen;
 460
 461   enum nss_status status = nss_getspnam_r (name, result, buffer, buflen,
 462                                            errnop);
 463   if (status != NSS_STATUS_SUCCESS)
 464     return status;
 465
 466   if (in_blacklist (result->sp_namp, strlen (result->sp_namp), ent))
 467     return NSS_STATUS_NOTFOUND;
 468
 469   copy_spwd_changes (result, &pwd, p, plen);
 470   give_spwd_free (&pwd);
 471   /* We found the entry.  */
 472   return NSS_STATUS_SUCCESS;
 473 }
 474
 475
 476 static enum nss_status
 477 getspent_next_file (struct spwd *result, ent_t *ent,
 478                     char *buffer, size_t buflen, int *errnop)
 479 {
 480   struct parser_data *data = (void *) buffer;
 481   while (1)
 482     {
 483       fpos_t pos;
 484       int parse_res = 0;
 485       char *p;
 486
 487       do
 488         {
 489           /* We need at least 3 characters for one line.  */
 490           if (__builtin_expect (buflen < 3, 0))
 491             {
 492             erange:
 493               *errnop = ERANGE;
 494               return NSS_STATUS_TRYAGAIN;
 495             }
 496
 497           fgetpos (ent->stream, &pos);
 498           buffer[buflen - 1] = '\xff';
 499           p = fgets_unlocked (buffer, buflen, ent->stream);
 500           if (p == NULL && feof_unlocked (ent->stream))
 501             return NSS_STATUS_NOTFOUND;
 502
 503           if (p == NULL || __builtin_expect (buffer[buflen - 1] != '\xff', 0))
 504             {
 505             erange_reset:
 506               fsetpos (ent->stream, &pos);
 507               goto erange;
 508             }
 509
 510           /* Skip leading blanks.  */
 511           while (isspace (*p))
 512             ++p;
 513         }
 514       while (*p == '\0' || *p == '#'    /* Ignore empty and comment lines.  */
 515              /* Parse the line.  If it is invalid, loop to
 516                 get the next line of the file to parse.  */
 517              || !(parse_res = _nss_files_parse_spent (p, result, data,
 518                                                       buflen, errnop)));
 519
 520       if (__builtin_expect (parse_res == -1, 0))
 521         /* The parser ran out of space.  */
 522         goto erange_reset;
 523
 524       if (result->sp_namp[0] != '+' && result->sp_namp[0] != '-')
 525         /* This is a real entry.  */
 526         break;
 527
 528       /* -@netgroup */
 529       if (result->sp_namp[0] == '-' && result->sp_namp[1] == '@'
 530           && result->sp_namp[2] != '\0')
 531         {
 532           /* XXX Do not use fixed length buffers.  */
 533           char buf2[1024];
 534           char *user, *host, *domain;
 535           struct __netgrent netgrdata;
 536
 537           bzero (&netgrdata, sizeof (struct __netgrent));
 538           __internal_setnetgrent (&result->sp_namp[2], &netgrdata);
 539           while (__internal_getnetgrent_r (&host, &user, &domain,
 540                                            &netgrdata, buf2, sizeof (buf2),
 541                                            errnop))
 542             {
 543               if (user != NULL && user[0] != '-')
 544                 blacklist_store_name (user, ent);
 545             }
 546           __internal_endnetgrent (&netgrdata);
 547           continue;
 548         }
 549
 550       /* +@netgroup */
 551       if (result->sp_namp[0] == '+' && result->sp_namp[1] == '@'
 552           && result->sp_namp[2] != '\0')
 553         {
 554           int status;
 555
 556           ent->netgroup = true;
 557           ent->first = true;
 558           copy_spwd_changes (&ent->pwd, result, NULL, 0);
 559
 560           status = getspent_next_nss_netgr (NULL, result, ent,
 561                                             &result->sp_namp[2],
 562                                             buffer, buflen, errnop);
 563           if (status == NSS_STATUS_RETURN)
 564             continue;
 565           else
 566             return status;
 567         }
 568
 569       /* -user */
 570       if (result->sp_namp[0] == '-' && result->sp_namp[1] != '\0'
 571           && result->sp_namp[1] != '@')
 572         {
 573           blacklist_store_name (&result->sp_namp[1], ent);
 574           continue;
 575         }
 576
 577       /* +user */
 578       if (result->sp_namp[0] == '+' && result->sp_namp[1] != '\0'
 579           && result->sp_namp[1] != '@')
 580         {
 581           size_t len = strlen (result->sp_namp);
 582           char buf[len];
 583           enum nss_status status;
 584
 585           /* Store the User in the blacklist for the "+" at the end of
 586              /etc/passwd */
 587           memcpy (buf, &result->sp_namp[1], len);
 588           status = getspnam_plususer (&result->sp_namp[1], result, ent,
 589                                       buffer, buflen, errnop);
 590           blacklist_store_name (buf, ent);
 591
 592           if (status == NSS_STATUS_SUCCESS)     /* We found the entry. */
 593             break;
 594           /* We couldn't parse the entry */
 595           else if (status == NSS_STATUS_RETURN
 596                    /* entry doesn't exist */
 597                    || status == NSS_STATUS_NOTFOUND)
 598             continue;
 599           else
 600             {
 601               if (status == NSS_STATUS_TRYAGAIN)
 602                 {
 603                   fsetpos (ent->stream, &pos);
 604                   *errnop = ERANGE;
 605                 }
 606               return status;
 607             }
 608         }
 609
 610       /* +:... */
 611       if (result->sp_namp[0] == '+' && result->sp_namp[1] == '\0')
 612         {
 613           ent->files = false;
 614           ent->first = true;
 615           copy_spwd_changes (&ent->pwd, result, NULL, 0);
 616
 617           return getspent_next_nss (result, ent, buffer, buflen, errnop);
 618         }
 619     }
 620
 621   return NSS_STATUS_SUCCESS;
 622 }
 623
 624
 625 static enum nss_status
 626 internal_getspent_r (struct spwd *pw, ent_t *ent,
 627                      char *buffer, size_t buflen, int *errnop)
 628 {
 629   if (ent->netgroup)
 630     {
 631       enum nss_status status;
 632
 633       /* We are searching members in a netgroup */
 634       /* Since this is not the first call, we don't need the group name */
 635       status = getspent_next_nss_netgr (NULL, pw, ent, NULL, buffer,
 636                                         buflen, errnop);
 637
 638       if (status == NSS_STATUS_RETURN)
 639         return getspent_next_file (pw, ent, buffer, buflen, errnop);
 640       else
 641         return status;
 642     }
 643   else if (ent->files)
 644     return getspent_next_file (pw, ent, buffer, buflen, errnop);
 645   else
 646     return getspent_next_nss (pw, ent, buffer, buflen, errnop);
 647 }
 648
 649
 650 enum nss_status
 651 _nss_compat_getspent_r (struct spwd *pwd, char *buffer, size_t buflen,
 652                         int *errnop)
 653 {
 654   enum nss_status result = NSS_STATUS_SUCCESS;
 655
 656   __libc_lock_lock (lock);
 657
 658   /* Be prepared that the setpwent function was not called before.  */
 659   if (ni == NULL)
 660     init_nss_interface ();
 661
 662   if (ext_ent.stream == NULL)
 663     result = internal_setspent (&ext_ent, 1);
 664
 665   if (result == NSS_STATUS_SUCCESS)
 666     result = internal_getspent_r (pwd, &ext_ent, buffer, buflen, errnop);
 667
 668   __libc_lock_unlock (lock);
 669
 670   return result;
 671 }
 672
 673
 674 /* Searches in /etc/passwd and the NIS/NIS+ map for a special user */
 675 static enum nss_status
 676 internal_getspnam_r (const char *name, struct spwd *result, ent_t *ent,
 677                      char *buffer, size_t buflen, int *errnop)
 678 {
 679   struct parser_data *data = (void *) buffer;
 680
 681   while (1)
 682     {
 683       fpos_t pos;
 684       char *p;
 685       int parse_res;
 686
 687       do
 688         {
 689           /* We need at least 3 characters for one line.  */
 690           if (__builtin_expect (buflen < 3, 0))
 691             {
 692             erange:
 693               *errnop = ERANGE;
 694               return NSS_STATUS_TRYAGAIN;
 695             }
 696
 697           fgetpos (ent->stream, &pos);
 698           buffer[buflen - 1] = '\xff';
 699           p = fgets_unlocked (buffer, buflen, ent->stream);
 700           if (p == NULL && feof_unlocked (ent->stream))
 701             return NSS_STATUS_NOTFOUND;
 702
 703           if (p == NULL || buffer[buflen - 1] != '\xff')
 704             {
 705             erange_reset:
 706               fsetpos (ent->stream, &pos);
 707               goto erange;
 708             }
 709
 710           /* Terminate the line for any case.  */
 711           buffer[buflen - 1] = '\0';
 712
 713           /* Skip leading blanks.  */
 714           while (isspace (*p))
 715             ++p;
 716         }
 717       while (*p == '\0' || *p == '#' || /* Ignore empty and comment lines.  */
 718              /* Parse the line.  If it is invalid, loop to
 719                 get the next line of the file to parse.  */
 720              !(parse_res = _nss_files_parse_spent (p, result, data, buflen,
 721                                                    errnop)));
 722
 723       if (__builtin_expect (parse_res == -1, 0))
 724         /* The parser ran out of space.  */
 725         goto erange_reset;
 726
 727       /* This is a real entry.  */
 728       if (result->sp_namp[0] != '+' && result->sp_namp[0] != '-')
 729         {
 730           if (strcmp (result->sp_namp, name) == 0)
 731             return NSS_STATUS_SUCCESS;
 732           else
 733             continue;
 734         }
 735
 736       /* -@netgroup */
 737       /* If the loaded NSS module does not support this service, add
 738          all users from a +@netgroup entry to the blacklist, too.  */
 739       if (result->sp_namp[0] == '-' && result->sp_namp[1] == '@'
 740           && result->sp_namp[2] != '\0')
 741         {
 742           if (innetgr (&result->sp_namp[2], NULL, name, NULL))
 743             return NSS_STATUS_NOTFOUND;
 744           continue;
 745         }
 746
 747       /* +@netgroup */
 748       if (result->sp_namp[0] == '+' && result->sp_namp[1] == '@'
 749           && result->sp_namp[2] != '\0')
 750         {
 751           enum nss_status status;
 752
 753           if (innetgr (&result->sp_namp[2], NULL, name, NULL))
 754             {
 755               status = getspnam_plususer (name, result, ent, buffer,
 756                                           buflen, errnop);
 757
 758               if (status == NSS_STATUS_RETURN)
 759                 continue;
 760
 761               return status;
 762             }
 763           continue;
 764         }
 765
 766       /* -user */
 767       if (result->sp_namp[0] == '-' && result->sp_namp[1] != '\0'
 768           && result->sp_namp[1] != '@')
 769         {
 770           if (strcmp (&result->sp_namp[1], name) == 0)
 771             return NSS_STATUS_NOTFOUND;
 772           else
 773             continue;
 774         }
 775
 776       /* +user */
 777       if (result->sp_namp[0] == '+' && result->sp_namp[1] != '\0'
 778           && result->sp_namp[1] != '@')
 779         {
 780           if (strcmp (name, &result->sp_namp[1]) == 0)
 781             {
 782               enum nss_status status;
 783
 784               status = getspnam_plususer (name, result, ent,
 785                                           buffer, buflen, errnop);
 786
 787               if (status == NSS_STATUS_RETURN)
 788                 /* We couldn't parse the entry */
 789                 return NSS_STATUS_NOTFOUND;
 790               else
 791                 return status;
 792             }
 793         }
 794
 795       /* +:... */
 796       if (result->sp_namp[0] == '+' && result->sp_namp[1] == '\0')
 797         {
 798           enum nss_status status;
 799
 800           status = getspnam_plususer (name, result, ent,
 801                                       buffer, buflen, errnop);
 802
 803           if (status == NSS_STATUS_SUCCESS)
 804             /* We found the entry. */
 805             break;
 806           else if (status == NSS_STATUS_RETURN)
 807             /* We couldn't parse the entry */
 808             return NSS_STATUS_NOTFOUND;
 809           else
 810             return status;
 811         }
 812     }
 813   return NSS_STATUS_SUCCESS;
 814 }
 815
 816
 817 enum nss_status
 818 _nss_compat_getspnam_r (const char *name, struct spwd *pwd,
 819                         char *buffer, size_t buflen, int *errnop)
 820 {
 821   enum nss_status result;
 822   ent_t ent = { false, true, false, NSS_STATUS_SUCCESS, NULL, { NULL, 0, 0},
 823                 { NULL, NULL, 0, 0, 0, 0, 0, 0, 0}};
 824
 825   if (name[0] == '-' || name[0] == '+')
 826     return NSS_STATUS_NOTFOUND;
 827
 828   __libc_lock_lock (lock);
 829
 830   if (ni == NULL)
 831     init_nss_interface ();
 832
 833   __libc_lock_unlock (lock);
 834
 835   result = internal_setspent (&ent, 0);
 836
 837   if (result == NSS_STATUS_SUCCESS)
 838     result = internal_getspnam_r (name, pwd, &ent, buffer, buflen, errnop);
 839
 840   internal_endspent (&ent);
 841
 842   return result;
 843 }
 844
 845
 846 /* Support routines for remembering -@netgroup and -user entries.
 847    The names are stored in a single string with `|' as separator. */
 848 static void
 849 blacklist_store_name (const char *name, ent_t *ent)
 850 {
 851   int namelen = strlen (name);
 852   char *tmp;
 853
 854   /* first call, setup cache */
 855   if (ent->blacklist.size == 0)
 856     {
 857       ent->blacklist.size = MAX (BLACKLIST_INITIAL_SIZE, 2 * namelen);
 858       ent->blacklist.data = malloc (ent->blacklist.size);
 859       if (ent->blacklist.data == NULL)
 860         return;
 861       ent->blacklist.data[0] = '|';
 862       ent->blacklist.data[1] = '\0';
 863       ent->blacklist.current = 1;
 864     }
 865   else
 866     {
 867       if (in_blacklist (name, namelen, ent))
 868         return;                 /* no duplicates */
 869
 870       if (ent->blacklist.current + namelen + 1 >= ent->blacklist.size)
 871         {
 872           ent->blacklist.size += MAX (BLACKLIST_INCREMENT, 2 * namelen);
 873           tmp = realloc (ent->blacklist.data, ent->blacklist.size);
 874           if (tmp == NULL)
 875             {
 876               free (ent->blacklist.data);
 877               ent->blacklist.size = 0;
 878               return;
 879             }
 880           ent->blacklist.data = tmp;
 881         }
 882     }
 883
 884   tmp = stpcpy (ent->blacklist.data + ent->blacklist.current, name);
 885   *tmp++ = '|';
 886   *tmp = '\0';
 887   ent->blacklist.current += namelen + 1;
 888
 889   return;
 890 }
 891
 892
 893 /* Returns TRUE if ent->blacklist contains name, else FALSE.  */
 894 static bool_t
 895 in_blacklist (const char *name, int namelen, ent_t *ent)
 896 {
 897   char buf[namelen + 3];
 898   char *cp;
 899
 900   if (ent->blacklist.data == NULL)
 901     return false;
 902
 903   buf[0] = '|';
 904   cp = stpcpy (&buf[1], name);
 905   *cp++ = '|';
 906   *cp = '\0';
 907   return strstr (ent->blacklist.data, buf) != NULL;
 908 }