src/windows/classes/sun/nio/fs/WindowsLinkSupport.java - toolchain/jdk/jdk9_jdk - Git at Google

 /*
  * Copyright (c) 2008, 2009, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package sun.nio.fs;

 import java.nio.file.*;
 import java.io.IOException;
 import java.io.IOError;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import sun.misc.Unsafe;

 import static sun.nio.fs.WindowsNativeDispatcher.*;
 import static sun.nio.fs.WindowsConstants.*;

 /**
  * Utility methods for symbolic link support on Windows Vista and newer.
  */

 class WindowsLinkSupport {
     private static final Unsafe unsafe = Unsafe.getUnsafe();

     private WindowsLinkSupport() {
     }

     /**
      * Returns the target of a symbolic link
      */
     static String readLink(WindowsPath path) throws IOException {
         long handle = 0L;
         try {
             handle = path.openForReadAttributeAccess(false); // don't follow links
         } catch (WindowsException x) {
             x.rethrowAsIOException(path);
         }
         try {
             return readLinkImpl(handle);
         } finally {
             CloseHandle(handle);
         }
     }

     /**
      * Returns the final path (all symbolic links resolved) or null if this
      * operation is not supported.
      */
     private static String getFinalPath(WindowsPath input) throws IOException {
         long h = 0;
         try {
             h = input.openForReadAttributeAccess(true);
         } catch (WindowsException x) {
             x.rethrowAsIOException(input);
         }
         try {
             return stripPrefix(GetFinalPathNameByHandle(h));
         } catch (WindowsException x) {
             // ERROR_INVALID_LEVEL is the error returned when not supported
             // (a sym link to file on FAT32 or Samba server for example)
             if (x.lastError() != ERROR_INVALID_LEVEL)
                 x.rethrowAsIOException(input);
         } finally {
             CloseHandle(h);
         }
         return null;
     }

     /**
      * Returns the final path of a given path as a String. This should be used
      * prior to calling Win32 system calls that do not follow links.
      */
     static String getFinalPath(WindowsPath input, boolean followLinks)
         throws IOException
     {
         WindowsFileSystem fs = input.getFileSystem();
         try {
             // if not following links then don't need final path
             if (!followLinks || !fs.supportsLinks())
                 return input.getPathForWin32Calls();

             // if file is not a sym link then don't need final path
             if (!WindowsFileAttributes.get(input, false).isSymbolicLink()) {
                 return input.getPathForWin32Calls();
             }
         } catch (WindowsException x) {
             x.rethrowAsIOException(input);
         }

         // The file is a symbolic link so attempt to get the final path
         String result = getFinalPath(input);
         if (result != null)
             return result;

         // Fallback: read target of link, resolve against parent, and repeat
         // until file is not a link.
         WindowsPath target = input;
         int linkCount = 0;
         do {
             try {
                 WindowsFileAttributes attrs =
                     WindowsFileAttributes.get(target, false);
                 // non a link so we are done
                 if (!attrs.isSymbolicLink()) {
                     return target.getPathForWin32Calls();
                 }
             } catch (WindowsException x) {
                 x.rethrowAsIOException(target);
             }
             WindowsPath link = WindowsPath
                 .createFromNormalizedPath(fs, readLink(target));
             WindowsPath parent = target.getParent();
             if (parent == null) {
                 // no parent so use parent of absolute path
                 final WindowsPath t = target;
                 target = AccessController
                     .doPrivileged(new PrivilegedAction<WindowsPath>() {
                         @Override
                         public WindowsPath run() {
                             return t.toAbsolutePath();
                         }});
                 parent = target.getParent();
             }
             target = parent.resolve(link);

         } while (++linkCount < 32);

         throw new FileSystemException(input.getPathForExceptionMessage(), null,
             "Too many links");
     }

     /**
      * Returns the actual path of a file, optionally resolving all symbolic
      * links.
      */
     static String getRealPath(WindowsPath input, boolean resolveLinks)
         throws IOException
     {
         WindowsFileSystem fs = input.getFileSystem();
         if (resolveLinks && !fs.supportsLinks())
             resolveLinks = false;

         // Start with absolute path
         String path = null;
         try {
             path = input.toAbsolutePath().toString();
         } catch (IOError x) {
             throw (IOException)(x.getCause());
         }

         // Collapse "." and ".."
         if (path.indexOf('.') >= 0) {
             try {
                 path = GetFullPathName(path);
             } catch (WindowsException x) {
                 x.rethrowAsIOException(input);
             }
         }

         // string builder to build up components of path
         StringBuilder sb = new StringBuilder(path.length());

         // Copy root component
         int start;
         char c0 = path.charAt(0);
         char c1 = path.charAt(1);
         if ((c0 <= 'z' && c0 >= 'a' || c0 <= 'Z' && c0 >= 'A') &&
             c1 == ':' && path.charAt(2) == '\\') {
             // Driver specifier
             sb.append(Character.toUpperCase(c0));
             sb.append(":\\");
             start = 3;
         } else if (c0 == '\\' && c1 == '\\') {
             // UNC pathname, begins with "\\\\host\\share"
             int last = path.length() - 1;
             int pos = path.indexOf('\\', 2);
             // skip both server and share names
             if (pos == -1 || (pos == last)) {
                 // The UNC does not have a share name (collapsed by GetFullPathName)
                 throw new FileSystemException(input.getPathForExceptionMessage(),
                     null, "UNC has invalid share");
             }
             pos = path.indexOf('\\', pos+1);
             if (pos < 0) {
                 pos = last;
                 sb.append(path).append("\\");
             } else {
                 sb.append(path, 0, pos+1);
             }
             start = pos + 1;
         } else {
             throw new AssertionError("path type not recognized");
         }

         // if the result is only a root component then we simply check it exists
         if (start >= path.length()) {
             String result = sb.toString();
             try {
                 GetFileAttributes(result);
             } catch (WindowsException x) {
                 x.rethrowAsIOException(path);
             }
             return result;
         }

         // iterate through each component to get its actual name in the
         // directory
         int curr = start;
         while (curr < path.length()) {
             int next = path.indexOf('\\', curr);
             int end = (next == -1) ? path.length() : next;
             String search = sb.toString() + path.substring(curr, end);
             try {
                 FirstFile fileData = FindFirstFile(addLongPathPrefixIfNeeded(search));
                 FindClose(fileData.handle());

                 // if a reparse point is encountered then we must return the
                 // final path.
                 if (resolveLinks &&
                     WindowsFileAttributes.isReparsePoint(fileData.attributes()))
                 {
                     String result = getFinalPath(input);
                     if (result == null) {
                         // Fallback to slow path, usually because there is a sym
                         // link to a file system that doesn't support sym links.
                         WindowsPath resolved = resolveAllLinks(
                             WindowsPath.createFromNormalizedPath(fs, path));
                         result = getRealPath(resolved, false);
                     }
                     return result;
                 }

                 // add the name to the result
                 sb.append(fileData.name());
                 if (next != -1) {
                     sb.append('\\');
                 }
             } catch (WindowsException e) {
                 e.rethrowAsIOException(path);
             }
             curr = end + 1;
         }

         return sb.toString();
     }

     /**
      * Returns target of a symbolic link given the handle of an open file
      * (that should be a link).
      */
     private static String readLinkImpl(long handle) throws IOException {
         int size = MAXIMUM_REPARSE_DATA_BUFFER_SIZE;
         NativeBuffer buffer = NativeBuffers.getNativeBuffer(size);
         try {
             try {
                 DeviceIoControlGetReparsePoint(handle, buffer.address(), size);
             } catch (WindowsException x) {
                 // FIXME: exception doesn't have file name
                 if (x.lastError() == ERROR_NOT_A_REPARSE_POINT)
                     throw new NotLinkException(null, null, x.errorString());
                 x.rethrowAsIOException((String)null);
             }

             /*
              * typedef struct _REPARSE_DATA_BUFFER {
              *     ULONG  ReparseTag;
              *     USHORT  ReparseDataLength;
              *     USHORT  Reserved;
              *     union {
              *         struct {
              *             USHORT  SubstituteNameOffset;
              *             USHORT  SubstituteNameLength;
              *             USHORT  PrintNameOffset;
              *             USHORT  PrintNameLength;
              *             WCHAR  PathBuffer[1];
              *         } SymbolicLinkReparseBuffer;
              *         struct {
              *             USHORT  SubstituteNameOffset;
              *             USHORT  SubstituteNameLength;
              *             USHORT  PrintNameOffset;
              *             USHORT  PrintNameLength;
              *             WCHAR  PathBuffer[1];
              *         } MountPointReparseBuffer;
              *         struct {
              *             UCHAR  DataBuffer[1];
              *         } GenericReparseBuffer;
              *     };
              * } REPARSE_DATA_BUFFER
              */
             final short OFFSETOF_REPARSETAG = 0;
             final short OFFSETOF_PATHOFFSET = 8;
             final short OFFSETOF_PATHLENGTH = 10;
             final short OFFSETOF_PATHBUFFER = 16 + 4;   // check this

             int tag = (int)unsafe.getLong(buffer.address() + OFFSETOF_REPARSETAG);
             if (tag != IO_REPARSE_TAG_SYMLINK) {
                 // FIXME: exception doesn't have file name
                 throw new NotLinkException(null, null, "Reparse point is not a symbolic link");
             }

             // get offset and length of target
             short nameOffset = unsafe.getShort(buffer.address() + OFFSETOF_PATHOFFSET);
             short nameLengthInBytes = unsafe.getShort(buffer.address() + OFFSETOF_PATHLENGTH);
             if ((nameLengthInBytes % 2) != 0)
                 throw new FileSystemException(null, null, "Symbolic link corrupted");

             // copy into char array
             char[] name = new char[nameLengthInBytes/2];
             unsafe.copyMemory(null, buffer.address() + OFFSETOF_PATHBUFFER + nameOffset,
                 name, Unsafe.ARRAY_CHAR_BASE_OFFSET, nameLengthInBytes);

             // remove special prefix
             String target = stripPrefix(new String(name));
             if (target.length() == 0) {
                 throw new IOException("Symbolic link target is invalid");
             }
             return target;
         } finally {
             buffer.release();
         }
     }

     /**
      * Resolve all symbolic-links in a given absolute and normalized path
      */
     private static WindowsPath resolveAllLinks(WindowsPath path)
         throws IOException
     {
         assert path.isAbsolute();
         WindowsFileSystem fs = path.getFileSystem();

         // iterate through each name element of the path, resolving links as
         // we go.
         int linkCount = 0;
         int elem = 0;
         while (elem < path.getNameCount()) {
             WindowsPath current = path.getRoot().resolve(path.subpath(0, elem+1));

             WindowsFileAttributes attrs = null;
             try {
                 attrs = WindowsFileAttributes.get(current, false);
             } catch (WindowsException x) {
                 x.rethrowAsIOException(current);
             }

             /**
              * If a symbolic link then we resolve it against the parent
              * of the current name element. We then resolve any remaining
              * part of the path against the result. The target of the link
              * may have "." and ".." components so re-normalize and restart
              * the process from the first element.
              */
             if (attrs.isSymbolicLink()) {
                 linkCount++;
                 if (linkCount > 32)
                     throw new IOException("Too many links");
                 WindowsPath target = WindowsPath
                     .createFromNormalizedPath(fs, readLink(current));
                 WindowsPath remainder = null;
                 int count = path.getNameCount();
                 if ((elem+1) < count) {
                     remainder = path.subpath(elem+1, count);
                 }
                 path = current.getParent().resolve(target);
                 try {
                     String full = GetFullPathName(path.toString());
                     if (!full.equals(path.toString())) {
                         path = WindowsPath.createFromNormalizedPath(fs, full);
                     }
                 } catch (WindowsException x) {
                     x.rethrowAsIOException(path);
                 }
                 if (remainder != null) {
                     path = path.resolve(remainder);
                 }

                 // reset
                 elem = 0;
             } else {
                 // not a link
                 elem++;
             }
         }

         return path;
     }

     /**
      * Add long path prefix to path if required.
      */
     private static String addLongPathPrefixIfNeeded(String path) {
         if (path.length() > 248) {
             if (path.startsWith("\\\\")) {
                 path = "\\\\?\\UNC" + path.substring(1, path.length());
             } else {
                 path = "\\\\?\\" + path;
             }
         }
         return path;
     }

     /**
      * Strip long path or symbolic link prefix from path
      */
     private static String stripPrefix(String path) {
         // prefix for resolved/long path
         if (path.startsWith("\\\\?\\")) {
             if (path.startsWith("\\\\?\\UNC\\")) {
                 path = "\\" + path.substring(7);
             } else {
                 path = path.substring(4);
             }
             return path;
         }

         // prefix for target of symbolic link
         if (path.startsWith("\\??\\")) {
             if (path.startsWith("\\??\\UNC\\")) {
                 path = "\\" + path.substring(7);
             } else {
                 path = path.substring(4);
             }
             return path;
         }
         return path;
     }
 }
	/*
	* Copyright (c) 2008, 2009, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.nio.fs;

	import java.nio.file.*;
	import java.io.IOException;
	import java.io.IOError;
	import java.security.AccessController;
	import java.security.PrivilegedAction;
	import sun.misc.Unsafe;

	import static sun.nio.fs.WindowsNativeDispatcher.*;
	import static sun.nio.fs.WindowsConstants.*;

	/**
	* Utility methods for symbolic link support on Windows Vista and newer.
	*/

	class WindowsLinkSupport {
	private static final Unsafe unsafe = Unsafe.getUnsafe();

	private WindowsLinkSupport() {
	}

	/**
	* Returns the target of a symbolic link
	*/
	static String readLink(WindowsPath path) throws IOException {
	long handle = 0L;
	try {
	handle = path.openForReadAttributeAccess(false); // don't follow links
	} catch (WindowsException x) {
	x.rethrowAsIOException(path);
	}
	try {
	return readLinkImpl(handle);
	} finally {
	CloseHandle(handle);
	}
	}

	/**
	* Returns the final path (all symbolic links resolved) or null if this
	* operation is not supported.
	*/
	private static String getFinalPath(WindowsPath input) throws IOException {
	long h = 0;
	try {
	h = input.openForReadAttributeAccess(true);
	} catch (WindowsException x) {
	x.rethrowAsIOException(input);
	}
	try {
	return stripPrefix(GetFinalPathNameByHandle(h));
	} catch (WindowsException x) {
	// ERROR_INVALID_LEVEL is the error returned when not supported
	// (a sym link to file on FAT32 or Samba server for example)
	if (x.lastError() != ERROR_INVALID_LEVEL)
	x.rethrowAsIOException(input);
	} finally {
	CloseHandle(h);
	}
	return null;
	}

	/**
	* Returns the final path of a given path as a String. This should be used
	* prior to calling Win32 system calls that do not follow links.
	*/
	static String getFinalPath(WindowsPath input, boolean followLinks)
	throws IOException
	{
	WindowsFileSystem fs = input.getFileSystem();
	try {
	// if not following links then don't need final path
	if (!followLinks \|\| !fs.supportsLinks())
	return input.getPathForWin32Calls();

	// if file is not a sym link then don't need final path
	if (!WindowsFileAttributes.get(input, false).isSymbolicLink()) {
	return input.getPathForWin32Calls();
	}
	} catch (WindowsException x) {
	x.rethrowAsIOException(input);
	}

	// The file is a symbolic link so attempt to get the final path
	String result = getFinalPath(input);
	if (result != null)
	return result;

	// Fallback: read target of link, resolve against parent, and repeat
	// until file is not a link.
	WindowsPath target = input;
	int linkCount = 0;
	do {
	try {
	WindowsFileAttributes attrs =
	WindowsFileAttributes.get(target, false);
	// non a link so we are done
	if (!attrs.isSymbolicLink()) {
	return target.getPathForWin32Calls();
	}
	} catch (WindowsException x) {
	x.rethrowAsIOException(target);
	}
	WindowsPath link = WindowsPath
	.createFromNormalizedPath(fs, readLink(target));
	WindowsPath parent = target.getParent();
	if (parent == null) {
	// no parent so use parent of absolute path
	final WindowsPath t = target;
	target = AccessController
	.doPrivileged(new PrivilegedAction<WindowsPath>() {
	@Override
	public WindowsPath run() {
	return t.toAbsolutePath();
	}});
	parent = target.getParent();
	}
	target = parent.resolve(link);

	} while (++linkCount < 32);

	throw new FileSystemException(input.getPathForExceptionMessage(), null,
	"Too many links");
	}

	/**
	* Returns the actual path of a file, optionally resolving all symbolic
	* links.
	*/
	static String getRealPath(WindowsPath input, boolean resolveLinks)
	throws IOException
	{
	WindowsFileSystem fs = input.getFileSystem();
	if (resolveLinks && !fs.supportsLinks())
	resolveLinks = false;

	// Start with absolute path
	String path = null;
	try {
	path = input.toAbsolutePath().toString();
	} catch (IOError x) {
	throw (IOException)(x.getCause());
	}

	// Collapse "." and ".."
	if (path.indexOf('.') >= 0) {
	try {
	path = GetFullPathName(path);
	} catch (WindowsException x) {
	x.rethrowAsIOException(input);
	}
	}

	// string builder to build up components of path
	StringBuilder sb = new StringBuilder(path.length());

	// Copy root component
	int start;
	char c0 = path.charAt(0);
	char c1 = path.charAt(1);
	if ((c0 <= 'z' && c0 >= 'a' \|\| c0 <= 'Z' && c0 >= 'A') &&
	c1 == ':' && path.charAt(2) == '\\') {
	// Driver specifier
	sb.append(Character.toUpperCase(c0));
	sb.append(":\\");
	start = 3;
	} else if (c0 == '\\' && c1 == '\\') {
	// UNC pathname, begins with "\\\\host\\share"
	int last = path.length() - 1;
	int pos = path.indexOf('\\', 2);
	// skip both server and share names
	if (pos == -1 \|\| (pos == last)) {
	// The UNC does not have a share name (collapsed by GetFullPathName)
	throw new FileSystemException(input.getPathForExceptionMessage(),
	null, "UNC has invalid share");
	}
	pos = path.indexOf('\\', pos+1);
	if (pos < 0) {
	pos = last;
	sb.append(path).append("\\");
	} else {
	sb.append(path, 0, pos+1);
	}
	start = pos + 1;
	} else {
	throw new AssertionError("path type not recognized");
	}

	// if the result is only a root component then we simply check it exists
	if (start >= path.length()) {
	String result = sb.toString();
	try {
	GetFileAttributes(result);
	} catch (WindowsException x) {
	x.rethrowAsIOException(path);
	}
	return result;
	}

	// iterate through each component to get its actual name in the
	// directory
	int curr = start;
	while (curr < path.length()) {
	int next = path.indexOf('\\', curr);
	int end = (next == -1) ? path.length() : next;
	String search = sb.toString() + path.substring(curr, end);
	try {
	FirstFile fileData = FindFirstFile(addLongPathPrefixIfNeeded(search));
	FindClose(fileData.handle());

	// if a reparse point is encountered then we must return the
	// final path.
	if (resolveLinks &&
	WindowsFileAttributes.isReparsePoint(fileData.attributes()))
	{
	String result = getFinalPath(input);
	if (result == null) {
	// Fallback to slow path, usually because there is a sym
	// link to a file system that doesn't support sym links.
	WindowsPath resolved = resolveAllLinks(
	WindowsPath.createFromNormalizedPath(fs, path));
	result = getRealPath(resolved, false);
	}
	return result;
	}

	// add the name to the result
	sb.append(fileData.name());
	if (next != -1) {
	sb.append('\\');
	}
	} catch (WindowsException e) {
	e.rethrowAsIOException(path);
	}
	curr = end + 1;
	}

	return sb.toString();
	}

	/**
	* Returns target of a symbolic link given the handle of an open file
	* (that should be a link).
	*/
	private static String readLinkImpl(long handle) throws IOException {
	int size = MAXIMUM_REPARSE_DATA_BUFFER_SIZE;
	NativeBuffer buffer = NativeBuffers.getNativeBuffer(size);
	try {
	try {
	DeviceIoControlGetReparsePoint(handle, buffer.address(), size);
	} catch (WindowsException x) {
	// FIXME: exception doesn't have file name
	if (x.lastError() == ERROR_NOT_A_REPARSE_POINT)
	throw new NotLinkException(null, null, x.errorString());
	x.rethrowAsIOException((String)null);
	}

	/*
	* typedef struct _REPARSE_DATA_BUFFER {
	* ULONG ReparseTag;
	* USHORT ReparseDataLength;
	* USHORT Reserved;
	* union {
	* struct {
	* USHORT SubstituteNameOffset;
	* USHORT SubstituteNameLength;
	* USHORT PrintNameOffset;
	* USHORT PrintNameLength;
	* WCHAR PathBuffer[1];
	* } SymbolicLinkReparseBuffer;
	* struct {
	* USHORT SubstituteNameOffset;
	* USHORT SubstituteNameLength;
	* USHORT PrintNameOffset;
	* USHORT PrintNameLength;
	* WCHAR PathBuffer[1];
	* } MountPointReparseBuffer;
	* struct {
	* UCHAR DataBuffer[1];
	* } GenericReparseBuffer;
	* };
	* } REPARSE_DATA_BUFFER
	*/
	final short OFFSETOF_REPARSETAG = 0;
	final short OFFSETOF_PATHOFFSET = 8;
	final short OFFSETOF_PATHLENGTH = 10;
	final short OFFSETOF_PATHBUFFER = 16 + 4; // check this

	int tag = (int)unsafe.getLong(buffer.address() + OFFSETOF_REPARSETAG);
	if (tag != IO_REPARSE_TAG_SYMLINK) {
	// FIXME: exception doesn't have file name
	throw new NotLinkException(null, null, "Reparse point is not a symbolic link");
	}

	// get offset and length of target
	short nameOffset = unsafe.getShort(buffer.address() + OFFSETOF_PATHOFFSET);
	short nameLengthInBytes = unsafe.getShort(buffer.address() + OFFSETOF_PATHLENGTH);
	if ((nameLengthInBytes % 2) != 0)
	throw new FileSystemException(null, null, "Symbolic link corrupted");

	// copy into char array
	char[] name = new char[nameLengthInBytes/2];
	unsafe.copyMemory(null, buffer.address() + OFFSETOF_PATHBUFFER + nameOffset,
	name, Unsafe.ARRAY_CHAR_BASE_OFFSET, nameLengthInBytes);

	// remove special prefix
	String target = stripPrefix(new String(name));
	if (target.length() == 0) {
	throw new IOException("Symbolic link target is invalid");
	}
	return target;
	} finally {
	buffer.release();
	}
	}

	/**
	* Resolve all symbolic-links in a given absolute and normalized path
	*/
	private static WindowsPath resolveAllLinks(WindowsPath path)
	throws IOException
	{
	assert path.isAbsolute();
	WindowsFileSystem fs = path.getFileSystem();

	// iterate through each name element of the path, resolving links as
	// we go.
	int linkCount = 0;
	int elem = 0;
	while (elem < path.getNameCount()) {
	WindowsPath current = path.getRoot().resolve(path.subpath(0, elem+1));

	WindowsFileAttributes attrs = null;
	try {
	attrs = WindowsFileAttributes.get(current, false);
	} catch (WindowsException x) {
	x.rethrowAsIOException(current);
	}

	/**
	* If a symbolic link then we resolve it against the parent
	* of the current name element. We then resolve any remaining
	* part of the path against the result. The target of the link
	* may have "." and ".." components so re-normalize and restart
	* the process from the first element.
	*/
	if (attrs.isSymbolicLink()) {
	linkCount++;
	if (linkCount > 32)
	throw new IOException("Too many links");
	WindowsPath target = WindowsPath
	.createFromNormalizedPath(fs, readLink(current));
	WindowsPath remainder = null;
	int count = path.getNameCount();
	if ((elem+1) < count) {
	remainder = path.subpath(elem+1, count);
	}
	path = current.getParent().resolve(target);
	try {
	String full = GetFullPathName(path.toString());
	if (!full.equals(path.toString())) {
	path = WindowsPath.createFromNormalizedPath(fs, full);
	}
	} catch (WindowsException x) {
	x.rethrowAsIOException(path);
	}
	if (remainder != null) {
	path = path.resolve(remainder);
	}

	// reset
	elem = 0;
	} else {
	// not a link
	elem++;
	}
	}

	return path;
	}

	/**
	* Add long path prefix to path if required.
	*/
	private static String addLongPathPrefixIfNeeded(String path) {
	if (path.length() > 248) {
	if (path.startsWith("\\\\")) {
	path = "\\\\?\\UNC" + path.substring(1, path.length());
	} else {
	path = "\\\\?\\" + path;
	}
	}
	return path;
	}

	/**
	* Strip long path or symbolic link prefix from path
	*/
	private static String stripPrefix(String path) {
	// prefix for resolved/long path
	if (path.startsWith("\\\\?\\")) {
	if (path.startsWith("\\\\?\\UNC\\")) {
	path = "\\" + path.substring(7);
	} else {
	path = path.substring(4);
	}
	return path;
	}

	// prefix for target of symbolic link
	if (path.startsWith("\\??\\")) {
	if (path.startsWith("\\??\\UNC\\")) {
	path = "\\" + path.substring(7);
	} else {
	path = path.substring(4);
	}
	return path;
	}
	return path;
	}
	}