inet/getnetgrent_r.c

   1 /* Copyright (C) 1996-2014 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <http://www.gnu.org/licenses/>.  */
  17
  18 #include <assert.h>
  19 #include <atomic.h>
  20 #include <bits/libc-lock.h>
  21 #include <errno.h>
  22 #include <netdb.h>
  23 #include <stdbool.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include "netgroup.h"
  27 #include "nsswitch.h"
  28 #include <sysdep.h>
  29 #include <nscd/nscd_proto.h>
  30
  31
  32 /* Protect above variable against multiple uses at the same time.  */
  33 __libc_lock_define_initialized (static, lock)
  34
  35 /* The whole information for the set/get/endnetgrent functions are
  36    kept in this structure.  */
  37 static struct __netgrent dataset;
  38
  39 /* The lookup function for the first entry of this service.  */
  40 extern int __nss_netgroup_lookup (service_user **nipp, const char *name,
  41                                   void **fctp) internal_function;
  42
  43 /* Set up NIP to run through the services.  Return nonzero if there are no
  44    services (left).  */
  45 static int
  46 setup (void **fctp, service_user **nipp)
  47 {
  48   /* Remember the first service_entry, it's always the same.  */
  49   static bool startp_initialized;
  50   static service_user *startp;
  51   int no_more;
  52
  53   if (!startp_initialized)
  54     {
  55       /* Executing this more than once at the same time must yield the
  56          same result every time.  So we need no locking.  */
  57       no_more = __nss_netgroup_lookup (nipp, "setnetgrent", fctp);
  58       startp = no_more ? (service_user *) -1 : *nipp;
  59 #ifdef PTR_MANGLE
  60       PTR_MANGLE (startp);
  61 #endif
  62       atomic_write_barrier ();
  63       startp_initialized = true;
  64     }
  65   else
  66     {
  67       service_user *nip = startp;
  68 #ifdef PTR_DEMANGLE
  69       PTR_DEMANGLE (nip);
  70 #endif
  71       if (nip == (service_user *) -1)
  72         /* No services at all.  */
  73         return 1;
  74
  75       /* Reset to the beginning of the service list.  */
  76       *nipp = nip;
  77       /* Look up the first function.  */
  78       no_more = __nss_lookup (nipp, "setnetgrent", NULL, fctp);
  79     }
  80   return no_more;
  81 }
  82 \f
  83 /* Free used memory.  */
  84 static void
  85 free_memory (struct __netgrent *data)
  86 {
  87   while (data->known_groups != NULL)
  88     {
  89       struct name_list *tmp = data->known_groups;
  90       data->known_groups = data->known_groups->next;
  91       free (tmp);
  92     }
  93
  94   while (data->needed_groups != NULL)
  95     {
  96       struct name_list *tmp = data->needed_groups;
  97       data->needed_groups = data->needed_groups->next;
  98       free (tmp);
  99     }
 100 }
 101 \f
 102 static void
 103 endnetgrent_hook (struct __netgrent *datap)
 104 {
 105   enum nss_status (*endfct) (struct __netgrent *);
 106
 107   if (datap->nip == NULL || datap->nip == (service_user *) -1l)
 108     return;
 109
 110   endfct = __nss_lookup_function (datap->nip, "endnetgrent");
 111   if (endfct != NULL)
 112     (void) (*endfct) (datap);
 113   datap->nip = NULL;
 114 }
 115
 116 static int
 117 internal_function
 118 __internal_setnetgrent_reuse (const char *group, struct __netgrent *datap,
 119                               int *errnop)
 120 {
 121   union
 122   {
 123     enum nss_status (*f) (const char *, struct __netgrent *);
 124     void *ptr;
 125   } fct;
 126   enum nss_status status = NSS_STATUS_UNAVAIL;
 127   struct name_list *new_elem;
 128
 129   /* Free data from previous service.  */
 130   endnetgrent_hook (datap);
 131
 132   /* Cycle through all the services and run their setnetgrent functions.  */
 133   int no_more = setup (&fct.ptr, &datap->nip);
 134   while (! no_more)
 135     {
 136       assert (datap->data == NULL);
 137
 138       /* Ignore status, we force check in `__nss_next2'.  */
 139       status = DL_CALL_FCT (*fct.f, (group, datap));
 140
 141       service_user *old_nip = datap->nip;
 142       no_more = __nss_next2 (&datap->nip, "setnetgrent", NULL, &fct.ptr,
 143                              status, 0);
 144
 145       if (status == NSS_STATUS_SUCCESS && ! no_more)
 146         {
 147           enum nss_status (*endfct) (struct __netgrent *);
 148
 149           endfct = __nss_lookup_function (old_nip, "endnetgrent");
 150           if (endfct != NULL)
 151             (void) DL_CALL_FCT (*endfct, (datap));
 152         }
 153     }
 154
 155   /* Add the current group to the list of known groups.  */
 156   size_t group_len = strlen (group) + 1;
 157   new_elem = (struct name_list *) malloc (sizeof (struct name_list)
 158                                           + group_len);
 159   if (new_elem == NULL)
 160     {
 161       *errnop = errno;
 162       status = NSS_STATUS_TRYAGAIN;
 163     }
 164   else
 165     {
 166       new_elem->next = datap->known_groups;
 167       memcpy (new_elem->name, group, group_len);
 168       datap->known_groups = new_elem;
 169     }
 170
 171   return status == NSS_STATUS_SUCCESS;
 172 }
 173
 174 int
 175 internal_function
 176 __internal_setnetgrent (const char *group, struct __netgrent *datap)
 177 {
 178   /* Free list of all netgroup names from last run.  */
 179   free_memory (datap);
 180
 181   return __internal_setnetgrent_reuse (group, datap, &errno);
 182 }
 183 libc_hidden_def (__internal_setnetgrent)
 184
 185 static int
 186 nscd_setnetgrent (const char *group)
 187 {
 188 #ifdef USE_NSCD
 189   if (__nss_not_use_nscd_netgroup > 0
 190       && ++__nss_not_use_nscd_netgroup > NSS_NSCD_RETRY)
 191     __nss_not_use_nscd_netgroup = 0;
 192
 193   if (!__nss_not_use_nscd_netgroup
 194       && !__nss_database_custom[NSS_DBSIDX_netgroup])
 195     return __nscd_setnetgrent (group, &dataset);
 196 #endif
 197   return -1;
 198 }
 199
 200 int
 201 setnetgrent (const char *group)
 202 {
 203   int result;
 204
 205   __libc_lock_lock (lock);
 206
 207   result = nscd_setnetgrent (group);
 208   if (result < 0)
 209     result = __internal_setnetgrent (group, &dataset);
 210
 211   __libc_lock_unlock (lock);
 212
 213   return result;
 214 }
 215
 216 void
 217 internal_function
 218 __internal_endnetgrent (struct __netgrent *datap)
 219 {
 220   endnetgrent_hook (datap);
 221   /* Now free list of all netgroup names from last run.  */
 222   free_memory (datap);
 223 }
 224 libc_hidden_def (__internal_endnetgrent)
 225
 226
 227 void
 228 endnetgrent (void)
 229 {
 230   __libc_lock_lock (lock);
 231
 232   __internal_endnetgrent (&dataset);
 233
 234   __libc_lock_unlock (lock);
 235 }
 236
 237 #ifdef USE_NSCD
 238 static const char *
 239 get_nonempty_val (const char *in)
 240 {
 241   if (*in == '\0')
 242     return NULL;
 243   return in;
 244 }
 245
 246 static enum nss_status
 247 nscd_getnetgrent (struct __netgrent *datap, char *buffer, size_t buflen,
 248                   int *errnop)
 249 {
 250   if (datap->cursor >= datap->data + datap->data_size)
 251     return NSS_STATUS_UNAVAIL;
 252
 253   datap->type = triple_val;
 254   datap->val.triple.host = get_nonempty_val (datap->cursor);
 255   datap->cursor = (char *) __rawmemchr (datap->cursor, '\0') + 1;
 256   datap->val.triple.user = get_nonempty_val (datap->cursor);
 257   datap->cursor = (char *) __rawmemchr (datap->cursor, '\0') + 1;
 258   datap->val.triple.domain = get_nonempty_val (datap->cursor);
 259   datap->cursor = (char *) __rawmemchr (datap->cursor, '\0') + 1;
 260
 261   return NSS_STATUS_SUCCESS;
 262 }
 263 #endif
 264
 265 int
 266 internal_function
 267 __internal_getnetgrent_r (char **hostp, char **userp, char **domainp,
 268                           struct __netgrent *datap,
 269                           char *buffer, size_t buflen, int *errnop)
 270 {
 271   enum nss_status (*fct) (struct __netgrent *, char *, size_t, int *);
 272
 273   /* Initialize status to return if no more functions are found.  */
 274   enum nss_status status = NSS_STATUS_NOTFOUND;
 275
 276   /* Run through available functions, starting with the same function last
 277      run.  We will repeat each function as long as it succeeds, and then go
 278      on to the next service action.  */
 279   int no_more = datap->nip == NULL;
 280   if (! no_more)
 281     {
 282 #ifdef USE_NSCD
 283       /* This bogus function pointer is a special marker left by
 284          __nscd_setnetgrent to tell us to use the data it left
 285          before considering any modules.  */
 286       if (datap->nip == (service_user *) -1l)
 287         fct = nscd_getnetgrent;
 288       else
 289 #endif
 290         {
 291           fct = __nss_lookup_function (datap->nip, "getnetgrent_r");
 292           no_more = fct == NULL;
 293         }
 294     }
 295
 296   while (! no_more)
 297     {
 298       status = DL_CALL_FCT (*fct, (datap, buffer, buflen, &errno));
 299
 300       if (status == NSS_STATUS_RETURN)
 301         {
 302           /* This was the last one for this group.  Look at next group
 303              if available.  */
 304           int found = 0;
 305           while (datap->needed_groups != NULL && ! found)
 306             {
 307               struct name_list *tmp = datap->needed_groups;
 308               datap->needed_groups = datap->needed_groups->next;
 309               tmp->next = datap->known_groups;
 310               datap->known_groups = tmp;
 311
 312               found = __internal_setnetgrent_reuse (datap->known_groups->name,
 313                                                     datap, errnop);
 314             }
 315
 316           if (found && datap->nip != NULL)
 317             {
 318               fct = __nss_lookup_function (datap->nip, "getnetgrent_r");
 319               if (fct != NULL)
 320                 continue;
 321             }
 322         }
 323       else if (status == NSS_STATUS_SUCCESS && datap->type == group_val)
 324         {
 325           /* The last entry was a name of another netgroup.  */
 326           struct name_list *namep;
 327
 328           /* Ignore if we've seen the name before.  */
 329           for (namep = datap->known_groups; namep != NULL;
 330                namep = namep->next)
 331             if (strcmp (datap->val.group, namep->name) == 0)
 332               break;
 333           if (namep == NULL)
 334             for (namep = datap->needed_groups; namep != NULL;
 335                  namep = namep->next)
 336               if (strcmp (datap->val.group, namep->name) == 0)
 337                 break;
 338           if (namep != NULL)
 339             /* Really ignore.  */
 340             continue;
 341
 342           size_t group_len = strlen (datap->val.group) + 1;
 343           namep = (struct name_list *) malloc (sizeof (struct name_list)
 344                                                + group_len);
 345           if (namep == NULL)
 346             /* We are out of memory.  */
 347             status = NSS_STATUS_RETURN;
 348           else
 349             {
 350               namep->next = datap->needed_groups;
 351               memcpy (namep->name, datap->val.group, group_len);
 352               datap->needed_groups = namep;
 353               /* And get the next entry.  */
 354               continue;
 355             }
 356         }
 357
 358       break;
 359     }
 360
 361   if (status == NSS_STATUS_SUCCESS)
 362     {
 363       *hostp = (char *) datap->val.triple.host;
 364       *userp = (char *) datap->val.triple.user;
 365       *domainp = (char *) datap->val.triple.domain;
 366     }
 367
 368   return status == NSS_STATUS_SUCCESS ? 1 : 0;
 369 }
 370 libc_hidden_def (__internal_getnetgrent_r)
 371
 372 /* The real entry point.  */
 373 int
 374 __getnetgrent_r (char **hostp, char **userp, char **domainp,
 375                  char *buffer, size_t buflen)
 376 {
 377   enum nss_status status;
 378
 379   __libc_lock_lock (lock);
 380
 381   status = __internal_getnetgrent_r (hostp, userp, domainp, &dataset,
 382                                      buffer, buflen, &errno);
 383
 384   __libc_lock_unlock (lock);
 385
 386   return status;
 387 }
 388 weak_alias (__getnetgrent_r, getnetgrent_r)
 389 \f
 390 /* Test whether given (host,user,domain) triple is in NETGROUP.  */
 391 int
 392 innetgr (const char *netgroup, const char *host, const char *user,
 393          const char *domain)
 394 {
 395 #ifdef USE_NSCD
 396   if (__nss_not_use_nscd_netgroup > 0
 397       && ++__nss_not_use_nscd_netgroup > NSS_NSCD_RETRY)
 398     __nss_not_use_nscd_netgroup = 0;
 399
 400   if (!__nss_not_use_nscd_netgroup
 401       && !__nss_database_custom[NSS_DBSIDX_netgroup])
 402     {
 403       int result = __nscd_innetgr (netgroup, host, user, domain);
 404       if (result >= 0)
 405         return result;
 406     }
 407 #endif
 408
 409   union
 410   {
 411     enum nss_status (*f) (const char *, struct __netgrent *);
 412     void *ptr;
 413   } setfct;
 414   void (*endfct) (struct __netgrent *);
 415   int (*getfct) (struct __netgrent *, char *, size_t, int *);
 416   struct __netgrent entry;
 417   int result = 0;
 418   const char *current_group = netgroup;
 419
 420   memset (&entry, '\0', sizeof (entry));
 421
 422   /* Walk through the services until we found an answer or we shall
 423      not work further.  We can do some optimization here.  Since all
 424      services must provide the `setnetgrent' function we can do all
 425      the work during one walk through the service list.  */
 426   while (1)
 427     {
 428       int no_more = setup (&setfct.ptr, &entry.nip);
 429       while (! no_more)
 430         {
 431           assert (entry.data == NULL);
 432
 433           /* Open netgroup.  */
 434           enum nss_status status = DL_CALL_FCT (*setfct.f,
 435                                                 (current_group, &entry));
 436
 437           if (status == NSS_STATUS_SUCCESS
 438               && (getfct = __nss_lookup_function (entry.nip, "getnetgrent_r"))
 439                  != NULL)
 440             {
 441               char buffer[1024];
 442
 443               while (DL_CALL_FCT (*getfct,
 444                                   (&entry, buffer, sizeof buffer, &errno))
 445                      == NSS_STATUS_SUCCESS)
 446                 {
 447                   if (entry.type == group_val)
 448                     {
 449                       /* Make sure we haven't seen the name before.  */
 450                       struct name_list *namep;
 451
 452                       for (namep = entry.known_groups; namep != NULL;
 453                            namep = namep->next)
 454                         if (strcmp (entry.val.group, namep->name) == 0)
 455                           break;
 456                       if (namep == NULL)
 457                         for (namep = entry.needed_groups; namep != NULL;
 458                              namep = namep->next)
 459                           if (strcmp (entry.val.group, namep->name) == 0)
 460                             break;
 461                       if (namep == NULL
 462                           && strcmp (netgroup, entry.val.group) != 0)
 463                         {
 464                           size_t group_len = strlen (entry.val.group) + 1;
 465                           namep =
 466                             (struct name_list *) malloc (sizeof (*namep)
 467                                                          + group_len);
 468                           if (namep == NULL)
 469                             {
 470                               /* Out of memory, simply return.  */
 471                               result = -1;
 472                               break;
 473                             }
 474
 475                           namep->next = entry.needed_groups;
 476                           memcpy (namep->name, entry.val.group, group_len);
 477                           entry.needed_groups = namep;
 478                         }
 479                     }
 480                   else
 481                     {
 482                       if ((entry.val.triple.host == NULL || host == NULL
 483                            || __strcasecmp (entry.val.triple.host, host) == 0)
 484                           && (entry.val.triple.user == NULL || user == NULL
 485                               || strcmp (entry.val.triple.user, user) == 0)
 486                           && (entry.val.triple.domain == NULL || domain == NULL
 487                               || __strcasecmp (entry.val.triple.domain,
 488                                                domain) == 0))
 489                         {
 490                           result = 1;
 491                           break;
 492                         }
 493                     }
 494                 }
 495
 496               /* If we found one service which does know the given
 497                  netgroup we don't try further.  */
 498               status = NSS_STATUS_RETURN;
 499             }
 500
 501           /* Free all resources of the service.  */
 502           endfct = __nss_lookup_function (entry.nip, "endnetgrent");
 503           if (endfct != NULL)
 504             DL_CALL_FCT (*endfct, (&entry));
 505
 506           if (result != 0)
 507             break;
 508
 509           /* Look for the next service.  */
 510           no_more = __nss_next2 (&entry.nip, "setnetgrent", NULL,
 511                                  &setfct.ptr, status, 0);
 512         }
 513
 514       if (result == 0 && entry.needed_groups != NULL)
 515         {
 516           struct name_list *tmp = entry.needed_groups;
 517           entry.needed_groups = tmp->next;
 518           tmp->next = entry.known_groups;
 519           entry.known_groups = tmp;
 520           current_group = tmp->name;
 521           continue;
 522         }
 523
 524       /* No way out.  */
 525       break;
 526     }
 527
 528   /* Free the memory.  */
 529   free_memory (&entry);
 530
 531   return result == 1;
 532 }
 533 libc_hidden_def (innetgr)