#include <errno.h>
#include <fcntl.h>
#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
#include <sys/stat.h>
#include "areadlink.h"
# endif
#endif
+#if !HAVE_LINKAT
+
/* Create a link. If FILE1 is a symlink, either create a hardlink to
that symlink, or fake it by creating an identical symlink. */
-#if LINK_FOLLOWS_SYMLINKS == 0
-# define link_immediate link
-#else
+# if LINK_FOLLOWS_SYMLINKS == 0
+# define link_immediate link
+# else
static int
link_immediate (char const *file1, char const *file2)
{
return -1;
return link (file1, file2);
}
-#endif
+# endif /* LINK_FOLLOWS_SYMLINKS == 0 */
/* Create a link. If FILE1 is a symlink, create a hardlink to the
canonicalized file. */
-#if 0 < LINK_FOLLOWS_SYMLINKS
-# define link_follow link
-#else
+# if 0 < LINK_FOLLOWS_SYMLINKS
+# define link_follow link
+# else
static int
link_follow (char const *file1, char const *file2)
{
}
return result;
}
-#endif
+# endif /* 0 < LINK_FOLLOWS_SYMLINKS */
/* Create a link to FILE1, in the directory open on descriptor FD1, to FILE2,
in the directory open on descriptor FD2. If FILE1 is a symlink, FLAG
return at_func2 (fd1, file1, fd2, file2,
flag ? link_follow : link_immediate);
}
+
+#else /* HAVE_LINKAT */
+
+# undef linkat
+
+/* Read a symlink, like areadlink, but relative to FD. */
+
+static char *
+areadlinkat (int fd, char const *filename)
+{
+ /* The initial buffer size for the link value. A power of 2
+ detects arithmetic overflow earlier, but is not required. */
+# define INITIAL_BUF_SIZE 1024
+
+ /* Allocate the initial buffer on the stack. This way, in the common
+ case of a symlink of small size, we get away with a single small malloc()
+ instead of a big malloc() followed by a shrinking realloc(). */
+ char initial_buf[INITIAL_BUF_SIZE];
+
+ char *buffer = initial_buf;
+ size_t buf_size = sizeof (initial_buf);
+
+ while (1)
+ {
+ /* Attempt to read the link into the current buffer. */
+ ssize_t link_length = readlinkat (fd, filename, buffer, buf_size);
+
+ /* On AIX 5L v5.3 and HP-UX 11i v2 04/09, readlink returns -1
+ with errno == ERANGE if the buffer is too small. */
+ if (link_length < 0 && errno != ERANGE)
+ {
+ if (buffer != initial_buf)
+ {
+ int saved_errno = errno;
+ free (buffer);
+ errno = saved_errno;
+ }
+ return NULL;
+ }
+
+ if ((size_t) link_length < buf_size)
+ {
+ buffer[link_length++] = '\0';
+
+ /* Return it in a chunk of memory as small as possible. */
+ if (buffer == initial_buf)
+ {
+ buffer = (char *) malloc (link_length);
+ if (buffer == NULL)
+ /* errno is ENOMEM. */
+ return NULL;
+ memcpy (buffer, initial_buf, link_length);
+ }
+ else
+ {
+ /* Shrink buffer before returning it. */
+ if ((size_t) link_length < buf_size)
+ {
+ char *smaller_buffer = (char *) realloc (buffer, link_length);
+
+ if (smaller_buffer != NULL)
+ buffer = smaller_buffer;
+ }
+ }
+ return buffer;
+ }
+
+ if (buffer != initial_buf)
+ free (buffer);
+ buf_size *= 2;
+ if (SSIZE_MAX < buf_size || (SIZE_MAX / 2 < SSIZE_MAX && buf_size == 0))
+ {
+ errno = ENOMEM;
+ return NULL;
+ }
+ buffer = (char *) malloc (buf_size);
+ if (buffer == NULL)
+ /* errno is ENOMEM. */
+ return NULL;
+ }
+}
+
+/* Create a link. If FILE1 is a symlink, create a hardlink to the
+ canonicalized file. */
+
+static int
+linkat_follow (int fd1, char const *file1, int fd2, char const *file2)
+{
+ char *name = (char *) file1;
+ char *target;
+ int result;
+ int i = MAXSYMLINKS;
+
+ /* There is no realpathat. */
+ while (i-- && (target = areadlinkat (fd1, name)))
+ {
+ if (IS_ABSOLUTE_FILE_NAME (target))
+ {
+ if (name != file1)
+ free (name);
+ name = target;
+ }
+ else
+ {
+ char *dir = mdir_name (name);
+ if (name != file1)
+ free (name);
+ if (!dir)
+ {
+ free (target);
+ errno = ENOMEM;
+ return -1;
+ }
+ name = mfile_name_concat (dir, target, NULL);
+ free (dir);
+ free (target);
+ if (!name)
+ {
+ errno = ENOMEM;
+ return -1;
+ }
+ }
+ }
+ if (i < 0)
+ {
+ target = NULL;
+ errno = ELOOP;
+ }
+ if (!target && errno != EINVAL)
+ {
+ if (name != file1)
+ {
+ int saved_errno = errno;
+ free (name);
+ errno = saved_errno;
+ }
+ return -1;
+ }
+ result = linkat (fd1, name, fd2, file2, 0);
+ if (name != file1)
+ {
+ int saved_errno = errno;
+ free (name);
+ errno = saved_errno;
+ }
+ return result;
+}
+
+
+/* Like linkat, but guarantee that AT_SYMLINK_FOLLOW works even on
+ older Linux kernels. */
+
+int
+rpl_linkat (int fd1, char const *file1, int fd2, char const *file2, int flag)
+{
+ if (!flag)
+ return linkat (fd1, file1, fd2, file2, flag);
+ if (flag & ~AT_SYMLINK_FOLLOW)
+ {
+ errno = EINVAL;
+ return -1;
+ }
+
+ /* Cache the information on whether the system call really works. */
+ {
+ static int have_follow_really; /* 0 = unknown, 1 = yes, -1 = no */
+ if (0 <= have_follow_really)
+ {
+ int result = linkat (fd1, file1, fd2, file2, flag);
+ if (!(result == -1 && errno == EINVAL))
+ {
+ have_follow_really = 1;
+ return result;
+ }
+ have_follow_really = -1;
+ }
+ }
+ return linkat_follow (fd1, file1, fd2, file2);
+}
+
+#endif /* HAVE_LINKAT */
projects / gnulib.git / blobdiff