Back to index

glibc  2.9
Functions
getnetgrent_r.c File Reference
#include <assert.h>
#include <atomic.h>
#include <bits/libc-lock.h>
#include <errno.h>
#include <netdb.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "netgroup.h"
#include "nsswitch.h"
#include <sysdep.h>

Go to the source code of this file.

Functions

 __libc_lock_define_initialized (static, lock)
static void free_memory (struct __netgrent *data)
static void endnetgrent_hook (struct __netgrent *datap)
static int internal_function __internal_setnetgrent_reuse (const char *group, struct __netgrent *datap, int *errnop)
int internal_setnetgrent (const char *group, struct __netgrent *datap)
 libc_hidden_proto (internal_setnetgrent)
 libc_hidden_def (strong_alias(internal_setnetgrent)
void internal_endnetgrent (struct __netgrent *datap)
 libc_hidden_proto (internal_endnetgrent)
int internal_getnetgrent_r (char **hostp, char **userp, char **domainp, struct __netgrent *datap, char *buffer, size_t buflen, int *errnop)
 libc_hidden_proto (internal_getnetgrent_r)
 weak_alias (__getnetgrent_r, getnetgrent_r)

Function Documentation

static int internal_function __internal_setnetgrent_reuse ( const char *  group,
struct __netgrent datap,
int errnop 
) [static]

Definition at line 115 of file getnetgrent_r.c.

{
  union
  {
    enum nss_status (*f) (const char *, struct __netgrent *);
    void *ptr;
  } fct;
  enum nss_status status = NSS_STATUS_UNAVAIL;
  struct name_list *new_elem;

  /* Free data from previous service.  */
  endnetgrent_hook (datap);

  /* Cycle through all the services and run their setnetgrent functions.  */
  int no_more = setup (&fct.ptr, &datap->nip);
  while (! no_more)
    {
      assert (datap->data == NULL);

      /* Ignore status, we force check in `__nss_next2'.  */
      status = (*fct.f) (group, datap);

      service_user *old_nip = datap->nip;
      no_more = __nss_next2 (&datap->nip, "setnetgrent", NULL, &fct.ptr,
                          status, 0);

      if (status == NSS_STATUS_SUCCESS && ! no_more)
       {
         enum nss_status (*endfct) (struct __netgrent *);

         endfct = __nss_lookup_function (old_nip, "endnetgrent");
         if (endfct != NULL)
           (void) (*endfct) (datap);
       }
    }

  /* Add the current group to the list of known groups.  */
  size_t group_len = strlen (group) + 1;
  new_elem = (struct name_list *) malloc (sizeof (struct name_list)
                                     + group_len);
  if (new_elem == NULL)
    {
      *errnop = errno;
      status = NSS_STATUS_TRYAGAIN;
    }
  else
    {
      new_elem->next = datap->known_groups;
      memcpy (new_elem->name, group, group_len);
      datap->known_groups = new_elem;
    }

  return status == NSS_STATUS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

__libc_lock_define_initialized ( static  ,
lock   
)

Definition at line 34 of file getnetgrent_r.c.

{
  /* Remember the first service_entry, it's always the same.  */
  static bool startp_initialized;
  static service_user *startp;
  int no_more;

  if (!startp_initialized)
    {
      /* Executing this more than once at the same time must yield the
        same result every time.  So we need no locking.  */
      no_more = __nss_netgroup_lookup (nipp, "setnetgrent", fctp);
      startp = no_more ? (service_user *) -1 : *nipp;
      PTR_MANGLE (startp);
      atomic_write_barrier ();
      startp_initialized = true;
    }
  else
    {
      service_user *nip = startp;
      PTR_DEMANGLE (nip);
      if (nip == (service_user *) -1)
       /* No services at all.  */
       return 1;

      /* Reset to the beginning of the service list.  */
      *nipp = nip;
      /* Look up the first function.  */
      no_more = __nss_lookup (nipp, "setnetgrent", NULL, fctp);
    }
  return no_more;
}
static void endnetgrent_hook ( struct __netgrent datap) [static]

Definition at line 100 of file getnetgrent_r.c.

{
  enum nss_status (*endfct) (struct __netgrent *);

  if (datap->nip == NULL)
    return;

  endfct = __nss_lookup_function (datap->nip, "endnetgrent");
  if (endfct != NULL)
    (void) (*endfct) (datap);
  datap->nip = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void free_memory ( struct __netgrent data) [static]

Definition at line 82 of file getnetgrent_r.c.

{
  while (data->known_groups != NULL)
    {
      struct name_list *tmp = data->known_groups;
      data->known_groups = data->known_groups->next;
      free (tmp);
    }

  while (data->needed_groups != NULL)
    {
      struct name_list *tmp = data->needed_groups;
      data->needed_groups = data->needed_groups->next;
      free (tmp);
    }
}

Here is the caller graph for this function:

void internal_endnetgrent ( struct __netgrent datap)

Here is the caller graph for this function:

int internal_getnetgrent_r ( char **  hostp,
char **  userp,
char **  domainp,
struct __netgrent datap,
char *  buffer,
size_t  buflen,
int errnop 
)
int internal_setnetgrent ( const char *  group,
struct __netgrent datap 
)

Here is the caller graph for this function:

libc_hidden_def ( strong_alias internal_setnetgrent)

Definition at line 182 of file getnetgrent_r.c.

{
  int result;

  __libc_lock_lock (lock);

  result = internal_setnetgrent (group, &dataset);

  __libc_lock_unlock (lock);

  return result;
}

Here is the call graph for this function:

Definition at line 172 of file getnetgrent_r.c.

{
  /* Free list of all netgroup names from last run.  */
  free_memory (datap);

  return __internal_setnetgrent_reuse (group, datap, &errno);
}

Here is the call graph for this function:

Definition at line 200 of file getnetgrent_r.c.

{
  endnetgrent_hook (datap);
  /* Now free list of all netgroup names from last run.  */
  free_memory (datap);
}

Here is the call graph for this function:

Definition at line 227 of file getnetgrent_r.c.

{
  enum nss_status (*fct) (struct __netgrent *, char *, size_t, int *);

  /* Initialize status to return if no more functions are found.  */
  enum nss_status status = NSS_STATUS_NOTFOUND;

  /* Run through available functions, starting with the same function last
     run.  We will repeat each function as long as it succeeds, and then go
     on to the next service action.  */
  int no_more = (datap->nip == NULL
               || (fct = __nss_lookup_function (datap->nip, "getnetgrent_r"))
                  == NULL);
  while (! no_more)
    {
      status = (*fct) (datap, buffer, buflen, &errno);

      if (status == NSS_STATUS_RETURN)
       {
         /* This was the last one for this group.  Look at next group
            if available.  */
         int found = 0;
         while (datap->needed_groups != NULL && ! found)
           {
             struct name_list *tmp = datap->needed_groups;
             datap->needed_groups = datap->needed_groups->next;
             tmp->next = datap->known_groups;
             datap->known_groups = tmp;

             found = __internal_setnetgrent_reuse (datap->known_groups->name,
                                              datap, errnop);
           }

         if (found && datap->nip != NULL)
           {
             fct = __nss_lookup_function (datap->nip, "getnetgrent_r");
             if (fct != NULL)
              continue;
           }
       }
      else if (status == NSS_STATUS_SUCCESS && datap->type == group_val)
       {
         /* The last entry was a name of another netgroup.  */
         struct name_list *namep;

         /* Ignore if we've seen the name before.  */
         for (namep = datap->known_groups; namep != NULL;
              namep = namep->next)
           if (strcmp (datap->val.group, namep->name) == 0)
             break;
         if (namep != NULL)
           /* Really ignore.  */
           continue;

         size_t group_len = strlen (datap->val.group) + 1;
         namep = (struct name_list *) malloc (sizeof (struct name_list)
                                          + group_len);
         if (namep == NULL)
           /* We are out of memory.  */
           status = NSS_STATUS_RETURN;
         else
           {
             namep->next = datap->needed_groups;
             memcpy (namep->name, datap->val.group, group_len);
             datap->needed_groups = namep;
             /* And get the next entry.  */
             continue;
           }
       }

      break;
    }

  if (status == NSS_STATUS_SUCCESS)
    {
      *hostp = (char *) datap->val.triple.host;
      *userp = (char *) datap->val.triple.user;
      *domainp = (char *) datap->val.triple.domain;
    }

  return status == NSS_STATUS_SUCCESS ? 1 : 0;
}

Here is the call graph for this function:

weak_alias ( __getnetgrent_r  ,
getnetgrent_r   
)

Definition at line 333 of file getnetgrent_r.c.

{
  union
  {
    int (*f) (const char *, struct __netgrent *);
    void *ptr;
  } setfct;
  void (*endfct) (struct __netgrent *);
  int (*getfct) (struct __netgrent *, char *, size_t, int *);
  struct __netgrent entry;
  int result = 0;
  const char *current_group = netgroup;
  int real_entry = 0;

  memset (&entry, '\0', sizeof (entry));

  /* Walk through the services until we found an answer or we shall
     not work further.  We can do some optimization here.  Since all
     services must provide the `setnetgrent' function we can do all
     the work during one walk through the service list.  */
  while (1)
    {
      int no_more = setup (&setfct.ptr, &entry.nip);
      while (! no_more)
       {
         assert (entry.data == NULL);

         /* Open netgroup.  */
         enum nss_status status = (*setfct.f) (current_group, &entry);

         if (status == NSS_STATUS_SUCCESS
             && (getfct = __nss_lookup_function (entry.nip, "getnetgrent_r"))
               != NULL)
           {
             char buffer[1024];

             while ((*getfct) (&entry, buffer, sizeof buffer, &errno)
                   == NSS_STATUS_SUCCESS)
              {
                if (entry.type == group_val)
                  {
                    /* Make sure we haven't seen the name before.  */
                    struct name_list *namep;

                    for (namep = entry.known_groups; namep != NULL;
                        namep = namep->next)
                     if (strcmp (entry.val.group, namep->name) == 0)
                       break;
                    if (namep == NULL
                       && strcmp (netgroup, entry.val.group) != 0)
                     {
                       size_t group_len = strlen (entry.val.group) + 1;
                       namep =
                         (struct name_list *) malloc (sizeof (*namep)
                                                  + group_len);
                       if (namep == NULL)
                         {
                           /* Out of memory, simply return.  */
                           result = -1;
                           break;
                         }

                       namep->next = entry.needed_groups;
                       memcpy (namep->name, entry.val.group, group_len);
                       entry.needed_groups = namep;
                     }
                  }
                else
                  {
                    real_entry = 1;

                    if ((entry.val.triple.host == NULL || host == NULL
                        || __strcasecmp (entry.val.triple.host, host) == 0)
                       && (entry.val.triple.user == NULL || user == NULL
                           || strcmp (entry.val.triple.user, user) == 0)
                       && (entry.val.triple.domain == NULL || domain == NULL
                           || __strcasecmp (entry.val.triple.domain,
                                          domain) == 0))
                     {
                       result = 1;
                       break;
                     }
                  }
              }

             /* If we found one service which does know the given
               netgroup we don't try further.  */
             status = NSS_STATUS_RETURN;
           }

         /* Free all resources of the service.  */
         endfct = __nss_lookup_function (entry.nip, "endnetgrent");
         if (endfct != NULL)
           (*endfct) (&entry);

         if (result != 0)
           break;

         /* Look for the next service.  */
         no_more = __nss_next2 (&entry.nip, "setnetgrent", NULL,
                             &setfct.ptr, status, 0);
       }

      if (result == 0 && entry.needed_groups != NULL)
       {
         struct name_list *tmp = entry.needed_groups;
         entry.needed_groups = tmp->next;
         tmp->next = entry.known_groups;
         entry.known_groups = tmp;
         current_group = entry.known_groups->name;
         continue;
       }

      /* No way out.  */
      break;
    }

  /* Free the memory.  */
  free_memory (&entry);

  return result == 1;
}

Here is the call graph for this function: