How can I follow and fully report on a chain of symlinks?

Question

What are the best tools/programming-techniques for following a complicated nesting of symlinks and completely capturing and reporting on every symlink along the way, including those in the middle of a path (See below for more info).

Here's a specific example. Consider the following output from a shell command

 ls -l /Library/Java/Home
 lrwxr-xr-x  1 root  admin  48 Feb 24 12:58 /Library/Java/Home -> /System/Library/Frameworks/JavaVM.framework/Home

The ls command lets you know that the file /Library/Java/Home file is a symlink to another location. However, it doesn't let you know that the thing it's pointing to is also a symlink

ls -l /System/Library/Frameworks/JavaVM.framework/Home
lrwxr-xr-x  1 root  wheel  24 Feb 24 12:58 /System/Library/Frameworks/JavaVM.framework/Home -> Versions/CurrentJDK/Home

This, in turn, doesn't let you know that part of the path of the pointed to file is a symlink.

ls -l /System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK
lrwxr-xr-x  1 root  wheel  3 Feb 24 12:58 /System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK -> 1.5

Which, just to complete this tale, is another symlink

ls -l /System/Library/Frameworks/JavaVM.framework/Versions/1.5
lrwxr-xr-x  1 root  wheel  5 Feb 24 12:58 /System/Library/Frameworks/JavaVM.framework/Versions/1.5 -> 1.5.0

Finally pointing at a "real" folder.

Are there any tools that can visualize the full chain of links for you in some way (either graphically or plain old text)? I'm sure one could script this themselves (and if you want to, please do it and share!), but it seems like the kind of thing that would be fraught with "oh, crap, edge case. Oh, crap, ANOTHER edge case". I'm hoping someone's already gone to the bother.

I do freelance/contract work, and everyone uses symlinks slightly differently to install their PHP applications on a web-server. Half my job is usually un-nesting this (inevitably) undocumented hierarchy so we know where to put our new code/modules.

Answer 1

If you just need to know the ultimate referent, php has the realpath function which can do that.

Answer 2

Tcl has a command [file type $filename] that will return "link" if it's a link. It has another command [file link $filename] that will return what the link points to. With those two commands it's possible to take a link and follow the links until you get to an actual file.

Perhaps something like this off the top of my head:

#!/usr/bin/tclsh

proc dereferenceLink {path {tree {}}} {
    if {[file type $path] == "link"} {
        set pointsTo [file link $path]
        if {[lsearch -exact $tree $path] >= 0} {
            lappend tree $path
            return "[join $tree ->] (circular reference)"
        } else {
            lappend tree $path
            return [dereferenceLink $pointsTo $tree]
        }
    } else {
        lappend tree $path
        return [join $tree "->"]
    }
}

puts [dereferenceLink [lindex $argv 0]]

You'll get output that looks like:

foo->bar->baz

If there's a circular link it will look like:

foo->bar->baz->foo (circular reference)

Answer 3

This python script would do it, if you added a single print inside the loop:

http://mail.python.org/pipermail/python-ideas/2007-December/001254.html

Answer 4

In PHP, you can use is_link and readlink.

Example usage:

function dereference_link($path) {
  $parts = array();
  foreach (explode(DIRECTORY_SEPARATOR, $path) as $part) {
    $parts[] = $part;
    $partial = implode(DIRECTORY_SEPARATOR, $parts);
    if (is_link($partial)) {
      $result = dereference_link(readlink($partial) . substr($path, strlen($partial)));
      array_unshift($result, $path);
      return $result;
    }
  }
  return array($path);
}