private final char slash;

private final char colon;

private final String javaHome;

public UnixFileSystem() {

slash = AccessController.doPrivileged(

new GetPropertyAction("file.separator")).charAt(0);

colon = AccessController.doPrivileged(

new GetPropertyAction("path.separator")).charAt(0);

javaHome = AccessController.doPrivileged(

new GetPropertyAction("java.home"));

}

/* -- Normalization and construction -- */

public char getSeparator() {

return slash;

}

public char getPathSeparator() {

return colon;

}

/* A normal Unix pathname contains no duplicate slashes and does not end

/* Normalize the given pathname, whose length is len, starting at the given

private String normalize(String pathname, int len, int off) {

if (len == 0) return pathname;

int n = len;

while ((n > 0) && (pathname.charAt(n - 1) == '/')) n--;

if (n == 0) return "/";

StringBuffer sb = new StringBuffer(pathname.length());

if (off > 0) sb.append(pathname.substring(0, off));

char prevChar = 0;

for (int i = off; i < n; i++) {

char c = pathname.charAt(i);

if ((prevChar == '/') && (c == '/')) continue;

sb.append(c);

prevChar = c;

}

return sb.toString();

}

/* Check that the given pathname is normal. If not, invoke the real

public String normalize(String pathname) {

int n = pathname.length();

char prevChar = 0;

for (int i = 0; i < n; i++) {

char c = pathname.charAt(i);

if ((prevChar == '/') && (c == '/'))

return normalize(pathname, n, i - 1);

prevChar = c;

}

if (prevChar == '/') return normalize(pathname, n, n - 1);

return pathname;

}

public int prefixLength(String pathname) {

if (pathname.length() == 0) return 0;

return (pathname.charAt(0) == '/') ? 1 : 0;

}

public String resolve(String parent, String child) {

if (child.equals("")) return parent;

if (child.charAt(0) == '/') {

if (parent.equals("/")) return child;

return parent + child;

}

if (parent.equals("/")) return parent + child;

return parent + '/' + child;

}

public String getDefaultParent() {

return "/";

}

public String fromURIPath(String path) {

String p = path;

if (p.endsWith("/") && (p.length() > 1)) {

// "/foo/" --> "/foo", but "/" --> "/"

p = p.substring(0, p.length() - 1);

}

return p;

}

/* -- Path operations -- */

public boolean isAbsolute(File f) {

return (f.getPrefixLength() != 0);

}

public String resolve(File f) {

if (isAbsolute(f)) return f.getPath();

return resolve(System.getProperty("user.dir"), f.getPath());

}

// Caches for canonicalization results to improve startup performance.

// The first cache handles repeated canonicalizations of the same path

// name. The prefix cache handles repeated canonicalizations within the

// same directory, and must not create results differing from the true

// canonicalization algorithm in canonicalize_md.c. For this reason the

// prefix cache is conservative and is not used for complex path names.

private ExpiringCache cache = new ExpiringCache();

// On Unix symlinks can jump anywhere in the file system, so we only

// treat prefixes in java.home as trusted and cacheable in the

// canonicalization algorithm

private ExpiringCache javaHomePrefixCache = new ExpiringCache();

public String canonicalize(String path) throws IOException {

if (!useCanonCaches) {

return canonicalize0(path);

} else {

String res = cache.get(path);

if (res == null) {

String dir = null;

String resDir = null;

if (useCanonPrefixCache) {

// Note that this can cause symlinks that should

// be resolved to a destination directory to be

// resolved to the directory they're contained in

dir = parentOrNull(path);

if (dir != null) {

resDir = javaHomePrefixCache.get(dir);

if (resDir != null) {

// Hit only in prefix cache; full path is canonical

String filename = path.substring(1 + dir.length());

res = resDir + slash + filename;

cache.put(dir + slash + filename, res);

}

}

}

if (res == null) {

res = canonicalize0(path);

cache.put(path, res);

if (useCanonPrefixCache &&

dir != null && dir.startsWith(javaHome)) {

resDir = parentOrNull(res);

// Note that we don't allow a resolved symlink

// to elsewhere in java.home to pollute the

// prefix cache (java.home prefix cache could

// just as easily be a set at this point)

if (resDir != null && resDir.equals(dir)) {

File f = new File(res);

if (f.exists() && !f.isDirectory()) {

javaHomePrefixCache.put(dir, resDir);

}

}

}

}

}

return res;

}

}

private native String canonicalize0(String path) throws IOException;

// Best-effort attempt to get parent of this path; used for

// optimization of filename canonicalization. This must return null for

// any cases where the code in canonicalize_md.c would throw an

// exception or otherwise deal with non-simple pathnames like handling

// of "." and "..". It may conservatively return null in other

// situations as well. Returning null will cause the underlying

// (expensive) canonicalization routine to be called.

static String parentOrNull(String path) {

if (path == null) return null;

char sep = File.separatorChar;

int last = path.length() - 1;

int idx = last;

int adjacentDots = 0;

int nonDotCount = 0;

while (idx > 0) {

char c = path.charAt(idx);

if (c == '.') {

if (++adjacentDots >= 2) {

// Punt on pathnames containing . and ..

return null;

}

} else if (c == sep) {

if (adjacentDots == 1 && nonDotCount == 0) {

// Punt on pathnames containing . and ..

return null;

}

if (idx == 0 ||

idx >= last - 1 ||

path.charAt(idx - 1) == sep) {

// Punt on pathnames containing adjacent slashes

// toward the end

return null;

}

return path.substring(0, idx);

} else {

++nonDotCount;

adjacentDots = 0;

}

--idx;

}

return null;

}

/* -- Attribute accessors -- */

public native int getBooleanAttributes0(File f);

public int getBooleanAttributes(File f) {

int rv = getBooleanAttributes0(f);

String name = f.getName();

boolean hidden = (name.length() > 0) && (name.charAt(0) == '.');

return rv | (hidden ? BA_HIDDEN : 0);

}

public native boolean checkAccess(File f, int access);

public native long getLastModifiedTime(File f);

public native long getLength(File f);

public native boolean setPermission(File f, int access, boolean enable, boolean owneronly);

/* -- File operations -- */

public native boolean createFileExclusively(String path)

throws IOException;

public boolean delete(File f) {

// Keep canonicalization caches in sync after file deletion

// and renaming operations. Could be more clever than this

// (i.e., only remove/update affected entries) but probably

// not worth it since these entries expire after 30 seconds

// anyway.

cache.clear();

javaHomePrefixCache.clear();

return delete0(f);

}

private native boolean delete0(File f);

public native String[] list(File f);

public native boolean createDirectory(File f);

public boolean rename(File f1, File f2) {

// Keep canonicalization caches in sync after file deletion

// and renaming operations. Could be more clever than this

// (i.e., only remove/update affected entries) but probably

// not worth it since these entries expire after 30 seconds

// anyway.

cache.clear();

javaHomePrefixCache.clear();

return rename0(f1, f2);

}

private native boolean rename0(File f1, File f2);

public native boolean setLastModifiedTime(File f, long time);

public native boolean setReadOnly(File f);

/* -- Filesystem interface -- */

public File[] listRoots() {

try {

SecurityManager security = System.getSecurityManager();

if (security != null) {

security.checkRead("/");

}

return new File[] { new File("/") };

} catch (SecurityException x) {

return new File[0];

}

}

/* -- Disk usage -- */

public native long getSpace(File f, int t);

/* -- Basic infrastructure -- */

public int compare(File f1, File f2) {

return f1.getPath().compareTo(f2.getPath());

}

public int hashCode(File f) {

return f.getPath().hashCode() ^ 1234321;

}

private static native void initIDs();

static {

initIDs();

}