diff --git a/src/share/classes/java/nio/file/Path.java b/src/share/classes/java/nio/file/Path.java index 618f0226363a530da3e20d809e8c3527048b6544..cefd2d2fd04d29e685f91dd4e462323846bbb3d9 100644 --- a/src/share/classes/java/nio/file/Path.java +++ b/src/share/classes/java/nio/file/Path.java @@ -550,18 +550,21 @@ public interface Path *

If this path is relative then its absolute path is first obtained, * as if by invoking the {@link #toAbsolutePath toAbsolutePath} method. * - *

The {@code resolveLinks} parameter specifies if symbolic links - * should be resolved. This parameter is ignored when symbolic links are - * not supported. Where supported, and the parameter has the value {@code - * true} then symbolic links are resolved to their final target. Where the - * parameter has the value {@code false} then this method does not resolve - * symbolic links. Some implementations allow special names such as - * "{@code ..}" to refer to the parent directory. When deriving the real - * path, and a "{@code ..}" (or equivalent) is preceded by a - * non-"{@code ..}" name then an implementation will typically causes both - * names to be removed. When not resolving symbolic links and the preceding - * name is a symbolic link then the names are only removed if it guaranteed - * that the resulting path will locate the same file as this path. + *

The {@code options} array may be used to indicate how symbolic links + * are handled. By default, symbolic links are resolved to their final + * target. If the option {@link LinkOption#NOFOLLOW_LINKS NOFOLLOW_LINKS} is + * present then this method does not resolve symbolic links. + * + * Some implementations allow special names such as "{@code ..}" to refer to + * the parent directory. When deriving the real path, and a + * "{@code ..}" (or equivalent) is preceded by a non-"{@code ..}" name then + * an implementation will typically cause both names to be removed. When + * not resolving symbolic links and the preceding name is a symbolic link + * then the names are only removed if it guaranteed that the resulting path + * will locate the same file as this path. + * + * @param options + * options indicating how symbolic links are handled * * @return an absolute path represent the real path of the file * located by this object @@ -576,7 +579,7 @@ public interface Path * checkPropertyAccess} method is invoked to check access to the * system property {@code user.dir} */ - Path toRealPath(boolean resolveLinks) throws IOException; + Path toRealPath(LinkOption... options) throws IOException; /** * Returns a {@link File} object representing this path. Where this {@code diff --git a/src/share/classes/sun/nio/fs/Util.java b/src/share/classes/sun/nio/fs/Util.java index 7628701116964fdd8980eb4ee9acfdfd53111bfb..6c94710dd8d68482f05b3ba99849831cbaed9fad 100644 --- a/src/share/classes/sun/nio/fs/Util.java +++ b/src/share/classes/sun/nio/fs/Util.java @@ -26,6 +26,7 @@ package sun.nio.fs; import java.util.*; +import java.nio.file.*; /** * Utility methods @@ -80,4 +81,21 @@ class Util { } return set; } + + /** + * Returns {@code true} if symbolic links should be followed + */ + static boolean followLinks(LinkOption... options) { + boolean followLinks = true; + for (LinkOption option: options) { + if (option == LinkOption.NOFOLLOW_LINKS) { + followLinks = false; + } else if (option == null) { + throw new NullPointerException(); + } else { + throw new AssertionError("Should not get here"); + } + } + return followLinks; + } } diff --git a/src/share/classes/sun/util/calendar/ZoneInfoFile.java b/src/share/classes/sun/util/calendar/ZoneInfoFile.java index c6251ade5122e4bb6675e26a5ef3f0a33fcb8d29..891817776aaeb72d435b5dcd94ff068f541aae85 100644 --- a/src/share/classes/sun/util/calendar/ZoneInfoFile.java +++ b/src/share/classes/sun/util/calendar/ZoneInfoFile.java @@ -479,7 +479,7 @@ public class ZoneInfoFile { String zi = System.getProperty("java.home") + File.separator + "lib" + File.separator + "zi"; try { - zi = FileSystems.getDefault().getPath(zi).toRealPath(true).toString(); + zi = FileSystems.getDefault().getPath(zi).toRealPath().toString(); } catch(Exception e) { } return zi; diff --git a/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystemProvider.java b/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystemProvider.java index d8aa305d29b1ab1be0913966f75656406d3a6a54..530c8864ba61d02ecd6370ef42d53fc9577cf1ae 100644 --- a/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystemProvider.java +++ b/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipFileSystemProvider.java @@ -99,7 +99,7 @@ public class ZipFileSystemProvider extends FileSystemProvider { synchronized(filesystems) { Path realPath = null; if (ensureFile(path)) { - realPath = path.toRealPath(true); + realPath = path.toRealPath(); if (filesystems.containsKey(realPath)) throw new FileSystemAlreadyExistsException(); } @@ -154,7 +154,7 @@ public class ZipFileSystemProvider extends FileSystemProvider { synchronized (filesystems) { ZipFileSystem zipfs = null; try { - zipfs = filesystems.get(uriToPath(uri).toRealPath(true)); + zipfs = filesystems.get(uriToPath(uri).toRealPath()); } catch (IOException x) { // ignore the ioe from toRealPath(), return FSNFE } @@ -310,7 +310,7 @@ public class ZipFileSystemProvider extends FileSystemProvider { ////////////////////////////////////////////////////////////// void removeFileSystem(Path zfpath, ZipFileSystem zfs) throws IOException { synchronized (filesystems) { - zfpath = zfpath.toRealPath(true); + zfpath = zfpath.toRealPath(); if (filesystems.get(zfpath) == zfs) filesystems.remove(zfpath); } diff --git a/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipPath.java b/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipPath.java index 1232a27ff1f0b2c1f0d1cb9d6307854a5e22e630..8c97818b24482f3fde4f129a7f46185054d041e7 100644 --- a/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipPath.java +++ b/src/share/demo/nio/zipfs/src/com/sun/nio/zipfs/ZipPath.java @@ -150,7 +150,7 @@ public class ZipPath implements Path { } @Override - public ZipPath toRealPath(boolean resolveLinks) throws IOException { + public ZipPath toRealPath(LinkOption... options) throws IOException { ZipPath realPath = new ZipPath(zfs, getResolvedPath()).toAbsolutePath(); realPath.checkAccess(); return realPath; diff --git a/src/solaris/classes/sun/nio/fs/LinuxFileSystemProvider.java b/src/solaris/classes/sun/nio/fs/LinuxFileSystemProvider.java index 6659ff5ede48f5871524e7697db056d53b87df54..0b8aa14e1882b1a57f43561dc716c9e16c59a795 100644 --- a/src/solaris/classes/sun/nio/fs/LinuxFileSystemProvider.java +++ b/src/solaris/classes/sun/nio/fs/LinuxFileSystemProvider.java @@ -56,11 +56,11 @@ public class LinuxFileSystemProvider extends UnixFileSystemProvider { { if (type == DosFileAttributeView.class) { return (V) new LinuxDosFileAttributeView(UnixPath.toUnixPath(obj), - followLinks(options)); + Util.followLinks(options)); } if (type == UserDefinedFileAttributeView.class) { return (V) new LinuxUserDefinedFileAttributeView(UnixPath.toUnixPath(obj), - followLinks(options)); + Util.followLinks(options)); } return super.getFileAttributeView(obj, type, options); } @@ -72,11 +72,11 @@ public class LinuxFileSystemProvider extends UnixFileSystemProvider { { if (name.equals("dos")) { return new LinuxDosFileAttributeView(UnixPath.toUnixPath(obj), - followLinks(options)); + Util.followLinks(options)); } if (name.equals("user")) { return new LinuxUserDefinedFileAttributeView(UnixPath.toUnixPath(obj), - followLinks(options)); + Util.followLinks(options)); } return super.getFileAttributeView(obj, name, options); } diff --git a/src/solaris/classes/sun/nio/fs/SolarisFileSystemProvider.java b/src/solaris/classes/sun/nio/fs/SolarisFileSystemProvider.java index 98c3ae8699ca580bf37a26b26a7e763f649be1e9..eca619be1d0dfbe21cdd84aa674eda8d58b05361 100644 --- a/src/solaris/classes/sun/nio/fs/SolarisFileSystemProvider.java +++ b/src/solaris/classes/sun/nio/fs/SolarisFileSystemProvider.java @@ -57,11 +57,11 @@ public class SolarisFileSystemProvider extends UnixFileSystemProvider { { if (type == AclFileAttributeView.class) { return (V) new SolarisAclFileAttributeView(UnixPath.toUnixPath(obj), - followLinks(options)); + Util.followLinks(options)); } if (type == UserDefinedFileAttributeView.class) { return(V) new SolarisUserDefinedFileAttributeView(UnixPath.toUnixPath(obj), - followLinks(options)); + Util.followLinks(options)); } return super.getFileAttributeView(obj, type, options); } @@ -73,10 +73,10 @@ public class SolarisFileSystemProvider extends UnixFileSystemProvider { { if (name.equals("acl")) return new SolarisAclFileAttributeView(UnixPath.toUnixPath(obj), - followLinks(options)); + Util.followLinks(options)); if (name.equals("user")) return new SolarisUserDefinedFileAttributeView(UnixPath.toUnixPath(obj), - followLinks(options)); + Util.followLinks(options)); return super.getFileAttributeView(obj, name, options); } } diff --git a/src/solaris/classes/sun/nio/fs/UnixFileSystemProvider.java b/src/solaris/classes/sun/nio/fs/UnixFileSystemProvider.java index 8ec672a306bbca65911ae715730de5aa6effeff5..1bee2d0b3860e3d60477ef52b9427c1bb5d0630b 100644 --- a/src/solaris/classes/sun/nio/fs/UnixFileSystemProvider.java +++ b/src/solaris/classes/sun/nio/fs/UnixFileSystemProvider.java @@ -105,20 +105,6 @@ public abstract class UnixFileSystemProvider return (UnixPath)obj; } - boolean followLinks(LinkOption... options) { - boolean followLinks = true; - for (LinkOption option: options) { - if (option == LinkOption.NOFOLLOW_LINKS) { - followLinks = false; - continue; - } - if (option == null) - throw new NullPointerException(); - throw new AssertionError("Should not get here"); - } - return followLinks; - } - @Override @SuppressWarnings("unchecked") public V getFileAttributeView(Path obj, @@ -126,7 +112,7 @@ public abstract class UnixFileSystemProvider LinkOption... options) { UnixPath file = UnixPath.toUnixPath(obj); - boolean followLinks = followLinks(options); + boolean followLinks = Util.followLinks(options); if (type == BasicFileAttributeView.class) return (V) UnixFileAttributeViews.createBasicView(file, followLinks); if (type == PosixFileAttributeView.class) @@ -163,7 +149,7 @@ public abstract class UnixFileSystemProvider LinkOption... options) { UnixPath file = UnixPath.toUnixPath(obj); - boolean followLinks = followLinks(options); + boolean followLinks = Util.followLinks(options); if (name.equals("basic")) return UnixFileAttributeViews.createBasicView(file, followLinks); if (name.equals("posix")) diff --git a/src/solaris/classes/sun/nio/fs/UnixPath.java b/src/solaris/classes/sun/nio/fs/UnixPath.java index b392b56b7e92c2c3839baec5c7184548ab4e5255..dfa1e0f0d7e6894eb68afea19df3abc9cd60f7ca 100644 --- a/src/solaris/classes/sun/nio/fs/UnixPath.java +++ b/src/solaris/classes/sun/nio/fs/UnixPath.java @@ -819,13 +819,13 @@ class UnixPath } @Override - public Path toRealPath(boolean resolveLinks) throws IOException { + public Path toRealPath(LinkOption... options) throws IOException { checkRead(); UnixPath absolute = toAbsolutePath(); - // if resolveLinks is true then use realpath - if (resolveLinks) { + // if resolving links then use realpath + if (Util.followLinks(options)) { try { byte[] rp = realpath(absolute); return new UnixPath(getFileSystem(), rp); @@ -834,7 +834,7 @@ class UnixPath } } - // if resolveLinks is false then eliminate "." and also ".." + // if not resolving links then eliminate "." and also ".." // where the previous element is not a link. UnixPath result = fs.rootDirectory(); for (int i=0; i V @@ -172,7 +158,7 @@ public class WindowsFileSystemProvider WindowsPath file = WindowsPath.toWindowsPath(obj); if (view == null) throw new NullPointerException(); - boolean followLinks = followLinks(options); + boolean followLinks = Util.followLinks(options); if (view == BasicFileAttributeView.class) return (V) WindowsFileAttributeViews.createBasicView(file, followLinks); if (view == DosFileAttributeView.class) @@ -209,7 +195,7 @@ public class WindowsFileSystemProvider @Override public DynamicFileAttributeView getFileAttributeView(Path obj, String name, LinkOption... options) { WindowsPath file = WindowsPath.toWindowsPath(obj); - boolean followLinks = followLinks(options); + boolean followLinks = Util.followLinks(options); if (name.equals("basic")) return WindowsFileAttributeViews.createBasicView(file, followLinks); if (name.equals("dos")) diff --git a/src/windows/classes/sun/nio/fs/WindowsPath.java b/src/windows/classes/sun/nio/fs/WindowsPath.java index eb35de8167e554d3dbc649bf1c84395fd2497ff3..0f6d5f8c242e5e40e695f08fb05e1ab5332816ce 100644 --- a/src/windows/classes/sun/nio/fs/WindowsPath.java +++ b/src/windows/classes/sun/nio/fs/WindowsPath.java @@ -831,9 +831,9 @@ class WindowsPath extends AbstractPath { } @Override - public WindowsPath toRealPath(boolean resolveLinks) throws IOException { + public WindowsPath toRealPath(LinkOption... options) throws IOException { checkRead(); - String rp = WindowsLinkSupport.getRealPath(this, resolveLinks); + String rp = WindowsLinkSupport.getRealPath(this, Util.followLinks(options)); return createFromNormalizedPath(getFileSystem(), rp); } diff --git a/test/java/nio/file/Files/CheckPermissions.java b/test/java/nio/file/Files/CheckPermissions.java index 8137a358d42cd07a56478c52089a3b99bf5c7c19..4c9dcca85f3131cd2e6dda508dead71b587f15dc 100644 --- a/test/java/nio/file/Files/CheckPermissions.java +++ b/test/java/nio/file/Files/CheckPermissions.java @@ -521,19 +521,19 @@ public class CheckPermissions { // -- toRealPath -- prepare(); - file.toRealPath(true); + file.toRealPath(); assertCheckRead(file); prepare(); - file.toRealPath(false); + file.toRealPath(LinkOption.NOFOLLOW_LINKS); assertCheckRead(file); prepare(); - Paths.get(".").toRealPath(true); + Paths.get(".").toRealPath(); assertCheckPropertyAccess("user.dir"); prepare(); - Paths.get(".").toRealPath(false); + Paths.get(".").toRealPath(LinkOption.NOFOLLOW_LINKS); assertCheckPropertyAccess("user.dir"); // -- register -- diff --git a/test/java/nio/file/Files/PassThroughFileSystem.java b/test/java/nio/file/Files/PassThroughFileSystem.java index 31345a8bf36d124d0574b7ca27a6ec74d94709e0..e460e358265928953c7ad3e8f8002eb059c82b24 100644 --- a/test/java/nio/file/Files/PassThroughFileSystem.java +++ b/test/java/nio/file/Files/PassThroughFileSystem.java @@ -486,8 +486,8 @@ class PassThroughFileSystem extends FileSystem { } @Override - public Path toRealPath(boolean resolveLinks) throws IOException { - return wrap(delegate.toRealPath(resolveLinks)); + public Path toRealPath(LinkOption... options) throws IOException { + return wrap(delegate.toRealPath(options)); } @Override diff --git a/test/java/nio/file/Path/Misc.java b/test/java/nio/file/Path/Misc.java index b2bf03e3510b15e2cc8c2694e916b14fe85b273d..3f997d1752e7a7a5ec120a0b60bf5f105eaf3659 100644 --- a/test/java/nio/file/Path/Misc.java +++ b/test/java/nio/file/Path/Misc.java @@ -22,12 +22,13 @@ */ /* @test - * @bug 4313887 6838333 + * @bug 4313887 6838333 7029979 * @summary Unit test for miscellenous java.nio.file.Path methods * @library .. */ import java.nio.file.*; +import static java.nio.file.LinkOption.*; import java.io.*; public class Misc { @@ -96,65 +97,65 @@ public class Misc { final Path link = dir.resolve("link"); /** - * Test: totRealPath(true) will access same file as toRealPath(false) + * Test: totRealPath() will access same file as toRealPath(NOFOLLOW_LINKS) */ - assertTrue(Files.isSameFile(file.toRealPath(true), file.toRealPath(false))); + assertTrue(Files.isSameFile(file.toRealPath(), file.toRealPath(NOFOLLOW_LINKS))); /** * Test: toRealPath should fail if file does not exist */ Path doesNotExist = dir.resolve("DoesNotExist"); try { - doesNotExist.toRealPath(true); + doesNotExist.toRealPath(); throw new RuntimeException("IOException expected"); } catch (IOException expected) { } try { - doesNotExist.toRealPath(false); + doesNotExist.toRealPath(NOFOLLOW_LINKS); throw new RuntimeException("IOException expected"); } catch (IOException expected) { } /** - * Test: toRealPath(true) should resolve links + * Test: toRealPath() should resolve links */ if (supportsLinks) { Files.createSymbolicLink(link, file.toAbsolutePath()); - assertTrue(link.toRealPath(true).equals(file.toRealPath(true))); + assertTrue(link.toRealPath().equals(file.toRealPath())); Files.delete(link); } /** - * Test: toRealPath(false) should not resolve links + * Test: toRealPath(NOFOLLOW_LINKS) should not resolve links */ if (supportsLinks) { Files.createSymbolicLink(link, file.toAbsolutePath()); - assertTrue(link.toRealPath(false).getFileName().equals(link.getFileName())); + assertTrue(link.toRealPath(NOFOLLOW_LINKS).getFileName().equals(link.getFileName())); Files.delete(link); } /** - * Test: toRealPath(false) with broken link + * Test: toRealPath(NOFOLLOW_LINKS) with broken link */ if (supportsLinks) { Path broken = Files.createSymbolicLink(link, doesNotExist); - assertTrue(link.toRealPath(false).getFileName().equals(link.getFileName())); + assertTrue(link.toRealPath(NOFOLLOW_LINKS).getFileName().equals(link.getFileName())); Files.delete(link); } /** * Test: toRealPath should eliminate "." */ - assertTrue(dir.resolve(".").toRealPath(true).equals(dir.toRealPath(true))); - assertTrue(dir.resolve(".").toRealPath(false).equals(dir.toRealPath(false))); + assertTrue(dir.resolve(".").toRealPath().equals(dir.toRealPath())); + assertTrue(dir.resolve(".").toRealPath(NOFOLLOW_LINKS).equals(dir.toRealPath(NOFOLLOW_LINKS))); /** * Test: toRealPath should eliminate ".." when it doesn't follow a * symbolic link */ Path subdir = Files.createDirectory(dir.resolve("subdir")); - assertTrue(subdir.resolve("..").toRealPath(true).equals(dir.toRealPath(true))); - assertTrue(subdir.resolve("..").toRealPath(false).equals(dir.toRealPath(false))); + assertTrue(subdir.resolve("..").toRealPath().equals(dir.toRealPath())); + assertTrue(subdir.resolve("..").toRealPath(NOFOLLOW_LINKS).equals(dir.toRealPath(NOFOLLOW_LINKS))); Files.delete(subdir); // clean-up