char *
xreadlink (char const *filename)
{
char *result = areadlink (filename);
if (result == NULL && errno == ENOMEM)
xalloc_die ();
return result;
}
static int
link_immediate (char const *file1, char const *file2)
{
char *target = areadlink (file1);
if (target)
{
/* A symlink cannot be modified in-place. Therefore, creating
an identical symlink behaves like a hard link to a symlink,
except for incorrect st_ino and st_nlink. However, we must
be careful of EXDEV. */
struct stat st1;
struct stat st2;
char *dir = mdir_name (file2);
if (!dir)
{
free (target);
errno = ENOMEM;
return -1;
}
if (lstat (file1, &st1) == 0 && stat (dir, &st2) == 0)
{
if (st1.st_dev == st2.st_dev)
{
int result = symlink (target, file2);
int saved_errno = errno;
free (target);
free (dir);
errno = saved_errno;
return result;
}
free (target);
free (dir);
errno = EXDEV;
return -1;
}
free (target);
free (dir);
}
if (errno == ENOMEM)
return -1;
return link (file1, file2);
}
char* fsll_getlink(const char *base, const char *file)
{
char *path = NULL;
asprintf(&path, "%s/%s", base, file);
char *result = areadlink(path);
if (result == NULL) {
if ((errno == ENOENT) || (errno == ENOTDIR)) {
free(path);
return NULL;
}
else {
PERROR("readlink in fsll_getlink");
free(path);
return NULL;
}
}
else {
free(path);
return result;
}
}
static int
link_follow (char const *file1, char const *file2)
{
char *name = (char *) file1;
char *target;
int result;
int i = MAXSYMLINKS;
/* Using realpath or canonicalize_file_name is too heavy-handed: we
don't need an absolute name, and we don't need to resolve
intermediate symlinks, just the basename of each iteration. */
while (i-- && (target = areadlink (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 = link (name, file2);
if (name != file1)
{
int saved_errno = errno;
free (name);
errno = saved_errno;
}
return result;
}
int
main ()
{
int i;
int dfd;
char *cwd;
int result;
/* Clean up any trash from prior testsuite runs. */
ASSERT (system ("rm -rf " BASE "*") == 0);
/* Test basic link functionality, without mentioning symlinks. */
result = test_link (do_link, false);
dfd1 = open (".", O_RDONLY);
ASSERT (0 <= dfd1);
ASSERT (test_link (do_link, false) == result);
dfd2 = dfd1;
ASSERT (test_link (do_link, false) == result);
dfd1 = AT_FDCWD;
ASSERT (test_link (do_link, false) == result);
flag = 0;
ASSERT (test_link (do_link, false) == result);
dfd1 = dfd2;
ASSERT (test_link (do_link, false) == result);
dfd2 = AT_FDCWD;
ASSERT (test_link (do_link, false) == result);
ASSERT (close (dfd1) == 0);
dfd1 = AT_FDCWD;
ASSERT (test_link (do_link, false) == result);
/* Create locations to manipulate. */
ASSERT (mkdir (BASE "sub1", 0700) == 0);
ASSERT (mkdir (BASE "sub2", 0700) == 0);
ASSERT (close (creat (BASE "00", 0600)) == 0);
cwd = xgetcwd ();
dfd = open (BASE "sub1", O_RDONLY);
ASSERT (0 <= dfd);
ASSERT (chdir (BASE "sub2") == 0);
/* There are 16 possible scenarios, based on whether an fd is
AT_FDCWD or real, whether a file is absolute or relative, coupled
with whether flag is set for 32 iterations.
To ensure that we test all of the code paths (rather than
triggering early normalization optimizations), we use a loop to
repeatedly rename a file in the parent directory, use an fd open
on subdirectory 1, all while executing in subdirectory 2; all
relative names are thus given with a leading "../". Finally, the
last scenario (two relative paths given, neither one AT_FDCWD)
has two paths, based on whether the two fds are equivalent, so we
do the other variant after the loop. */
for (i = 0; i < 32; i++)
{
int flag = (i & 0x10 ? AT_SYMLINK_FOLLOW : 0);
int fd1 = (i & 8) ? dfd : AT_FDCWD;
char *file1 = file_name_concat ((i & 4) ? ".." : cwd, BASE "xx", NULL);
int fd2 = (i & 2) ? dfd : AT_FDCWD;
char *file2 = file_name_concat ((i & 1) ? ".." : cwd, BASE "xx", NULL);
ASSERT (sprintf (strchr (file1, '\0') - 2, "%02d", i) == 2);
ASSERT (sprintf (strchr (file2, '\0') - 2, "%02d", i + 1) == 2);
ASSERT (linkat (fd1, file1, fd2, file2, flag) == 0);
ASSERT (unlinkat (fd1, file1, 0) == 0);
free (file1);
free (file2);
}
dfd2 = open ("..", O_RDONLY);
ASSERT (0 <= dfd2);
ASSERT (linkat (dfd, "../" BASE "32", dfd2, BASE "33", 0) == 0);
ASSERT (linkat (dfd, "../" BASE "33", dfd2, BASE "34",
AT_SYMLINK_FOLLOW) == 0);
ASSERT (close (dfd2) == 0);
/* Now we change back to the parent directory, and set dfd to ".",
in order to test behavior on symlinks. */
ASSERT (chdir ("..") == 0);
ASSERT (close (dfd) == 0);
if (symlink (BASE "sub1", BASE "link1"))
{
ASSERT (unlink (BASE "32") == 0);
ASSERT (unlink (BASE "33") == 0);
ASSERT (unlink (BASE "34") == 0);
ASSERT (rmdir (BASE "sub1") == 0);
ASSERT (rmdir (BASE "sub2") == 0);
free (cwd);
fputs ("skipping test: symlinks not supported on this filesystem\n",
stderr);
return result;
}
dfd = open (".", O_RDONLY);
ASSERT (0 <= dfd);
ASSERT (symlink (BASE "34", BASE "link2") == 0);
ASSERT (symlink (BASE "link3", BASE "link3") == 0);
ASSERT (symlink (BASE "nowhere", BASE "link4") == 0);
/* Link cannot overwrite existing files. */
errno = 0;
ASSERT (linkat (dfd, BASE "link1", dfd, BASE "sub1", 0) == -1);
ASSERT (errno == EEXIST);
errno = 0;
ASSERT (linkat (dfd, BASE "link1/", dfd, BASE "sub1", 0) == -1);
ASSERT (errno == EEXIST || errno == EPERM || errno == EACCES);
errno = 0;
ASSERT (linkat (dfd, BASE "link1", dfd, BASE "sub1/", 0) == -1);
ASSERT (errno == EEXIST);
errno = 0;
ASSERT (linkat (dfd, BASE "link1", dfd, BASE "sub1",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == EEXIST || errno == EPERM || errno == EACCES);
errno = 0;
ASSERT (linkat (dfd, BASE "link1/", dfd, BASE "sub1",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == EEXIST || errno == EPERM || errno == EACCES);
errno = 0;
ASSERT (linkat (dfd, BASE "link1", dfd, BASE "sub1/",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == EEXIST || errno == EPERM || errno == EACCES);
errno = 0;
ASSERT (linkat (dfd, BASE "link1", dfd, BASE "link2", 0) == -1);
ASSERT (errno == EEXIST);
errno = 0;
ASSERT (linkat (dfd, BASE "link1", dfd, BASE "link2",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == EEXIST || errno == EPERM || errno == EACCES);
errno = 0;
ASSERT (linkat (dfd, BASE "link1", dfd, BASE "link3", 0) == -1);
ASSERT (errno == EEXIST || errno == ELOOP);
errno = 0;
ASSERT (linkat (dfd, BASE "link1", dfd, BASE "link3",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == EEXIST || errno == EPERM || errno == EACCES
|| errno == ELOOP);
errno = 0;
ASSERT (linkat (dfd, BASE "link2", dfd, BASE "link3", 0) == -1);
ASSERT (errno == EEXIST || errno == ELOOP);
errno = 0;
ASSERT (linkat (dfd, BASE "link2", dfd, BASE "link3",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == EEXIST || errno == ELOOP);
/* AT_SYMLINK_FOLLOW only follows first argument, not second. */
errno = 0;
ASSERT (linkat (dfd, BASE "link1", dfd, BASE "link4", 0) == -1);
ASSERT (errno == EEXIST);
ASSERT (linkat (dfd, BASE "link1", dfd, BASE "link4",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == EEXIST || errno == EPERM || errno == EACCES);
errno = 0;
ASSERT (linkat (dfd, BASE "34", dfd, BASE "link4", 0) == -1);
ASSERT (errno == EEXIST);
errno = 0;
ASSERT (linkat (dfd, BASE "34", dfd, BASE "link4", AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == EEXIST);
/* Trailing slash handling. */
errno = 0;
ASSERT (linkat (dfd, BASE "link2/", dfd, BASE "link5", 0) == -1);
ASSERT (errno == ENOTDIR);
errno = 0;
ASSERT (linkat (dfd, BASE "link2/", dfd, BASE "link5",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == ENOTDIR);
errno = 0;
ASSERT (linkat (dfd, BASE "link3/", dfd, BASE "link5", 0) == -1);
ASSERT (errno == ELOOP);
errno = 0;
ASSERT (linkat (dfd, BASE "link3/", dfd, BASE "link5",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == ELOOP);
errno = 0;
ASSERT (linkat (dfd, BASE "link4/", dfd, BASE "link5", 0) == -1);
ASSERT (errno == ENOENT);
errno = 0;
ASSERT (linkat (dfd, BASE "link4/", dfd, BASE "link5",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == ENOENT);
/* Check for hard links to symlinks. */
ASSERT (linkat (dfd, BASE "link1", dfd, BASE "link5", 0) == 0);
check_same_link (BASE "link1", BASE "link5");
ASSERT (unlink (BASE "link5") == 0);
errno = 0;
ASSERT (linkat (dfd, BASE "link1", dfd, BASE "link5",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == EPERM || errno == EACCES);
ASSERT (linkat (dfd, BASE "link2", dfd, BASE "link5", 0) == 0);
check_same_link (BASE "link2", BASE "link5");
ASSERT (unlink (BASE "link5") == 0);
ASSERT (linkat (dfd, BASE "link2", dfd, BASE "file", AT_SYMLINK_FOLLOW) == 0);
errno = 0;
ASSERT (areadlink (BASE "file") == NULL);
ASSERT (errno == EINVAL);
ASSERT (unlink (BASE "file") == 0);
ASSERT (linkat (dfd, BASE "link3", dfd, BASE "link5", 0) == 0);
check_same_link (BASE "link3", BASE "link5");
ASSERT (unlink (BASE "link5") == 0);
errno = 0;
ASSERT (linkat (dfd, BASE "link3", dfd, BASE "link5",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == ELOOP);
ASSERT (linkat (dfd, BASE "link4", dfd, BASE "link5", 0) == 0);
check_same_link (BASE "link4", BASE "link5");
ASSERT (unlink (BASE "link5") == 0);
errno = 0;
ASSERT (linkat (dfd, BASE "link4", dfd, BASE "link5",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == ENOENT);
/* Check that symlink to symlink to file is followed all the way. */
ASSERT (symlink (BASE "link2", BASE "link5") == 0);
ASSERT (linkat (dfd, BASE "link5", dfd, BASE "link6", 0) == 0);
check_same_link (BASE "link5", BASE "link6");
ASSERT (unlink (BASE "link6") == 0);
ASSERT (linkat (dfd, BASE "link5", dfd, BASE "file", AT_SYMLINK_FOLLOW) == 0);
errno = 0;
ASSERT (areadlink (BASE "file") == NULL);
ASSERT (errno == EINVAL);
ASSERT (unlink (BASE "file") == 0);
ASSERT (unlink (BASE "link5") == 0);
ASSERT (symlink (BASE "link3", BASE "link5") == 0);
errno = 0;
ASSERT (linkat (dfd, BASE "link5", dfd, BASE "file",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == ELOOP);
ASSERT (unlink (BASE "link5") == 0);
ASSERT (symlink (BASE "link4", BASE "link5") == 0);
errno = 0;
ASSERT (linkat (dfd, BASE "link5", dfd, BASE "file",
AT_SYMLINK_FOLLOW) == -1);
ASSERT (errno == ENOENT);
/* Now for some real fun with directory crossing. */
ASSERT (symlink (cwd, BASE "sub1/link") == 0);
ASSERT (symlink (".././/" BASE "sub1/link/" BASE "link2",
BASE "sub2/link") == 0);
ASSERT (close (dfd) == 0);
dfd = open (BASE "sub1", O_RDONLY);
ASSERT (0 <= dfd);
dfd2 = open (BASE "sub2", O_RDONLY);
ASSERT (0 < dfd2);
ASSERT (linkat (dfd, "../" BASE "sub2/link", dfd2, "./..//" BASE "sub1/file",
AT_SYMLINK_FOLLOW) == 0);
errno = 0;
ASSERT (areadlink (BASE "sub1/file") == NULL);
ASSERT (errno == EINVAL);
/* Cleanup. */
ASSERT (close (dfd) == 0);
ASSERT (close (dfd2) == 0);
ASSERT (unlink (BASE "sub1/file") == 0);
ASSERT (unlink (BASE "sub1/link") == 0);
ASSERT (unlink (BASE "sub2/link") == 0);
ASSERT (unlink (BASE "32") == 0);
ASSERT (unlink (BASE "33") == 0);
ASSERT (unlink (BASE "34") == 0);
ASSERT (rmdir (BASE "sub1") == 0);
ASSERT (rmdir (BASE "sub2") == 0);
ASSERT (unlink (BASE "link1") == 0);
ASSERT (unlink (BASE "link2") == 0);
ASSERT (unlink (BASE "link3") == 0);
ASSERT (unlink (BASE "link4") == 0);
ASSERT (unlink (BASE "link5") == 0);
free (cwd);
return result;
}
/**
* virPidFileReadPathIfAlive:
* @path: path to pidfile
* @pid: variable to return pid in
* @binpath: path of executable associated with the pidfile
*
* This will attempt to read a pid from @path, and store it
* in @pid. The @pid will only be set, however, if the
* pid in @path is running, and its executable path
* resolves to @binpath. This adds protection against
* recycling of previously reaped pids.
*
* If @binpath is NULL the check for the executable path
* is skipped.
*
* Returns -errno upon error, or zero on successful
* reading of the pidfile. If the PID was not still
* alive, zero will be returned, but @pid will be
* set to -1.
*/
int virPidFileReadPathIfAlive(const char *path,
pid_t *pid,
const char *binPath)
{
int ret;
bool isLink;
char *procPath = NULL;
char *procLink = NULL;
size_t procLinkLen;
char *resolvedBinPath = NULL;
char *resolvedProcLink = NULL;
const char deletedText[] = " (deleted)";
size_t deletedTextLen = strlen(deletedText);
pid_t retPid;
/* only set this at the very end on success */
*pid = -1;
if ((ret = virPidFileReadPath(path, &retPid)) < 0)
goto cleanup;
#ifndef WIN32
/* Check that it's still alive. Safe to skip this sanity check on
* mingw, which lacks kill(). */
if (kill(retPid, 0) < 0) {
ret = 0;
retPid = -1;
goto cleanup;
}
#endif
if (!binPath) {
/* we only knew the pid, and that pid is alive, so we can
* return it.
*/
ret = 0;
goto cleanup;
}
if (virAsprintf(&procPath, "/proc/%lld/exe", (long long)retPid) < 0) {
ret = -ENOMEM;
goto cleanup;
}
if ((ret = virFileIsLink(procPath)) < 0)
goto cleanup;
isLink = ret;
if (isLink && virFileLinkPointsTo(procPath, binPath)) {
/* the link in /proc/$pid/exe is a symlink to a file
* that has the same inode as the file at binpath.
*/
ret = 0;
goto cleanup;
}
/* Even if virFileLinkPointsTo returns a mismatch, it could be
* that the binary was deleted/replaced after it was executed. In
* that case the link in /proc/$pid/exe will contain
* "$procpath (deleted)". Read that link, remove the " (deleted)"
* part, and see if it has the same canonicalized name as binpath.
*/
if (!(procLink = areadlink(procPath))) {
ret = -errno;
goto cleanup;
}
procLinkLen = strlen(procLink);
if (procLinkLen > deletedTextLen)
procLink[procLinkLen - deletedTextLen] = 0;
if ((ret = virFileResolveAllLinks(binPath, &resolvedBinPath)) < 0)
goto cleanup;
if ((ret = virFileResolveAllLinks(procLink, &resolvedProcLink)) < 0)
goto cleanup;
ret = STREQ(resolvedBinPath, resolvedProcLink) ? 0 : -1;
cleanup:
VIR_FREE(procPath);
VIR_FREE(procLink);
VIR_FREE(resolvedProcLink);
VIR_FREE(resolvedBinPath);
/* return the originally set pid of -1 unless we proclaim success */
if (ret == 0)
*pid = retPid;
return ret;
}
/*
* dcanon - canonicalize the pathname, removing excess ./ and ../ etc.
* we are of course assuming that the file system is standardly
* constructed (always have ..'s, directories have links)
*/
Char *
dcanon(Char *cp, Char *p)
{
Char *sp;
Char *p1, *p2; /* general purpose */
int slash;
#ifdef HAVE_SLASHSLASH
int slashslash;
#endif /* HAVE_SLASHSLASH */
size_t clen;
#ifdef S_IFLNK /* if we have symlinks */
Char *mlink, *newcp;
char *tlink;
size_t cc;
#endif /* S_IFLNK */
clen = Strlen(cp);
/*
* christos: if the path given does not start with a slash prepend cwd. If
* cwd does not start with a slash or the result would be too long try to
* correct it.
*/
if (!ABSOLUTEP(cp)) {
Char *tmpdir;
size_t len;
p1 = varval(STRcwd);
if (p1 == STRNULL || !ABSOLUTEP(p1)) {
Char *new_cwd = agetcwd();
if (new_cwd == NULL) {
xprintf("%s: %s\n", progname, strerror(errno));
setcopy(STRcwd, str2short("/"), VAR_READWRITE|VAR_NOGLOB);
}
else
setv(STRcwd, new_cwd, VAR_READWRITE|VAR_NOGLOB);
p1 = varval(STRcwd);
}
len = Strlen(p1);
tmpdir = xmalloc((len + clen + 2) * sizeof (*tmpdir));
(void) Strcpy(tmpdir, p1);
(void) Strcat(tmpdir, STRslash);
(void) Strcat(tmpdir, cp);
xfree(cp);
cp = p = tmpdir;
}
#ifdef HAVE_SLASHSLASH
slashslash = (cp[0] == '/' && cp[1] == '/');
#endif /* HAVE_SLASHSLASH */
while (*p) { /* for each component */
sp = p; /* save slash address */
while (*++p == '/') /* flush extra slashes */
continue;
if (p != ++sp)
for (p1 = sp, p2 = p; (*p1++ = *p2++) != '\0';)
continue;
p = sp; /* save start of component */
slash = 0;
if (*p)
while (*++p) /* find next slash or end of path */
if (*p == '/') {
slash = 1;
*p = 0;
break;
}
#ifdef HAVE_SLASHSLASH
if (&cp[1] == sp && sp[0] == '.' && sp[1] == '.' && sp[2] == '\0')
slashslash = 1;
#endif /* HAVE_SLASHSLASH */
if (*sp == '\0') { /* if component is null */
if (--sp == cp) /* if path is one char (i.e. /) */
break;
else
*sp = '\0';
}
else if (sp[0] == '.' && sp[1] == 0) {
if (slash) {
for (p1 = sp, p2 = p + 1; (*p1++ = *p2++) != '\0';)
continue;
p = --sp;
}
else if (--sp != cp)
*sp = '\0';
else
sp[1] = '\0';
}
else if (sp[0] == '.' && sp[1] == '.' && sp[2] == 0) {
/*
* We have something like "yyy/xxx/..", where "yyy" can be null or
* a path starting at /, and "xxx" is a single component. Before
* compressing "xxx/..", we want to expand "yyy/xxx", if it is a
* symbolic link.
*/
*--sp = 0; /* form the pathname for readlink */
#ifdef S_IFLNK /* if we have symlinks */
if (sp != cp && /* symlinks != SYM_IGNORE && */
(tlink = areadlink(short2str(cp))) != NULL) {
mlink = str2short(tlink);
xfree(tlink);
if (slash)
*p = '/';
/*
* Point p to the '/' in "/..", and restore the '/'.
*/
*(p = sp) = '/';
if (*mlink != '/') {
/*
* Relative path, expand it between the "yyy/" and the
* "/..". First, back sp up to the character past "yyy/".
*/
while (*--sp != '/')
continue;
sp++;
*sp = 0;
/*
* New length is "yyy/" + mlink + "/.." and rest
*/
p1 = newcp = xmalloc(((sp - cp) + Strlen(mlink) +
Strlen(p) + 1) * sizeof(Char));
/*
* Copy new path into newcp
*/
for (p2 = cp; (*p1++ = *p2++) != '\0';)
continue;
for (p1--, p2 = mlink; (*p1++ = *p2++) != '\0';)
continue;
for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
continue;
/*
* Restart canonicalization at expanded "/xxx".
*/
p = sp - cp - 1 + newcp;
}
else {
newcp = Strspl(mlink, p);
/*
* Restart canonicalization at beginning
*/
p = newcp;
}
xfree(cp);
cp = newcp;
#ifdef HAVE_SLASHSLASH
slashslash = (cp[0] == '/' && cp[1] == '/');
#endif /* HAVE_SLASHSLASH */
continue; /* canonicalize the link */
}
#endif /* S_IFLNK */
*sp = '/';
if (sp != cp)
while (*--sp != '/')
continue;
if (slash) {
for (p1 = sp + 1, p2 = p + 1; (*p1++ = *p2++) != '\0';)
continue;
p = sp;
}
else if (cp == sp)
*++sp = '\0';
else
*sp = '\0';
}
else { /* normal dir name (not . or .. or nothing) */
#ifdef S_IFLNK /* if we have symlinks */
if (sp != cp && symlinks == SYM_CHASE &&
(tlink = areadlink(short2str(cp))) != NULL) {
mlink = str2short(tlink);
xfree(tlink);
/*
* restore the '/'.
*/
if (slash)
*p = '/';
/*
* point sp to p (rather than backing up).
*/
sp = p;
if (*mlink != '/') {
/*
* Relative path, expand it between the "yyy/" and the
* remainder. First, back sp up to the character past
* "yyy/".
*/
while (*--sp != '/')
continue;
sp++;
*sp = 0;
/*
* New length is "yyy/" + mlink + "/.." and rest
*/
p1 = newcp = xmalloc(((sp - cp) + Strlen(mlink) +
Strlen(p) + 1) * sizeof(Char));
/*
* Copy new path into newcp
*/
for (p2 = cp; (*p1++ = *p2++) != '\0';)
continue;
for (p1--, p2 = mlink; (*p1++ = *p2++) != '\0';)
continue;
for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
continue;
/*
* Restart canonicalization at expanded "/xxx".
*/
p = sp - cp - 1 + newcp;
}
else {
newcp = Strspl(mlink, p);
/*
* Restart canonicalization at beginning
*/
p = newcp;
}
xfree(cp);
cp = newcp;
#ifdef HAVE_SLASHSLASH
slashslash = (cp[0] == '/' && cp[1] == '/');
#endif /* HAVE_SLASHSLASH */
continue; /* canonicalize the mlink */
}
#endif /* S_IFLNK */
if (slash)
*p = '/';
}
}
/*
* fix home...
*/
#ifdef S_IFLNK
p1 = varval(STRhome);
cc = Strlen(p1);
/*
* See if we're not in a subdir of STRhome
*/
if (p1 && *p1 == '/' && (Strncmp(p1, cp, cc) != 0 ||
(cp[cc] != '/' && cp[cc] != '\0'))) {
static ino_t home_ino = (ino_t) -1;
static dev_t home_dev = (dev_t) -1;
static Char *home_ptr = NULL;
struct stat statbuf;
int found;
Char *copy;
/*
* Get dev and ino of STRhome
*/
if (home_ptr != p1 &&
stat(short2str(p1), &statbuf) != -1) {
home_dev = statbuf.st_dev;
home_ino = statbuf.st_ino;
home_ptr = p1;
}
/*
* Start comparing dev & ino backwards
*/
p2 = copy = Strsave(cp);
found = 0;
while (*p2 && stat(short2str(p2), &statbuf) != -1) {
if (DEV_DEV_COMPARE(statbuf.st_dev, home_dev) &&
statbuf.st_ino == home_ino) {
found = 1;
break;
}
if ((sp = Strrchr(p2, '/')) != NULL)
*sp = '\0';
}
/*
* See if we found it
*/
if (*p2 && found) {
/*
* Use STRhome to make '~' work
*/
newcp = Strspl(p1, cp + Strlen(p2));
xfree(cp);
cp = newcp;
}
xfree(copy);
}
#endif /* S_IFLNK */
#ifdef HAVE_SLASHSLASH
if (slashslash) {
if (cp[1] != '/') {
p = xmalloc((Strlen(cp) + 2) * sizeof(Char));
*p = '/';
(void) Strcpy(&p[1], cp);
xfree(cp);
cp = p;
}
}
if (cp[1] == '/' && cp[2] == '/') {
for (p1 = &cp[1], p2 = &cp[2]; (*p1++ = *p2++) != '\0';)
continue;
}
#endif /* HAVE_SLASHSLASH */
return cp;
}
/* Wrapper for testing areadlink. */
static char *
do_areadlink (char const *name, size_t ignored _GL_UNUSED)
{
return areadlink (name);
}
