2006-01-31 Roland McGrath <roland@redhat.com>
[kopensolaris-gnu/glibc.git] / inet / getnetgrent_r.c
index 83e4c9e..97b2b80 100644 (file)
@@ -1,21 +1,23 @@
-/* Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1996, 1997, 1998, 1999, 2002, 2004, 2005
+   Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
 
    The GNU C Library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
+   Lesser General Public License for more details.
 
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
 
+#include <assert.h>
 #include <bits/libc-lock.h>
 #include <errno.h>
 #include <netdb.h>
 /* Protect above variable against multiple uses at the same time.  */
 __libc_lock_define_initialized (static, lock)
 
-/* This handle for the NSS data base is shared between all
-   set/get/endXXXent functions.  */
-static service_user *nip;
-
 /* The whole information for the set/get/endnetgrent functions are
    kept in this structure.  */
 static struct __netgrent dataset;
 
 /* The lookup function for the first entry of this service.  */
-extern int __nss_netgroup_lookup (service_user **nip, const char *name,
-                                 void **fctp);
-
+extern int __nss_netgroup_lookup (service_user **nipp, const char *name,
+                                 void **fctp) internal_function;
 
-/* Set up NIP to run through the services.  If ALL is zero, use NIP's
-   current location if it's not nil.  Return nonzero if there are no
+/* Set up NIP to run through the services.  Return nonzero if there are no
    services (left).  */
-static enum nss_status
-setup (void **fctp, const char *func_name, int all)
+static int
+setup (void **fctp, service_user **nipp)
 {
   /* Remember the first service_entry, it's always the same.  */
-  static service_user *startp = NULL;
+  static service_user *startp;
   int no_more;
 
   if (startp == NULL)
     {
-      no_more = __nss_netgroup_lookup (&nip, func_name, fctp);
-      startp = no_more ? (service_user *) -1 : nip;
+      /* 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;
     }
   else if (startp == (service_user *) -1)
     /* No services at all.  */
     return 1;
   else
     {
-      if (all || !nip)
-       /* Reset to the beginning of the service list.  */
-       nip = startp;
+      /* Reset to the beginning of the service list.  */
+      *nipp = startp;
       /* Look up the first function.  */
-      no_more = __nss_lookup (&nip, func_name, fctp);
+      no_more = __nss_lookup (nipp, "setnetgrent", fctp);
     }
   return no_more;
 }
@@ -78,7 +75,6 @@ free_memory (struct __netgrent *data)
     {
       struct name_list *tmp = data->known_groups;
       data->known_groups = data->known_groups->next;
-      free ((void *) tmp->name);
       free (tmp);
     }
 
@@ -86,57 +82,94 @@ free_memory (struct __netgrent *data)
     {
       struct name_list *tmp = data->needed_groups;
       data->needed_groups = data->needed_groups->next;
-      free ((void *) tmp->name);
       free (tmp);
     }
 }
 \f
+static void
+endnetgrent_hook (struct __netgrent *datap)
+{
+  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;
+}
+
 static int
 internal_function
 __internal_setnetgrent_reuse (const char *group, struct __netgrent *datap,
                              int *errnop)
 {
-  enum nss_status (*fct) (const char *, struct __netgrent *);
+  union
+  {
+    enum nss_status (*f) (const char *, struct __netgrent *);
+    void *ptr;
+  } fct;
   enum nss_status status = NSS_STATUS_UNAVAIL;
   struct name_list *new_elem;
-  int no_more;
+
+  /* Free data from previous service.  */
+  endnetgrent_hook (datap);
 
   /* Cycle through all the services and run their setnetgrent functions.  */
-  no_more = setup ((void **) &fct, "setnetgrent", 1);
+  int no_more = setup (&fct.ptr, &datap->nip);
   while (! no_more)
     {
+      assert (datap->data == NULL);
+
       /* Ignore status, we force check in `__nss_next'.  */
-      status = (*fct) (group, datap);
+      status = (*fct.f) (group, datap);
 
-      no_more = __nss_next (&nip, "setnetgrent", (void **) &fct, status, 0);
+      service_user *old_nip = datap->nip;
+      no_more = __nss_next (&datap->nip, "setnetgrent", &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.  */
-  new_elem = (struct name_list *) malloc (sizeof (struct name_list));
-  if (new_elem == NULL || (new_elem->name = __strdup (group)) == NULL)
+  size_t group_len = strlen (group) + 1;
+  new_elem = (struct name_list *) malloc (sizeof (struct name_list)
+                                         + group_len);
+  if (new_elem == NULL)
     {
-      if (new_elem != NULL)
-       free (new_elem);
       *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;
 }
 
+int internal_setnetgrent (const char *group, struct __netgrent *datap);
+libc_hidden_proto (internal_setnetgrent)
+
 int
-__internal_setnetgrent (const char *group, struct __netgrent *datap)
+internal_setnetgrent (const char *group, struct __netgrent *datap)
 {
   /* Free list of all netgroup names from last run.  */
   free_memory (datap);
 
-  return __internal_setnetgrent_reuse (group, datap, __errno_location ());
+  return __internal_setnetgrent_reuse (group, datap, &errno);
 }
+libc_hidden_def (internal_setnetgrent)
+strong_alias (internal_setnetgrent, __internal_setnetgrent)
 
 int
 setnetgrent (const char *group)
@@ -145,38 +178,25 @@ setnetgrent (const char *group)
 
   __libc_lock_lock (lock);
 
-  result = __internal_setnetgrent (group, &dataset);
+  result = internal_setnetgrent (group, &dataset);
 
   __libc_lock_unlock (lock);
 
   return result;
 }
 
+void internal_endnetgrent (struct __netgrent *datap);
+libc_hidden_proto (internal_endnetgrent)
 
 void
-__internal_endnetgrent (struct __netgrent *datap)
+internal_endnetgrent (struct __netgrent *datap)
 {
-  service_user *old_nip;
-  enum nss_status (*fct) (struct __netgrent *);
-  int no_more;
-
-  /* Remember which was the last used service.  */
-  old_nip = nip;
-
-  /* Cycle through all the services and run their endnetgrent functions.  */
-  no_more = setup ((void **) &fct, "endnetgrent", 1);
-  while (! no_more)
-    {
-      /* Ignore status, we force check in `__nss_next'.  */
-      (void) (*fct) (datap);
-
-      no_more = (nip == old_nip
-                || __nss_next (&nip, "endnetgrent", (void **) &fct, 0, 1));
-    }
-
+  endnetgrent_hook (datap);
   /* Now free list of all netgroup names from last run.  */
   free_memory (datap);
 }
+libc_hidden_def (internal_endnetgrent)
+strong_alias (internal_endnetgrent, __internal_endnetgrent)
 
 
 void
@@ -184,19 +204,23 @@ endnetgrent (void)
 {
   __libc_lock_lock (lock);
 
-  __internal_endnetgrent (&dataset);
+  internal_endnetgrent (&dataset);
 
   __libc_lock_unlock (lock);
 }
 
 
+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)
+
 int
-__internal_getnetgrent_r (char **hostp, char **userp, char **domainp,
+internal_getnetgrent_r (char **hostp, char **userp, char **domainp,
                          struct __netgrent *datap,
                          char *buffer, size_t buflen, int *errnop)
 {
-  enum nss_status (*fct) (struct __netgrent *, char *, size_t);
-  int no_more;
+  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;
@@ -204,10 +228,12 @@ __internal_getnetgrent_r (char **hostp, char **userp, char **domainp,
   /* 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.  */
-  no_more = setup ((void **) &fct, "getnetgrent_r", 0);
+  int no_more = (datap->nip == NULL
+                || (fct = __nss_lookup_function (datap->nip, "getnetgrent_r"))
+                   == NULL);
   while (! no_more)
     {
-      status = (*fct) (datap, buffer, buflen);
+      status = (*fct) (datap, buffer, buflen, &errno);
 
       if (status == NSS_STATUS_RETURN)
        {
@@ -225,8 +251,12 @@ __internal_getnetgrent_r (char **hostp, char **userp, char **domainp,
                                                    datap, errnop);
            }
 
-         if (found)
-           continue;
+         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)
        {
@@ -242,25 +272,23 @@ __internal_getnetgrent_r (char **hostp, char **userp, char **domainp,
            /* Really ignore.  */
            continue;
 
-         namep = (struct name_list *) malloc (sizeof (struct name_list));
-         if (namep == NULL
-             || (namep->name = __strdup (datap->val.group)) == NULL)
-           {
-             /* We are out of memory.  */
-             if (namep != NULL)
-               free (namep);
-             status = NSS_STATUS_RETURN;
-           }
+         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;
            }
        }
 
-      no_more = __nss_next (&nip, "getnetgrent_r", (void **) &fct, status, 0);
+      break;
     }
 
   if (status == NSS_STATUS_SUCCESS)
@@ -272,6 +300,8 @@ __internal_getnetgrent_r (char **hostp, char **userp, char **domainp,
 
   return status == NSS_STATUS_SUCCESS ? 1 : 0;
 }
+libc_hidden_def (internal_getnetgrent_r)
+strong_alias (internal_getnetgrent_r, __internal_getnetgrent_r)
 
 /* The real entry point.  */
 int
@@ -282,8 +312,8 @@ __getnetgrent_r (char **hostp, char **userp, char **domainp,
 
   __libc_lock_lock (lock);
 
-  status = __internal_getnetgrent_r (hostp, userp, domainp, &dataset,
-                                    buffer, buflen, __errno_location ());
+  status = internal_getnetgrent_r (hostp, userp, domainp, &dataset,
+                                  buffer, buflen, &errno);
 
   __libc_lock_unlock (lock);
 
@@ -296,39 +326,41 @@ int
 innetgr (const char *netgroup, const char *host, const char *user,
         const char *domain)
 {
-  int (*setfct) (const char *, struct __netgrent *);
+  union
+  {
+    int (*f) (const char *, struct __netgrent *);
+    void *ptr;
+  } setfct;
   void (*endfct) (struct __netgrent *);
-  int (*getfct) (struct __netgrent *, char *, size_t);
-  struct name_list *known = NULL;
-  struct name_list *needed = NULL;
+  int (*getfct) (struct __netgrent *, char *, size_t, int *);
+  struct __netgrent entry;
   int result = 0;
-  int no_more;
   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)
     {
-      no_more = setup ((void **) &setfct, "setnetgrent", 1);
+      int no_more = setup (&setfct.ptr, &entry.nip);
       while (! no_more)
        {
-         enum nss_status status;
-         struct __netgrent entry;
-
-         /* Clear the space for the netgroup data.  */
-         bzero (&entry, sizeof (entry));
+         assert (entry.data == NULL);
 
          /* Open netgroup.  */
-         status = (*setfct) (current_group, &entry);
+         enum nss_status status = (*setfct.f) (current_group, &entry);
+
          if (status == NSS_STATUS_SUCCESS
-             && __nss_lookup (&nip, "getnetgrent_r", (void **) &getfct) == 0)
+             && (getfct = __nss_lookup_function (entry.nip, "getnetgrent_r"))
+                != NULL)
            {
              char buffer[1024];
 
-             while ((*getfct) (&entry, buffer, sizeof buffer)
+             while ((*getfct) (&entry, buffer, sizeof buffer, &errno)
                     == NSS_STATUS_SUCCESS)
                {
                  if (entry.type == group_val)
@@ -336,27 +368,27 @@ innetgr (const char *netgroup, const char *host, const char *user,
                      /* Make sure we haven't seen the name before.  */
                      struct name_list *namep;
 
-                     for (namep = known; namep != NULL; namep = namep->next)
+                     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));
-                         if (namep == NULL
-                             || ((namep->name = __strdup (entry.val.group))
-                                 == NULL))
+                           (struct name_list *) malloc (sizeof (*namep)
+                                                        + group_len);
+                         if (namep == NULL)
                            {
                              /* Out of memory, simply return.  */
-                             if (namep != NULL)
-                               free (namep);
                              result = -1;
                              break;
                            }
 
-                         namep->next = needed;
-                         needed = namep;
+                         namep->next = entry.needed_groups;
+                         memcpy (namep->name, entry.val.group, group_len);
+                         entry.needed_groups = namep;
                        }
                    }
                  else
@@ -364,11 +396,12 @@ innetgr (const char *netgroup, const char *host, const char *user,
                      real_entry = 1;
 
                      if ((entry.val.triple.host == NULL || host == NULL
-                          || strcmp (entry.val.triple.host, host) == 0)
+                          || __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
-                             || strcmp (entry.val.triple.domain, domain) == 0))
+                             || __strcasecmp (entry.val.triple.domain,
+                                              domain) == 0))
                        {
                          result = 1;
                          break;
@@ -376,30 +409,31 @@ innetgr (const char *netgroup, const char *host, const char *user,
                    }
                }
 
-             if (result != 0)
-               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.  */
-         if (__nss_lookup (&nip, "endnetgrent", (void **) &endfct) == 0)
+         endfct = __nss_lookup_function (entry.nip, "endnetgrent");
+         if (endfct != NULL)
            (*endfct) (&entry);
 
+         if (result != 0)
+           break;
+
          /* Look for the next service.  */
-         no_more = __nss_next (&nip, "setnetgrent",
-                               (void **) &setfct, status, 0);
+         no_more = __nss_next (&entry.nip, "setnetgrent",
+                               &setfct.ptr, status, 0);
        }
 
-      if (result == 0 && needed != NULL)
+      if (result == 0 && entry.needed_groups != NULL)
        {
-         struct name_list *tmp = needed;
-         needed = tmp->next;
-         tmp->next = known;
-         known = tmp;
-         current_group = known->name;
+         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;
        }
 
@@ -408,20 +442,8 @@ innetgr (const char *netgroup, const char *host, const char *user,
     }
 
   /* Free the memory.  */
-  while (known != NULL)
-    {
-      struct name_list *tmp = known;
-      known = known->next;
-      free ((void *) tmp->name);
-      free (tmp);
-    }
-  while (needed != NULL)
-    {
-      struct name_list *tmp = needed;
-      needed = needed->next;
-      free ((void *) tmp->name);
-      free (tmp);
-    }
+  free_memory (&entry);
 
   return result == 1;
 }
+libc_hidden_def (innetgr)