jdk-sandbox: comparison jdk/src/share/classes/java/io/File.java

equal deleted inserted replaced

-:56bf7cddf22f
+:c445531b8f6b
 /*
-* Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1994, 2013, 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
 * The FileSystem object representing the platform's local file system.
 */
 private static final FileSystem fs = DefaultFileSystem.getFileSystem();
 /**
-* This abstract pathname's normalized pathname string.  A normalized
+* This abstract pathname's normalized pathname string. A normalized
 * pathname string uses the default name-separator character and does not
 * contain any duplicate or redundant separators.
 *
 * @serial
 */
 private final String path;
+/**
+* Enum type that indicates the status of a file path.
+*/
+private static enum PathStatus { INVALID, CHECKED };
+/**
+* The flag indicating whether the file path is invalid.
+*/
+private transient PathStatus status = null;
+/**
+* Check if the file has an invalid path. Currently, the inspection of
+* a file path is very limited, and it only covers Nul character check.
+* Returning true means the path is definitely invalid/garbage. But
+* returning false does not guarantee that the path is valid.
+*
+* @return true if the file path is invalid.
+*/
+final boolean isInvalid() {
+if (status == null) {
+status = (this.path.indexOf('\u0000') < 0) ? PathStatus.CHECKED
+: PathStatus.INVALID;
+}
+return status == PathStatus.INVALID;
+}
 /**
 * The length of this abstract pathname's prefix, or zero if it has no
 * prefix.
 */
 *
 * @since   JDK1.1
 * @see     Path#toRealPath
 */
 public String getCanonicalPath() throws IOException {
+if (isInvalid()) {
+throw new IOException("Invalid file path");
+}
 return fs.canonicalize(fs.resolve(this));
 }
 /**
 * Returns the canonical form of this abstract pathname.  Equivalent to
 * {@link #toURI() toURI} method, and then converting the URI into a URL
 * via the {@link java.net.URI#toURL() URI.toURL} method.
 */
 @Deprecated
 public URL toURL() throws MalformedURLException {
+if (isInvalid()) {
+throw new MalformedURLException("Invalid file path");
+}
 return new URL("file", "", slashify(getAbsolutePath(), isDirectory()));
 }
 /**
 * Constructs a <tt>file:</tt> URI that represents this abstract pathname.
 public boolean canRead() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkRead(path);
 }
+if (isInvalid()) {
+return false;
+}
 return fs.checkAccess(this, FileSystem.ACCESS_READ);
 }
 /**
 * Tests whether the application can modify the file denoted by this
 public boolean canWrite() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkWrite(path);
 }
+if (isInvalid()) {
+return false;
+}
 return fs.checkAccess(this, FileSystem.ACCESS_WRITE);
 }
 /**
 * Tests whether the file or directory denoted by this abstract pathname
 */
 public boolean exists() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkRead(path);
+}
+if (isInvalid()) {
+return false;
 }
 return ((fs.getBooleanAttributes(this) & FileSystem.BA_EXISTS) != 0);
 }
 /**
 public boolean isDirectory() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkRead(path);
 }
+if (isInvalid()) {
+return false;
+}
 return ((fs.getBooleanAttributes(this) & FileSystem.BA_DIRECTORY)
 != 0);
 }
 /**
 public boolean isFile() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkRead(path);
 }
+if (isInvalid()) {
+return false;
+}
 return ((fs.getBooleanAttributes(this) & FileSystem.BA_REGULAR) != 0);
 }
 /**
 * Tests whether the file named by this abstract pathname is a hidden
 */
 public boolean isHidden() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkRead(path);
+}
+if (isInvalid()) {
+return false;
 }
 return ((fs.getBooleanAttributes(this) & FileSystem.BA_HIDDEN) != 0);
 }
 /**
 public long lastModified() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkRead(path);
 }
+if (isInvalid()) {
+return 0L;
+}
 return fs.getLastModifiedTime(this);
 }
 /**
 * Returns the length of the file denoted by this abstract pathname.
 */
 public long length() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkRead(path);
+}
+if (isInvalid()) {
+return 0L;
 }
 return fs.getLength(this);
 }
 * @since 1.2
 */
 public boolean createNewFile() throws IOException {
 SecurityManager security = System.getSecurityManager();
 if (security != null) security.checkWrite(path);
+if (isInvalid()) {
+throw new IOException("Invalid file path");
+}
 return fs.createFileExclusively(path);
 }
 /**
 * Deletes the file or directory denoted by this abstract pathname.  If
 */
 public boolean delete() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkDelete(path);
+}
+if (isInvalid()) {
+return false;
 }
 return fs.delete(this);
 }
 /**
 public void deleteOnExit() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkDelete(path);
 }
+if (isInvalid()) {
+return;
+}
 DeleteOnExitHook.add(path);
 }
 /**
 * Returns an array of strings naming the files and directories in the
 */
 public String[] list() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkRead(path);
+}
+if (isInvalid()) {
+return null;
 }
 return fs.list(this);
 }
 /**
 public boolean mkdir() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkWrite(path);
 }
+if (isInvalid()) {
+return false;
+}
 return fs.createDirectory(this);
 }
 /**
 * Creates the directory named by this abstract pathname, including any
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkWrite(path);
 security.checkWrite(dest.path);
 }
+if (dest == null) {
+throw new NullPointerException();
+}
+if (this.isInvalid() || dest.isInvalid()) {
+return false;
+}
 return fs.rename(this, dest);
 }
 /**
 * Sets the last-modified time of the file or directory named by this
 public boolean setLastModified(long time) {
 if (time < 0) throw new IllegalArgumentException("Negative time");
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkWrite(path);
+}
+if (isInvalid()) {
+return false;
 }
 return fs.setLastModifiedTime(this, time);
 }
 /**
 public boolean setReadOnly() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkWrite(path);
 }
+if (isInvalid()) {
+return false;
+}
 return fs.setReadOnly(this);
 }
 /**
 * Sets the owner's or everybody's write permission for this abstract
 public boolean setWritable(boolean writable, boolean ownerOnly) {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkWrite(path);
 }
+if (isInvalid()) {
+return false;
+}
 return fs.setPermission(this, FileSystem.ACCESS_WRITE, writable, ownerOnly);
 }
 /**
 * A convenience method to set the owner's write permission for this abstract
 public boolean setReadable(boolean readable, boolean ownerOnly) {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkWrite(path);
 }
+if (isInvalid()) {
+return false;
+}
 return fs.setPermission(this, FileSystem.ACCESS_READ, readable, ownerOnly);
 }
 /**
 * A convenience method to set the owner's read permission for this abstract
 public boolean setExecutable(boolean executable, boolean ownerOnly) {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkWrite(path);
 }
+if (isInvalid()) {
+return false;
+}
 return fs.setPermission(this, FileSystem.ACCESS_EXECUTE, executable, ownerOnly);
 }
 /**
 * A convenience method to set the owner's execute permission for this
 */
 public boolean canExecute() {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkExec(path);
+}
+if (isInvalid()) {
+return false;
 }
 return fs.checkAccess(this, FileSystem.ACCESS_EXECUTE);
 }
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 sm.checkPermission(new RuntimePermission("getFileSystemAttributes"));
 sm.checkRead(path);
 }
+if (isInvalid()) {
+return 0L;
+}
 return fs.getSpace(this, FileSystem.SPACE_TOTAL);
 }
 /**
 * Returns the number of unallocated bytes in the partition <a
 * inaccurate by any external I/O operations including those made
 * on the system outside of this virtual machine.  This method
 * makes no guarantee that write operations to this file system
 * will succeed.
 *
-* @return  The number of unallocated bytes on the partition <tt>0L</tt>
+* @return  The number of unallocated bytes on the partition or <tt>0L</tt>
 *          if the abstract pathname does not name a partition.  This
 *          value will be less than or equal to the total file system size
 *          returned by {@link #getTotalSpace}.
 *
 * @throws  SecurityException
 public long getFreeSpace() {
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 sm.checkPermission(new RuntimePermission("getFileSystemAttributes"));
 sm.checkRead(path);
+}
+if (isInvalid()) {
+return 0L;
 }
 return fs.getSpace(this, FileSystem.SPACE_FREE);
 }
 /**
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 sm.checkPermission(new RuntimePermission("getFileSystemAttributes"));
 sm.checkRead(path);
 }
+if (isInvalid()) {
+return 0L;
+}
 return fs.getSpace(this, FileSystem.SPACE_USABLE);
 }
 /* -- Temporary files -- */
 private static class TempDirectory {
 private TempDirectory() { }
 // temporary directory location
-private static final File tmpdir = new File(fs.normalize(AccessController
+private static final File tmpdir = new File(AccessController
-.doPrivileged(new GetPropertyAction("java.io.tmpdir"))));
+.doPrivileged(new GetPropertyAction("java.io.tmpdir")));
 static File location() {
 return tmpdir;
 }
 // file name generation
 if (directory == null)
 throw new SecurityException("Unable to create temporary file");
 throw se;
 }
 }
+if (f.isInvalid()) {
+throw new IOException("Unable to create temporary file");
+}
 } while (!fs.createFileExclusively(f.getPath()));
 return f;
 }
 /**

changeset 17430	c445531b8f6b
parent 14324	3510b4bf90ee
child 18157	ee3bda8e26c6