Upgrade to Gnulib 20090915.

1 files changed, 124 insertions, 122 deletions

diff --git a/gnulib/lib/fchdir.c b/gnulib/lib/fchdir.c
index d51d9630..f3556291 100644
--- a/gnulib/lib/fchdir.c
+++ b/gnulib/lib/fchdir.c
@@ -19,10 +19,11 @@
 /* Specification.  */
 #include <unistd.h>
 
+#include <assert.h>
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <stdarg.h>
+#include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
@@ -30,80 +31,161 @@
 
 #include "canonicalize.h"
 
+#ifndef REPLACE_OPEN_DIRECTORY
+# define REPLACE_OPEN_DIRECTORY 0
+#endif
+
 /* This replacement assumes that a directory is not renamed while opened
-   through a file descriptor.  */
+   through a file descriptor.
+
+   FIXME: On mingw, this would be possible to enforce if we were to
+   also open a HANDLE to each directory currently visited by a file
+   descriptor, since mingw refuses to rename any in-use file system
+   object.  */
 
 /* Array of file descriptors opened.  If it points to a directory, it stores
-   info about this directory; otherwise it stores an errno value of ENOTDIR.  */
+   info about this directory.  */
 typedef struct
 {
   char *name;       /* Absolute name of the directory, or NULL.  */
-  int saved_errno;  /* If name == NULL: The error code describing the failure
-		       reason.  */
+  /* FIXME - add a DIR* member to make dirfd possible on mingw?  */
 } dir_info_t;
 static dir_info_t *dirs;
 static size_t dirs_allocated;
 
-/* Try to ensure dirs has enough room for a slot at index fd.  */
-static void
+/* Try to ensure dirs has enough room for a slot at index fd.  Return
+   false and set errno to ENOMEM on allocation failure.  */
+static bool
 ensure_dirs_slot (size_t fd)
 {
   if (fd >= dirs_allocated)
     {
       size_t new_allocated;
       dir_info_t *new_dirs;
-      size_t i;
 
       new_allocated = 2 * dirs_allocated + 1;
       if (new_allocated <= fd)
 	new_allocated = fd + 1;
       new_dirs =
 	(dirs != NULL
-	 ? (dir_info_t *) realloc (dirs, new_allocated * sizeof (dir_info_t))
-	 : (dir_info_t *) malloc (new_allocated * sizeof (dir_info_t)));
-      if (new_dirs != NULL)
-	{
-	  for (i = dirs_allocated; i < new_allocated; i++)
-	    {
-	      new_dirs[i].name = NULL;
-	      new_dirs[i].saved_errno = ENOTDIR;
-	    }
-	  dirs = new_dirs;
-	  dirs_allocated = new_allocated;
-	}
+	 ? (dir_info_t *) realloc (dirs, new_allocated * sizeof *dirs)
+	 : (dir_info_t *) malloc (new_allocated * sizeof *dirs));
+      if (new_dirs == NULL)
+        return false;
+      memset (new_dirs + dirs_allocated, 0,
+              (new_allocated - dirs_allocated) * sizeof *dirs);
+      dirs = new_dirs;
+      dirs_allocated = new_allocated;
     }
+  return true;
 }
 
 /* Hook into the gnulib replacements for open() and close() to keep track
    of the open file descriptors.  */
 
+/* Close FD, cleaning up any fd to name mapping if fd was visiting a
+   directory.  */
 void
 _gl_unregister_fd (int fd)
 {
   if (fd >= 0 && fd < dirs_allocated)
     {
-      if (dirs[fd].name != NULL)
-	free (dirs[fd].name);
+      free (dirs[fd].name);
       dirs[fd].name = NULL;
-      dirs[fd].saved_errno = ENOTDIR;
     }
 }
 
-void
+/* Mark FD as visiting FILENAME.  FD must be non-negative, and refer
+   to an open file descriptor.  If REPLACE_OPEN_DIRECTORY is non-zero,
+   this should only be called if FD is visiting a directory.  Close FD
+   and return -1 if there is insufficient memory to track the
+   directory name; otherwise return FD.  */
+int
 _gl_register_fd (int fd, const char *filename)
 {
   struct stat statbuf;
 
-  ensure_dirs_slot (fd);
-  if (fd < dirs_allocated
-      && fstat (fd, &statbuf) >= 0 && S_ISDIR (statbuf.st_mode))
+  assert (0 <= fd);
+  if (REPLACE_OPEN_DIRECTORY
+      || (fstat (fd, &statbuf) == 0 && S_ISDIR (statbuf.st_mode)))
     {
-      dirs[fd].name = canonicalize_file_name (filename);
-      if (dirs[fd].name == NULL)
-	dirs[fd].saved_errno = errno;
+      if (!ensure_dirs_slot (fd)
+          || (dirs[fd].name = canonicalize_file_name (filename)) == NULL)
+        {
+          int saved_errno = errno;
+          close (fd);
+          errno = saved_errno;
+          return -1;
+        }
     }
+  return fd;
+}
+
+/* Mark NEWFD as a duplicate of OLDFD; useful from dup, dup2, dup3,
+   and fcntl.  Both arguments must be valid and distinct file
+   descriptors.  Close NEWFD and return -1 if OLDFD is tracking a
+   directory, but there is insufficient memory to track the same
+   directory in NEWFD; otherwise return NEWFD.
+
+   FIXME: Need to implement rpl_fcntl in gnulib, and have it call
+   this.  */
+int
+_gl_register_dup (int oldfd, int newfd)
+{
+  assert (0 <= oldfd && 0 <= newfd && oldfd != newfd);
+  if (oldfd < dirs_allocated && dirs[oldfd].name)
+    {
+      /* Duplicated a directory; must ensure newfd is allocated.  */
+      if (!ensure_dirs_slot (newfd)
+          || (dirs[newfd].name = strdup (dirs[oldfd].name)) == NULL)
+        {
+          int saved_errno = errno;
+          close (newfd);
+          errno = saved_errno;
+          newfd = -1;
+        }
+    }
+  else if (newfd < dirs_allocated)
+    {
+      /* Duplicated a non-directory; ensure newfd is cleared.  */
+      free (dirs[newfd].name);
+      dirs[newfd].name = NULL;
+    }
+  return newfd;
+}
+
+/* If FD is currently visiting a directory, then return the name of
+   that directory.  Otherwise, return NULL and set errno.  */
+const char *
+_gl_directory_name (int fd)
+{
+  if (0 <= fd && fd < dirs_allocated && dirs[fd].name != NULL)
+    return dirs[fd].name;
+  /* At this point, fd is either invalid, or open but not a directory.
+     If dup2 fails, errno is correctly EBADF.  */
+  if (0 <= fd)
+    {
+      if (dup2 (fd, fd) == fd)
+        errno = ENOTDIR;
+    }
+  else
+    errno = EBADF;
+  return NULL;
 }
 
+/* Return stat information about FD in STATBUF.  Needed when
+   rpl_open() used a dummy file to work around an open() that can't
+   normally visit directories.  */
+#if REPLACE_OPEN_DIRECTORY
+int
+rpl_fstat (int fd, struct stat *statbuf)
+{
+  if (0 <= fd && fd < dirs_allocated && dirs[fd].name != NULL)
+    return stat (dirs[fd].name, statbuf);
+  return fstat (fd, statbuf);
+}
+#endif
+
 /* Override opendir() and closedir(), to keep track of the open file
    descriptors.  Needed because there is a function dirfd().  */
 
@@ -129,13 +211,18 @@ rpl_opendir (const char *filename)
   if (dp != NULL)
     {
       int fd = dirfd (dp);
-      if (fd >= 0)
-	_gl_register_fd (fd, filename);
+      if (0 <= fd && _gl_register_fd (fd, filename) != fd)
+        {
+          int saved_errno = errno;
+          closedir (dp);
+          errno = saved_errno;
+          return NULL;
+        }
     }
   return dp;
 }
 
-/* Override dup() and dup2(), to keep track of open file descriptors.  */
+/* Override dup(), to keep track of open file descriptors.  */
 
 int
 rpl_dup (int oldfd)
@@ -143,102 +230,17 @@ rpl_dup (int oldfd)
 {
   int newfd = dup (oldfd);
 
-  if (oldfd >= 0 && newfd >= 0)
-    {
-      ensure_dirs_slot (newfd);
-      if (newfd < dirs_allocated)
-	{
-	  if (oldfd < dirs_allocated)
-	    {
-	      if (dirs[oldfd].name != NULL)
-		{
-		  dirs[newfd].name = strdup (dirs[oldfd].name);
-		  if (dirs[newfd].name == NULL)
-		    dirs[newfd].saved_errno = ENOMEM;
-		}
-	      else
-		{
-		  dirs[newfd].name = NULL;
-		  dirs[newfd].saved_errno = dirs[oldfd].saved_errno;
-		}
-	    }
-	  else
-	    {
-	      dirs[newfd].name = NULL;
-	      dirs[newfd].saved_errno = ENOMEM;
-	    }
-	}
-    }
+  if (0 <= newfd)
+    newfd = _gl_register_dup (oldfd, newfd);
   return newfd;
 }
 
-/* Our <unistd.h> replacement overrides dup2 twice; be sure to pick
-   the one we want.  */
-#if REPLACE_DUP2
-# undef dup2
-# define dup2 rpl_dup2
-#endif
-
-int
-rpl_dup2_fchdir (int oldfd, int newfd)
-{
-  int retval = dup2 (oldfd, newfd);
-
-  if (retval >= 0 && newfd != oldfd)
-    {
-      ensure_dirs_slot (newfd);
-      if (newfd < dirs_allocated)
-	{
-	  if (oldfd < dirs_allocated)
-	    {
-	      if (dirs[oldfd].name != NULL)
-		{
-		  dirs[newfd].name = strdup (dirs[oldfd].name);
-		  if (dirs[newfd].name == NULL)
-		    dirs[newfd].saved_errno = ENOMEM;
-		}
-	      else
-		{
-		  dirs[newfd].name = NULL;
-		  dirs[newfd].saved_errno = dirs[oldfd].saved_errno;
-		}
-	    }
-	  else
-	    {
-	      dirs[newfd].name = NULL;
-	      dirs[newfd].saved_errno = ENOMEM;
-	    }
-	}
-    }
-  return retval;
-}
 
 /* Implement fchdir() in terms of chdir().  */
 
 int
 fchdir (int fd)
 {
-  if (fd >= 0)
-    {
-      if (fd < dirs_allocated)
-	{
-	  if (dirs[fd].name != NULL)
-	    return chdir (dirs[fd].name);
-	  else
-	    {
-	      errno = dirs[fd].saved_errno;
-	      return -1;
-	    }
-	}
-      else
-	{
-	  errno = ENOMEM;
-	  return -1;
-	}
-    }
-  else
-    {
-      errno = EBADF;
-      return -1;
-    }
+  const char *name = _gl_directory_name (fd);
+  return name ? chdir (name) : -1;
 }