Determine whether a file is a junction (in Windows) or not?

Question

I've been searching around trying to find a way to determine if a file is a junction or not, and have not found any satisfactory answers.

First thing I tried was:

Files.isSymbolicLink(aPath)

It detects only symbolic links not the files referred to as junctions in Windows.

Also tried the solution proposed here (using JNA library): Stackoverflow question (3249117) , but it never returned true on any of the files I know to be junctions.

The only way I've found to determine which files are junctions is the following command run in windows command prompt:

DIR /S /A:L

On my computer it returns 66 folders, wheras Files.isSymbolicLink(aPath) returned only 2. So I suppose I could find a way to utilize this, but I don't think it would be very effiecient when traversing a filetree.

Is there any way to do this using the standard java library, or alternativly JNA?

Answer 1

There can be a way to do it without JNA, if you have the right java, such as Oracle jdk 8. It's dodgy, it can cease to work, but....

You can get BasicFileAttributes interface related to the link:

BasicFileAttributes attr = Files.readAttributes(path, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS);

It can happen that this interface implementation is a class sun.nio.fs.WindowsFileAttributes. And this class has a method isReparsePoint, which returns true for both junction points and symbolic links. So you can try to use reflection and call the method:

    boolean isReparsePoint = false;
    if (DosFileAttributes.class.isInstance(attr))
        try {
            Method m = attr.getClass().getDeclaredMethod("isReparsePoint");
            m.setAccessible(true);
            isReparsePoint = (boolean) m.invoke(attr);
        } catch (Exception e) {
            // just gave it a try
        }

Now you only can discover whether it really is symbolic link: Files.isSymbolicLink(path)

If its not, but it is reparse point, then that's junction.

Answer 2

If you can write native code in JNA, you can directly call the Win32 API GetFileAttributes() function and check for the FILE_ATTRIBUTE_REPARSE_POINT flag (junctions are implemented as reparse points).

Update: To differentiate between different types of reparse points, you have to retreive the ReparseTag of the actual reparse point. For a junction point, it will be set to IO_REPARSE_TAG_MOUNT_POINT (0xA0000003).

There are two ways to retreive the ReparseTag:

1. Use DeviceIoControl() with the FSCTL_GET_REPARSE_POINT control code to obtain an REPARSE_DATA_BUFFER struct, which as a ReparseTag field. You can see an example of an IsDirectoryJunction() implementation using this technique in the following article:

   NTFS Hard Links, Directory Junctions, and Windows Shortcuts

2. Use FindFirstFile() to obtain a WIN32_FIND_DATA struct. If the path has the FILE_ATTRIBUTE_REPARSE_POINT attribute, the dwReserved0 field will contain the ReparseTag.

Answer 3

With J2SE 1.7 use Java NIO

/**
* returns true if the Path is a Windows Junction
*/
private static boolean isJunction(Path p) {
    boolean isJunction = false;
    try {
        isJunction = (p.compareTo(p.toRealPath()) != 0);
    } catch (IOException e) {
        e.printStackTrace(); // TODO: handleMeProperly
    }
    return isJunction;
}

Answer 4

While on Windows a junction's attributes have isSymbolicLink() == false, they have isOther() == true. So you could do something like:

boolean isWindows = System.getProperty("os.name").toLowerCase().contains("windows")
BasicFileAttributes attrs = Files.readAttributes(aPath, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS);
boolean isJunction = isWindows && attrs.isDirectory() && attrs.isOther();

Answer 5

Black-Box Solution:

aPath.toRealPath() resolves junctions and symbolic links, so the result will deviate from aPath.

In addition BasicFileAttributes.isSymbolicLink() delivers false for junctions for non-documented reason:

E.g. Path.toRealPath(LinkOption.NOFOLLOW_LINKS) well treats a junction as link an does not resolve it!!

So by non-identity of toRealPath() and BasicFileAttributes.isSymbolicLink() you may identify a junction.

Answer 6

You can discover the link type with PowerShell with the command

(Get-Item -Path fileName -Force).LinkType

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;

class WindowsFileLinkUtils {

    public enum WindowsLinkType {
        JUNCTION("Junction"),
        HARD_LINK("HardLink"),
        SYMBOLIC_LINK("SymbolicLink");

        private final String key;

        WindowsLinkType(String key) {
            this.key = key;
        }

        public String getKey() {
            return key;
        }
    }

    private static final String CREATE_JUNCTION_COMMAND = "(Get-Item -Path %s -Force).LinkType";

    public static Optional<WindowsLinkType> getLinkType(Path path) throws IOException, InterruptedException {
        ProcessBuilder processBuilder = createIsJunctionProcessBuilder(path);
        Process process = processBuilder.start();
        process.waitFor();

        try (BufferedReader inStreamReader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
            String output = inStreamReader.readLine();
            return Arrays.stream(WindowsLinkType.values()).filter(windowsLinkType -> windowsLinkType.getKey().equals(output)).findFirst();
        }
    }

    private static ProcessBuilder createIsJunctionProcessBuilder(Path target) {
        ProcessBuilder processBuilder = new ProcessBuilder();
        List<String> arguments = processBuilder.command();
        arguments.add("powershell.exe");

        arguments.add(String.format(CREATE_JUNCTION_COMMAND, target.toString()));
        return processBuilder;
    }

    private WindowsFileLinkUtils() {
    }
}