update from main archive 961008 cvs/libc-961009

Wed Oct  9 00:30:33 1996  Ulrich Drepper  <drepper@cygnus.com>

	* inet/getnetgrent_r.c: Correct netgroup implementation.  A
	specification of a netgroup can also name another netgroup.
	* nss/nss_files/files-netgrp.c: Likewise.
	* inet/netgroup.h: Add fields to hold additional information.

Tue Oct  8 21:51:14 1996  Arnold D. Robbins  <arnold@skeeve.atl.ga.us>

	* posix/getopt.c: Implement POSIX -W option handling.  When the
	option string contains "W;" -W foo is handled like --foo.

Tue Oct  8 12:27:26 1996  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/unix/sysv/linux/i386/clone.S: Define _ERRNO_H before
	inclusing <errnos.h> so we really get error symbols defined.
	* sysdeps/unix/sysv/linux/m68k/clone.S: Likewise.
	* sysdeps/unix/sysv/linux/alpha/clone.S: Likewise.

	* sunrpc/auth_unix.c (authunix_create_default): Don't use fixed
	size array for getgroups call.  Instead get maximal number via
	sysconf.  But discard list to NGRPS elements before calling XDR
	function since Sun's code cannot handle longer lists.
	Based on a patch by Thorsten Kukuk <kukuk@weber.uni-paderborn.de>.

	* sysdeps/stub/e_j0l.c: Define y0l as well.
	* sysdeps/stub/e_j1l.c: Define y1l as well.
	* sysdeps/stub/e_jnl.c: Define ynl as well.

	* posix/unistd.h: Correct prototype for execlp.

	* sysdeps/unix/sysv/linux/posix_opt.h: Define _POSIX_NO_TRUNC.

Mon Oct  7 22:18:03 1996  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* Makeconfig (sysdep-library-path): New variable.
	(built-program-cmd): Use it here to properly build a colon
	separated library path.

Mon Oct  7 22:11:55 1996  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* crypt/md5-crypt.c (md5_crypt_r): Add missing parens around &
	within comparison.  Fix comments.
	(md5_crypt): Fix comment.

Tue Oct  8 05:10:49 1996  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/unix/sysv/linux/errnos.h: Only include <linux/errnos.h>
	when _ERRNO_H is defined.
	[!_ERRNO_H && __need_Emath]: Define value for EDOM and ERANGE.
	Should there ever be a Linux port where the numeric values are
	not 33 and 34 this file must change.

Mon Oct  7 13:54:04 1996  Ulrich Drepper  <drepper@cygnus.com>

	* libio/iofgets.c (_IO_fgets): Use _IO_flockfile instead of
	__flockfile.

Mon Oct  7 11:01:45 1996  Andreas Jaeger  <aj@arthur.pfalz.de>

	* string/tst-strlen.c (main): Provide prototype.
	* malloc/mallocbug.c: Likewise.
	* io/test-utime.c: Likewise.

	* sysdeps/generic/crypt-entry.c: Correct typo.

Mon Oct  7 13:42:20 1996  Ulrich Drepper  <drepper@cygnus.com>

	* elf/dl-open.c (_dl_open): Check against _dl_sysdep_start to
	test for libc.a.  Checking _DYNAMIC is of no worth here.
	Suggested by Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>.

	* nss/nss_files/files-parse.c: Define LOOKUP_NAME even if
 	EXTERN_PARSER is defined.

Sat Oct  5 17:05:36 1996  Andreas Jaeger  <aj@arthur.pfalz.de>

	* Rules (dep-dummy-lib): Correct prototype for __dummy__.

	* crypt/md5-crypt.c: Fix typos in comments.

	* gmon/gmon.c: Provide prototypes.
	* db/makedb.c: Likewise.
	* locale/programs/xmalloc.c: Likewise.
	* stdio-common/bug11.c (main): Likewise.
	* stdio-common/bug7.c (main): Likewise.
	* stdio-common/bug8.c (main): Likewise.
	* stdio-common/bug9.c (main): Likewise.
	* stdio-common/scanf1.c (main): Likewise.
	* stdio-common/scanf2.c (main): Likewise.
	* stdio-common/scanf5.c (main): Likewise.
	* stdio-common/scanf6.c (main): Likewise.
	* stdio-common/scanf7.c (main): Likewise.
	* stdio-common/scanf8.c (main): Likewise.
	* stdio-common/temptest.c (main): Likewise.
	* stdio-common/test-fwrite.c (main): Likewise.
	* stdio-common/tst-printf.c: Likewise.
	* stdio-common/tstdiomisc.c: Likewise.
	* stdio-common/tstgetln.c (main): Likewise.
	* stdlib/testmb.c (main): Likewise.

	* stdio-common/scanf4.c (main): Correct prototype, remove unused
	variable n.

	* stdio-common/scanf3.c (main): Correct prototype, change
	declaration of s to reduce warnings.
	* stdio-common/bug10.c (main): Likewise.

	* stdio-common/tfformat.c: Provide prototype, remove unused
	reference to dump_stats, add braces in sprint_doubles.
	* stdio-common/tiformat.c: Likewise.

	* stdio-common/test_rdwr.c (main): Parameter `where' is long in
	printf call.

Mon Oct  7 14:04:26 1996  NIIBE Yutaka  <gniibe@mri.co.jp>

	* sysdeps/unix/sysv/linux/sys/soundcard.h: Fix typo.

	* shadow/putspent.c: Don't write colon after flag field.

	* sysdeps/unix/sysv/linux/net/if_ppp.h: New file.  Wrapper around
	kernel header.
	* sysdeps/unix/sysv/linux/net/ppp-comp.h: Likewise.
	* sysdeps/unix/sysv/linux/net/ppp_defs.h: Likewise.
	* sysdeps/unix/sysv/linux/Dist: Mention new files.

Mon Oct  7 00:58:19 1996  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/i386/i586/strchr.S: Correct handling of first bytes to
	get pointer aligned.  Reported by Matthias Urlichs <smurf@noris.de>.

	* sysdeps/posix/euidaccess.c [_LIBC]: Avoid calling get?id functions
	by using __libc_enable_secure variable.

	* sysdeps/libm-i387/s_copysignl.S: Correct loading of return value.

1 files changed, 222 insertions, 41 deletions

diff --git a/inet/getnetgrent_r.c b/inet/getnetgrent_r.c
index 52a90d055c..ff6d5395ed 100644
--- a/inet/getnetgrent_r.c
+++ b/inet/getnetgrent_r.c
@@ -31,6 +31,16 @@ static service_user *nip;
 /* Remember the first service_entry, it's always the same.  */
 static service_user *startp;
 
+/* A netgroup can consist of names of other netgroups.  We have to
+   track which netgroups were read and which still have to be read.  */
+struct name_list
+{
+  const char *name;
+  struct name_list *next;
+};
+struct name_list *known_groups;
+struct name_list *needed_groups;
+
 
 /* The lookup function for the first entry of this service.  */
 extern int __nss_netgroup_lookup (service_user **nip, const char *name,
@@ -62,30 +72,79 @@ setup (void **fctp, const char *func_name, int all)
   return no_more;
 }
 
-int
-setnetgrent (const char *group)
+/* Free used memory.  */
+static void
+free_memory (void)
+{
+  while (known_groups != NULL)
+    {
+      struct name_list *tmp = known_groups;
+      known_groups = known_groups->next;
+      free (tmp->name);
+      free (tmp);
+    }
+
+  while (needed_groups != NULL)
+    {
+      struct name_list *tmp = needed_groups;
+      needed_groups = needed_groups->next;
+      free (tmp->name);
+      free (tmp);
+    }
+}
+
+static int
+internal_setnetgrent (const char *group)
 {
   enum nss_status (*fct) (const char *);
   enum nss_status status = NSS_STATUS_UNAVAIL;
+  struct name_list *new_elem;
   int no_more;
 
-  __libc_lock_lock (lock);
-
   /* Cycle through all the services and run their setnetgrent functions.  */
   no_more = setup ((void **) &fct, "setnetgrent", 1);
   while (! no_more)
     {
-      /* Ignore status, we force check in __NSS_NEXT.  */
+      /* Ignore status, we force check in `__nss_next'.  */
       status = (*fct) (group);
 
       no_more = __nss_next (&nip, "setnetgrent", (void **) &fct, status, 0);
     }
 
-  __libc_lock_unlock (lock);
+  /* 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)
+    {
+      if (new_elem != NULL)
+	free (new_elem);
+      status == NSS_STATUS_UNAVAIL;
+    }
+  else
+    {
+      new_elem->next = known_groups;
+      known_groups = new_elem;
+    }
 
   return status == NSS_STATUS_SUCCESS;
 }
 
+int
+setnetgrent (const char *group)
+{
+  int result;
+
+  __libc_lock_lock (lock);
+
+  /* Free list of all netgroup names from last run.  */
+  free_memory ();
+
+  result = internal_setnetgrent (group);
+
+  __libc_lock_unlock (lock);
+
+  return result;
+}
+
 
 void
 endnetgrent (void)
@@ -103,13 +162,16 @@ endnetgrent (void)
   no_more = setup ((void **) &fct, "endnetgrent", 1);
   while (! no_more)
     {
-      /* Ignore status, we force check in __NSS_NEXT.  */
+      /* Ignore status, we force check in `__nss_next'.  */
       (void) (*fct) ();
 
       no_more = (nip == old_nip
 		 || __nss_next (&nip, "endnetgrent", (void **) &fct, 0, 1));
     }
 
+  /* Now free list of all netgroup names from last run.  */
+  free_memory ();
+
   __libc_lock_unlock (lock);
 }
 
@@ -135,14 +197,63 @@ __getnetgrent_r (char **hostp, char **userp, char **domainp,
     {
       status = (*fct) (&result, buffer, buflen);
 
+      if (status == NSS_STATUS_RETURN)
+	{
+	  /* This was the last one for this group.  Look at next group
+	     if available.  */
+	  int found = 0;
+	  while (needed_groups != NULL && ! found)
+	    {
+	      struct name_list *tmp = needed_groups;
+	      needed_groups = needed_groups->next;
+	      tmp->next = known_groups;
+	      known_groups = tmp;
+
+	      found = internal_setnetgrent (known_groups->name);
+	    }
+
+	  if (found)
+	    continue;
+	}
+      else if (status == NSS_STATUS_SUCCESS && result.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 = known_groups; namep != NULL; namep = namep->next)
+	    if (strcmp (result.val.group, namep->name) == 0)
+	      break;
+	  if (namep != NULL)
+	    /* Really ignore.  */
+	    continue;
+
+	  namep = (struct name_list *) malloc (sizeof (struct name_list));
+	  if (namep == NULL
+	      || (namep->name = strdup (result.val.group)) == NULL)
+	    {
+	      /* We are out of memory.  */
+	      if (namep != NULL)
+		free (namep);
+	      status = NSS_STATUS_RETURN;
+	    }
+	  else
+	    {
+	      namep->next = needed_groups;
+	      needed_groups = namep;
+	      /* And get the next entry.  */
+	      continue;
+	    }
+	}
+
       no_more = __nss_next (&nip, "getnetgrent_r", (void **) &fct, status, 0);
     }
 
   if (status == NSS_STATUS_SUCCESS)
     {
-      *hostp = result.host;
-      *userp = result.user;
-      *domainp = result.domain;
+      *hostp = result.val.triple.host;
+      *userp = result.val.triple.user;
+      *domainp = result.val.triple.domain;
     }
 
   __libc_lock_unlock (lock);
@@ -161,6 +272,10 @@ innetgr (const char *netgroup, const char *host, const char *user,
   int (*getfct) (struct __netgrent *, char *, int);
   int result = 0;
   int no_more;
+  struct name_list *known = NULL;
+  struct name_list *needed = NULL;
+  const char *current_group = netgroup;
+  int real_entry = 0;
 
   __libc_lock_lock (lock);
 
@@ -168,51 +283,117 @@ innetgr (const char *netgroup, const char *host, const char *user,
      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.  */
-  no_more = setup ((void **) &setfct, "setnetgrent", 1);
-  while (! no_more)
+  while (1)
     {
-      enum nss_status status;
-
-      /* Open netgroup.  */
-      status = (*setfct) (netgroup);
-      if (status == NSS_STATUS_SUCCESS
-	  && __nss_lookup (&nip, "getnetgrent_r", (void **) &getfct) == 0)
+      no_more = setup ((void **) &setfct, "setnetgrent", 1);
+      while (! no_more)
 	{
-	  char buffer[1024];
-	  struct __netgrent entry;
+	  enum nss_status status;
 
-	  while ((*getfct) (&entry, buffer, sizeof buffer)
-		 == NSS_STATUS_SUCCESS)
+	  /* Open netgroup.  */
+	  status = (*setfct) (current_group);
+	  if (status == NSS_STATUS_SUCCESS
+	      && __nss_lookup (&nip, "getnetgrent_r", (void **) &getfct) == 0)
 	    {
-	      if ((entry.host == NULL || host == NULL
-		   || strcmp (entry.host, host) == 0)
-		  && (entry.user == NULL || user == NULL
-		      || strcmp (entry.user, user) == 0)
-		  && (entry.domain == NULL || domain == NULL
-		      || strcmp (entry.domain, domain) == 0))
+	      char buffer[1024];
+	      struct __netgrent entry;
+
+	      while ((*getfct) (&entry, buffer, sizeof buffer)
+		     == NSS_STATUS_SUCCESS)
 		{
-		  result = 1;
-		  break;
+		  if (entry.type == group_val)
+		    {
+		      /* Make sure we haven't seen the name before.  */
+		      struct name_list *namep;
+
+		      for (namep = known; namep != NULL; namep = namep->next)
+			if (strcmp (entry.val.group, namep->name) == 0)
+			  break;
+		      if (namep == NULL
+			  && strcmp (netgroup, entry.val.group) != 0)
+			{
+			  namep =
+			    (struct name_list *) malloc (sizeof (*namep));
+			  if (namep == NULL
+			      || ((namep->name = strdup (entry.val.group))
+				  == NULL))
+			    {
+			      /* Out of memory, simply return.  */
+			      if (namep != NULL)
+				free (namep);
+			      result = -1;
+			      break;
+			    }
+
+			  namep->next = needed;
+			  needed = namep;
+			}
+		    }
+		  else
+		    {
+		      real_entry = 1;
+
+		      if ((entry.val.triple.host == NULL || host == NULL
+			   || strcmp (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))
+			{
+			  result = 1;
+			  break;
+			}
+		    }
 		}
+
+	      if (result != 0)
+		break;
+
+	      /* If we found one service which does know the given
+		 netgroup we don't try further.  */
+	      status = NSS_STATUS_RETURN;
 	    }
 
-	  if (result != 0)
-	    break;
+	  /* Free all resources of the service.  */
+	  if (__nss_lookup (&nip, "endnetgrent", (void **) &endfct) == 0)
+	    (*endfct) ();
 
-	  /* If we found one service which does know the given
-	     netgroup we don't try further.  */
-	  status = NSS_STATUS_RETURN;
+	  /* Look for the next service.  */
+	  no_more = __nss_next (&nip, "setnetgrent",
+				(void **) &setfct, status, 0);
 	}
 
-      /* Free all resources of the service.  */
-      if (__nss_lookup (&nip, "endnetgrent", (void **) &endfct) == 0)
-	(*endfct) ();
+      if (result == 0 && needed != NULL)
+	{
+	  struct name_list *tmp = needed;
+	  needed = tmp->next;
+	  tmp->next = known;
+	  known = tmp;
+	  current_group = known->name;
+	  continue;
+	}
 
-      /* Look for the next service.  */
-      no_more = __nss_next (&nip, "setnetgrent", (void **) &setfct, status, 0);
+      /* No way out.  */
+      break;
     }
 
   __libc_lock_unlock (lock);
 
-  return result;
+  /* Free the memory.  */
+  while (known != NULL)
+    {
+      struct name_list *tmp = known;
+      known = known->next;
+      free (tmp->name);
+      free (tmp);
+    }
+  while (needed != NULL)
+    {
+      struct name_list *tmp = needed;
+      needed = needed->next;
+      free (tmp->name);
+      free (tmp);
+    }
+
+  return result == 1;
 }