jdk-sandbox: comparison src/jdk.jfr/share/classes/jdk/jfr/internal/SecuritySupport.java

equal deleted inserted replaced

-:2c3cc4b01880
+:c16ac7a2eba4
 /*
-* Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2016, 2019, 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
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.ReflectPermission;
 import java.nio.channels.FileChannel;
 import java.nio.channels.ReadableByteChannel;
+import java.nio.file.DirectoryStream;
 import java.nio.file.FileVisitResult;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.SimpleFileVisitor;
 import jdk.jfr.Event;
 import jdk.jfr.FlightRecorder;
 import jdk.jfr.FlightRecorderListener;
 import jdk.jfr.FlightRecorderPermission;
 import jdk.jfr.Recording;
+import jdk.jfr.internal.consumer.FileAccess;
 /**
 * Contains JFR code that does
 * {@link AccessController#doPrivileged(PrivilegedAction)}
 */
 public final class SecuritySupport {
 private final static Unsafe unsafe = Unsafe.getUnsafe();
 private final static MethodHandles.Lookup LOOKUP = MethodHandles.lookup();
 private final static Module JFR_MODULE = Event.class.getModule();
 public  final static SafePath JFC_DIRECTORY = getPathInProperty("java.home", "lib/jfr");
+public final static FileAccess PRIVILIGED = new Privileged();
 static final SafePath USER_HOME = getPathInProperty("user.home", null);
 static final SafePath JAVA_IO_TMPDIR = getPathInProperty("java.io.tmpdir", null);
 static {
 // ensure module java.base can read module jdk.jfr as early as possible
 /**
 * Path created by the default file provider,and not
 * a malicious provider.
 *
 */
-public static final class SafePath {
+public static final class SafePath implements Comparable<SafePath> {
 private final Path path;
 private final String text;
 public SafePath(Path p) {
 // sanitize
 public Path toPath() {
 return path;
 }
+public File toFile() {
+return path.toFile();
+}
 public String toString() {
 return text;
+}
+@Override
+public int compareTo(SafePath that) {
+return that.text.compareTo(this.text);
 }
 @Override
 public boolean equals(Object other) {
 if(other != null && other instanceof SafePath){
 public static void registerMirror(Class<? extends Event> eventClass) {
 doPrivileged(() ->  MetadataRepository.getInstance().registerMirror(eventClass), new FlightRecorderPermission(Utils.REGISTER_EVENT));
 }
+public static void setProperty(String propertyName, String value) {
+doPrivileged(() -> System.setProperty(propertyName, value), new PropertyPermission(propertyName, "write"));
+}
 static boolean getBooleanProperty(String propertyName) {
 return doPrivilegedWithReturn(() -> Boolean.getBoolean(propertyName), new PropertyPermission(propertyName, "read"));
 }
 private static SafePath getPathInProperty(String prop, String subPath) {
 static void clearDirectory(SafePath safePath) throws IOException {
 doPriviligedIO(() -> Files.walkFileTree(safePath.toPath(), new DirectoryCleaner()));
 }
-static SafePath toRealPath(SafePath safePath) throws Exception {
+static SafePath toRealPath(SafePath safePath) throws IOException {
 return new SafePath(doPrivilegedIOWithReturn(() -> safePath.toPath().toRealPath()));
 }
 static boolean existDirectory(SafePath directory) throws IOException {
 return doPrivilegedIOWithReturn(() -> Files.exists(directory.toPath()));
 Path p = doPrivilegedIOWithReturn(() -> Files.createDirectories(safePath.toPath()));
 return new SafePath(p);
 }
 public static boolean exists(SafePath safePath) throws IOException {
-return doPrivilegedIOWithReturn(() -> Files.exists(safePath.toPath()));
+// Files.exist(path) is allocation intensive
+return doPrivilegedIOWithReturn(() -> safePath.toPath().toFile().exists());
 }
 public static boolean isDirectory(SafePath safePath) throws IOException {
 return doPrivilegedIOWithReturn(() -> Files.isDirectory(safePath.toPath()));
 }
 static void ensureClassIsInitialized(Class<?> clazz) {
 unsafe.ensureClassInitialized(clazz);
 }
 static Class<?> defineClass(Class<?> lookupClass, byte[] bytes) {
-return AccessController.doPrivileged(new PrivilegedAction<>() {
+return AccessController.doPrivileged(new PrivilegedAction<Class<?>>() {
 @Override
 public Class<?> run() {
 try {
 return MethodHandles.privateLookupIn(lookupClass, LOOKUP).defineClass(bytes);
 } catch (IllegalAccessException e) {
 }
 }
 });
 }
-static Thread createThreadWitNoPermissions(String threadName, Runnable runnable) {
+public static Thread createThreadWitNoPermissions(String threadName, Runnable runnable) {
 return doPrivilegedWithReturn(() -> new Thread(runnable, threadName), new Permission[0]);
 }
 static void setDaemonThread(Thread t, boolean daeomn) {
 doPrivileged(()-> t.setDaemon(daeomn), new RuntimePermission("modifyThread"));
 }
 public static SafePath getAbsolutePath(SafePath path) throws IOException {
 return new SafePath(doPrivilegedIOWithReturn((()-> path.toPath().toAbsolutePath())));
 }
+private final static class Privileged extends FileAccess {
+@Override
+public RandomAccessFile openRAF(File f, String mode) throws IOException {
+return doPrivilegedIOWithReturn( () -> new RandomAccessFile(f, mode));
+}
+@Override
+public  DirectoryStream<Path> newDirectoryStream(Path directory)  throws IOException  {
+return doPrivilegedIOWithReturn( () -> Files.newDirectoryStream(directory));
+}
+@Override
+public  String getAbsolutePath(File f) throws IOException {
+return doPrivilegedIOWithReturn( () -> f.getAbsolutePath());
+}
+@Override
+public long length(File f) throws IOException {
+return doPrivilegedIOWithReturn( () -> f.length());
+}
+@Override
+public  long fileSize(Path p) throws IOException {
+return doPrivilegedIOWithReturn( () -> Files.size(p));
+}
+}
 }

changeset 58863	c16ac7a2eba4
parent 58240	046533575954