/hg/release/icedtea7-forest-2.3/jdk: 2 new changesets
andrew at icedtea.classpath.org
andrew at icedtea.classpath.org
Tue Aug 6 03:40:12 PDT 2013
changeset 6ae667b931d5 in /hg/release/icedtea7-forest-2.3/jdk
details: http://icedtea.classpath.org/hg/release/icedtea7-forest-2.3/jdk?cmd=changeset;node=6ae667b931d5
author: mchung
date: Tue Jun 25 16:12:47 2013 -0700
8016814: sun.reflect.Reflection.getCallerClass returns the frame off by 1
Reviewed-by: jrose, alanb, chegar, twisti
changeset 64c0a3fb78cd in /hg/release/icedtea7-forest-2.3/jdk
details: http://icedtea.classpath.org/hg/release/icedtea7-forest-2.3/jdk?cmd=changeset;node=64c0a3fb78cd
author: mchung
date: Tue Jul 02 13:23:35 2013 -0700
8014925: Disable sun.reflect.Reflection.getCallerClass(int) with a temporary switch to re-enable it
Reviewed-by: jrose, alanb, chegar, twisti
diffstat:
src/share/classes/sun/misc/VM.java | 20 ++++
src/share/classes/sun/reflect/Reflection.java | 10 ++-
test/sun/reflect/GetCallerClass.java | 105 ++++++++++++++++++++++++++
3 files changed, 134 insertions(+), 1 deletions(-)
diffs (166 lines):
diff -r 8c388c89a45c -r 64c0a3fb78cd src/share/classes/sun/misc/VM.java
--- a/src/share/classes/sun/misc/VM.java Thu Jul 25 20:48:39 2013 +0100
+++ b/src/share/classes/sun/misc/VM.java Tue Jul 02 13:23:35 2013 -0700
@@ -216,6 +216,16 @@
return allowArraySyntax;
}
+ private static boolean allowGetCallerClass = false;
+
+ // Reflection.getCallerClass(int) is disabled by default.
+ // It can be enabled by setting the system property
+ // "jdk.reflect.allowGetCallerClass" and also used by
+ // logging stack walk of a resource bundle if it is turned on.
+ public static boolean allowGetCallerClass() {
+ return allowGetCallerClass;
+ }
+
/**
* Returns the system property of the specified key saved at
* system initialization time. This method should only be used
@@ -280,6 +290,16 @@
? defaultAllowArraySyntax
: Boolean.parseBoolean(s));
+ // Reflection.getCallerClass(int) is disabled by default.
+ // It can be enabled by setting the system property
+ // "jdk.reflect.allowGetCallerClass" and also used by
+ // logging stack walk of a resource bundle if it is turned on.
+ s = props.getProperty("jdk.reflect.allowGetCallerClass");
+ allowGetCallerClass = (s != null
+ ? (s.isEmpty() || Boolean.parseBoolean(s))
+ : false) ||
+ Boolean.valueOf(props.getProperty("jdk.logging.allowStackWalkSearch"));
+
// Remove other private system properties
// used by java.lang.Integer.IntegerCache
props.remove("java.lang.Integer.IntegerCache.high");
diff -r 8c388c89a45c -r 64c0a3fb78cd src/share/classes/sun/reflect/Reflection.java
--- a/src/share/classes/sun/reflect/Reflection.java Thu Jul 25 20:48:39 2013 +0100
+++ b/src/share/classes/sun/reflect/Reflection.java Tue Jul 02 13:23:35 2013 -0700
@@ -65,7 +65,15 @@
@Deprecated
@CallerSensitive
public static Class getCallerClass(int depth) {
- return getCallerClass0(depth);
+ if (sun.misc.VM.allowGetCallerClass()) {
+ return getCallerClass0(depth+1);
+ }
+ throw new UnsupportedOperationException("This method is in the sun.* " +
+ "namespace so it is not a supported, public interface. " +
+ "The 7u40 release notes describe a temporary mechanism " +
+ "to reenable the historical functionality of this method. " +
+ "Update code to function properly and this method will be " +
+ "removed without further warning in a subsequent 7 update release.");
}
// If the VM enforces getting caller class with @CallerSensitive,
diff -r 8c388c89a45c -r 64c0a3fb78cd test/sun/reflect/GetCallerClass.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/test/sun/reflect/GetCallerClass.java Tue Jul 02 13:23:35 2013 -0700
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 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.
+ *
+ * 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.
+ */
+
+/*
+ * @test
+ * @bug 8016814 8014925
+ * @summary Test sun.reflect.Reflection.getCallerClass(int) disabled by default
+ * @compile -XDignore.symbol.file GetCallerClass.java
+ * @run main/othervm GetCallerClass
+ * @run main/othervm -Djdk.reflect.allowGetCallerClass GetCallerClass
+ * @run main/othervm -Djdk.reflect.allowGetCallerClass=true GetCallerClass
+ * @run main/othervm -Djdk.reflect.allowGetCallerClass=false GetCallerClass
+ */
+
+public class GetCallerClass {
+ public static void main(String[] args) throws Exception {
+ String s = System.getProperty("jdk.reflect.allowGetCallerClass");
+ boolean allowed;
+ if (s == null || s.equals("false")) {
+ allowed = false;
+ } else if (s.equals("") || s.equals("true")) {
+ allowed = true;
+ } else {
+ throw new RuntimeException("Unsupported test setting");
+ }
+
+ try {
+ Class<?> c = Test.test();
+ if (!allowed) {
+ throw new RuntimeException("Reflection.getCallerClass should not be allowed");
+ }
+ Class<?> caller = Test.caller();
+ if (c != GetCallerClass.class || caller != c) {
+ throw new RuntimeException("Incorrect caller: " + c);
+ }
+ Test.selfTest();
+ } catch (UnsupportedOperationException e) {
+ if (allowed) throw e;
+ }
+ }
+
+ @sun.reflect.CallerSensitive
+ public Class<?> getCallerClass() {
+ // 0: Reflection 1: getCallerClass 2: Test.test 3: main
+ return sun.reflect.Reflection.getCallerClass(3);
+ }
+
+ static class Test {
+ // Returns the caller of this method
+ public static Class<?> test() {
+ return new GetCallerClass().getCallerClass();
+ }
+ @sun.reflect.CallerSensitive
+ public static Class<?> caller() {
+ return sun.reflect.Reflection.getCallerClass();
+ }
+ @sun.reflect.CallerSensitive
+ public static void selfTest() {
+ // 0: Reflection 1: Test.selfTest
+ Class<?> c = sun.reflect.Reflection.getCallerClass(1);
+ if (c != Test.class || caller() != c) {
+ throw new RuntimeException("Incorrect caller: " + c);
+ }
+ Inner1.deep();
+ }
+
+ static class Inner1 {
+ static void deep() {
+ deeper();
+ }
+ static void deeper() {
+ Inner2.deepest();
+ }
+ static class Inner2 {
+ static void deepest() {
+ // 0: Reflection 1: deepest 2: deeper 3: deep 4: Test.selfTest
+ Class<?> c = sun.reflect.Reflection.getCallerClass(4);
+ if (c != Test.class) {
+ throw new RuntimeException("Incorrect caller: " + c);
+ }
+ }
+ }
+ }
+ }
+}
More information about the distro-pkg-dev
mailing list