/* fchdir replacement.
- Copyright (C) 2006-2009 Free Software Foundation, Inc.
+ Copyright (C) 2006-2010 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/* 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>
#include <sys/stat.h>
-#include "canonicalize.h"
-
#ifndef REPLACE_OPEN_DIRECTORY
# define REPLACE_OPEN_DIRECTORY 0
#endif
+#ifndef HAVE_CANONICALIZE_FILE_NAME
+# if GNULIB_CANONICALIZE || GNULIB_CANONICALIZE_LGPL
+# define HAVE_CANONICALIZE_FILE_NAME 1
+# else
+# define HAVE_CANONICALIZE_FILE_NAME 0
+# define canonicalize_file_name(name) NULL
+# endif
+#endif
+
/* This replacement assumes that a directory is not renamed while opened
through a file descriptor.
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. */
+/* Array of file descriptors opened. If REPLACE_OPEN_DIRECTORY or if it points
+ to a directory, it stores 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; free any
+ contents already in that slot. Return false and set errno to
+ ENOMEM on allocation failure. */
+static bool
ensure_dirs_slot (size_t fd)
{
- if (fd >= dirs_allocated)
+ if (fd < dirs_allocated)
+ free (dirs[fd].name);
+ else
{
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_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;
- }
+ (dirs != NULL
+ ? (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;
+}
+
+/* Return the canonical name of DIR in malloc'd storage. */
+static char *
+get_name (char const *dir)
+{
+ char *result;
+ if (REPLACE_OPEN_DIRECTORY || !HAVE_CANONICALIZE_FILE_NAME)
+ {
+ /* The function canonicalize_file_name has not yet been ported
+ to mingw, with all its drive letter and backslash quirks.
+ Fortunately, getcwd is reliable in this case, but we ensure
+ we can get back to where we started before using it. Treat
+ "." as a special case, as it is frequently encountered. */
+ char *cwd = getcwd (NULL, 0);
+ int saved_errno;
+ if (dir[0] == '.' && dir[1] == '\0')
+ return cwd;
+ if (chdir (cwd))
+ return NULL;
+ result = chdir (dir) ? NULL : getcwd (NULL, 0);
+ saved_errno = errno;
+ if (chdir (cwd))
+ abort ();
+ free (cwd);
+ errno = saved_errno;
+ }
+ else
+ {
+ /* Avoid changing the directory. */
+ result = canonicalize_file_name (dir);
+ }
+ return result;
}
/* Hook into the gnulib replacements for open() and close() to keep track
{
free (dirs[fd].name);
dirs[fd].name = NULL;
- dirs[fd].saved_errno = ENOTDIR;
}
}
-/* Mark FD as visiting FILENAME. FD must be positive, 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. */
-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
- && (REPLACE_OPEN_DIRECTORY
- || (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)))
+ {
+ if (!ensure_dirs_slot (fd)
+ || (dirs[fd].name = get_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. */
+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)
{
- dirs[fd].name = canonicalize_file_name (filename);
- if (dirs[fd].name == NULL)
- dirs[fd].saved_errno = errno;
+ if (dup2 (fd, fd) == fd)
+ errno = ENOTDIR;
}
+ else
+ errno = EBADF;
+ return NULL;
}
+#if REPLACE_OPEN_DIRECTORY
/* 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
+# undef fstat
int
rpl_fstat (int fd, struct stat *statbuf)
{
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)
{
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 && fd < dirs_allocated && dirs[fd].name != NULL)
- return chdir (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 -1;
+ const char *name = _gl_directory_name (fd);
+ return name ? chdir (name) : -1;
}
projects / gnulib.git / blobdiff