/* Create a hard link relative to open directories.
- Copyright (C) 2009 Free Software Foundation, Inc.
+ Copyright (C) 2009-2011 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
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
+#include <stdint.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 */
+
+/* On Solaris, link() doesn't follow symlinks by default, but does so as soon
+ as a library or executable takes part in the program that has been compiled
+ with "c99" or "cc -xc99=all" or "cc ... /usr/lib/values-xpg4.o ...". */
+# if LINK_FOLLOWS_SYMLINKS == -1
+
+/* Reduce the penalty of link_immediate and link_follow by incorporating the
+ knowledge that link()'s behaviour depends on the __xpg4 variable. */
+extern int __xpg4;
+
+static int
+solaris_optimized_link_immediate (char const *file1, char const *file2)
+{
+ if (__xpg4 == 0)
+ return link (file1, file2);
+ return link_immediate (file1, file2);
+}
+
+static int
+solaris_optimized_link_follow (char const *file1, char const *file2)
+{
+ if (__xpg4 != 0)
+ return link (file1, file2);
+ return link_follow (file1, file2);
+}
+
+# define link_immediate solaris_optimized_link_immediate
+# define link_follow solaris_optimized_link_follow
+
+# endif
/* 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
+
+/* 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 & ~AT_SYMLINK_FOLLOW)
+ {
+ errno = EINVAL;
+ return -1;
+ }
+
+# if LINKAT_TRAILING_SLASH_BUG
+ /* Reject trailing slashes on non-directories. */
+ {
+ size_t len1 = strlen (file1);
+ size_t len2 = strlen (file2);
+ if ((len1 && file1[len1 - 1] == '/')
+ || (len2 && file2[len2 - 1] == '/'))
+ {
+ /* Let linkat() decide whether hard-linking directories is legal.
+ If fstatat() fails, then linkat() should fail for the same reason;
+ if fstatat() succeeds, require a directory. */
+ struct stat st;
+ if (fstatat (fd1, file1, &st, flag ? 0 : AT_SYMLINK_NOFOLLOW))
+ return -1;
+ if (!S_ISDIR (st.st_mode))
+ {
+ errno = ENOTDIR;
+ return -1;
+ }
+ }
+ }
+# endif
+
+ if (!flag)
+ return linkat (fd1, file1, fd2, file2, flag);
+
+ /* 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 */