sun.corba.Bridge Maven / Gradle / Ivy
Show all versions of openjdk-orb Show documentation
/*
* Copyright (c) 2004, 2016, 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
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* 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.
*/
package sun.corba ;
import java.io.OptionalDataException;
import java.lang.invoke.MethodHandle;
import java.lang.reflect.Field ;
import java.lang.reflect.Constructor ;
import java.lang.StackWalker;
import java.lang.StackWalker.StackFrame;
import java.util.Optional;
import java.util.stream.Stream;
import java.security.AccessController;
import java.security.Permission;
import java.security.PrivilegedAction;
import sun.misc.Unsafe;
import sun.reflect.ReflectionFactory;
/** This class provides the methods for fundamental JVM operations
* needed in the ORB that are not part of the public Java API. This includes:
*
* - throwException, which can throw undeclared checked exceptions.
* This is needed to handle throwing arbitrary exceptions across a standardized
* OMG interface that (incorrectly) does not specify appropriate exceptions.
* - putXXX/getXXX methods that allow unchecked access to fields of objects.
* This is used for setting uninitialzed non-static final fields (which is
* impossible with reflection) and for speed.
* - objectFieldOffset to obtain the field offsets for use in the putXXX/getXXX methods
* - newConstructorForSerialization to get the special constructor required for a
* Serializable class
* - latestUserDefinedLoader to get the latest user defined class loader from
* the call stack as required by the RMI-IIOP specification (really from the
* JDK 1.1 days)
*
* The code that calls Bridge.get() must have the following Permissions:
*
* - BridgePermission "getBridge"
* - ReflectPermission "suppressAccessChecks"
* - RuntimePermission "getStackWalkerWithClassReference"
* - RuntimePermission "reflectionFactoryAccess"
*
*
* All of these permissions are required to obtain and correctly initialize
* the instance of Bridge. No security checks are performed on calls
* made to Bridge instance methods, so access to the Bridge instance
* must be protected.
*
* This class is a singleton (per ClassLoader of course). Access to the
* instance is obtained through the Bridge.get() method.
*/
public final class Bridge
{
private static final Permission getBridgePermission =
new BridgePermission("getBridge");
private static Bridge bridge = null ;
/** Access to Unsafe to read/write fields. */
private static final Unsafe unsafe = AccessController.doPrivileged(
(PrivilegedAction)() -> {
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
return (Unsafe)field.get(null);
} catch (NoSuchFieldException |IllegalAccessException ex) {
throw new InternalError("Unsafe.theUnsafe field not available", ex);
}
}
) ;
private final ReflectionFactory reflectionFactory ;
private final StackWalker stackWalker;
private Bridge() {
reflectionFactory = ReflectionFactory.getReflectionFactory();
stackWalker = StackWalker.getInstance(
StackWalker.Option.RETAIN_CLASS_REFERENCE);
}
/** Fetch the Bridge singleton. This requires the following
* permissions:
*
* - BridgePermission "getBridge"
* - ReflectPermission "suppressAccessChecks"
* - RuntimePermission "getStackWalkerWithClassReference"
* - RuntimePermission "reflectionFactoryAccess"
*
* @return The singleton instance of the Bridge class
* @throws SecurityException if the caller does not have the
* required permissions and the caller has a non-null security manager.
*/
public static final synchronized Bridge get()
{
SecurityManager sman = System.getSecurityManager() ;
if (sman != null)
sman.checkPermission( getBridgePermission ) ;
if (bridge == null) {
bridge = new Bridge() ;
}
return bridge ;
}
/** Returns true if the loader that loaded the frame's declaring class
* is a user loader (if it is not the platform class loader or one of
* its ancestor).
*/
private boolean isUserLoader(StackFrame sf) {
ClassLoader cl = sf.getDeclaringClass().getClassLoader();
if (cl == null) return false;
ClassLoader p = ClassLoader.getPlatformClassLoader();
while (cl != p && p != null) p = p.getParent();
return cl != p;
}
private Optional getLatestUserDefinedLoaderFrame(Stream stream) {
return stream.filter(this::isUserLoader).findFirst();
}
/** Obtain the latest user defined ClassLoader from the call stack.
* This is required by the RMI-IIOP specification.
*/
public final ClassLoader getLatestUserDefinedLoader() {
// requires getClassLoader permission => needs doPrivileged.
PrivilegedAction pa = () ->
stackWalker.walk(this::getLatestUserDefinedLoaderFrame)
.map(sf -> sf.getDeclaringClass().getClassLoader())
.orElseGet(() -> ClassLoader.getPlatformClassLoader());
return AccessController.doPrivileged(pa);
}
/**
* Fetches a field element within the given
* object o at the given offset.
* The result is undefined unless the offset was obtained from
* {@link #objectFieldOffset} on the {@link java.lang.reflect.Field}
* of some Java field and the object referred to by o
* is of a class compatible with that field's class.
* @param o Java heap object in which the field from which the offset
* was obtained resides
* @param offset indication of where the field resides in a Java heap
* object
* @return the value fetched from the indicated Java field
* @throws RuntimeException No defined exceptions are thrown, not even
* {@link NullPointerException}
*/
public final int getInt(Object o, long offset)
{
return unsafe.getInt( o, offset ) ;
}
/**
* Stores a value into a given Java field.
*
* The first two parameters are interpreted exactly as with
* {@link #getInt(Object, long)} to refer to a specific
* Java field. The given value is stored into that field.
*
* The field must be of the same type as the method
* parameter x.
*
* @param o Java heap object in which the field resides, if any, else
* null
* @param offset indication of where the field resides in a Java heap
* object.
* @param x the value to store into the indicated Java field
* @throws RuntimeException No defined exceptions are thrown, not even
* {@link NullPointerException}
*/
public final void putInt(Object o, long offset, int x)
{
unsafe.putInt( o, offset, x ) ;
}
/**
* @see #getInt(Object, long)
*/
public final Object getObject(Object o, long offset)
{
return unsafe.getObject( o, offset ) ;
}
/**
* @see #putInt(Object, long, int)
*/
public final void putObject(Object o, long offset, Object x)
{
unsafe.putObject( o, offset, x ) ;
}
/** @see #getInt(Object, long) */
public final boolean getBoolean(Object o, long offset)
{
return unsafe.getBoolean( o, offset ) ;
}
/** @see #putInt(Object, long, int) */
public final void putBoolean(Object o, long offset, boolean x)
{
unsafe.putBoolean( o, offset, x ) ;
}
/** @see #getInt(Object, long) */
public final byte getByte(Object o, long offset)
{
return unsafe.getByte( o, offset ) ;
}
/** @see #putInt(Object, long, int) */
public final void putByte(Object o, long offset, byte x)
{
unsafe.putByte( o, offset, x ) ;
}
/** @see #getInt(Object, long) */
public final short getShort(Object o, long offset)
{
return unsafe.getShort( o, offset ) ;
}
/** @see #putInt(Object, long, int) */
public final void putShort(Object o, long offset, short x)
{
unsafe.putShort( o, offset, x ) ;
}
/** @see #getInt(Object, long) */
public final char getChar(Object o, long offset)
{
return unsafe.getChar( o, offset ) ;
}
/** @see #putInt(Object, long, int) */
public final void putChar(Object o, long offset, char x)
{
unsafe.putChar( o, offset, x ) ;
}
/** @see #getInt(Object, long) */
public final long getLong(Object o, long offset)
{
return unsafe.getLong( o, offset ) ;
}
/** @see #putInt(Object, long, int) */
public final void putLong(Object o, long offset, long x)
{
unsafe.putLong( o, offset, x ) ;
}
/** @see #getInt(Object, long) */
public final float getFloat(Object o, long offset)
{
return unsafe.getFloat( o, offset ) ;
}
/** @see #putInt(Object, long, int) */
public final void putFloat(Object o, long offset, float x)
{
unsafe.putFloat( o, offset, x ) ;
}
/** @see #getInt(Object, long) */
public final double getDouble(Object o, long offset)
{
return unsafe.getDouble( o, offset ) ;
}
/** @see #putInt(Object, long, int) */
public final void putDouble(Object o, long offset, double x)
{
unsafe.putDouble( o, offset, x ) ;
}
/**
* This constant differs from all results that will ever be returned from
* {@link #objectFieldOffset}.
*/
public static final long INVALID_FIELD_OFFSET = -1;
/**
* Returns the offset of a non-static field.
*/
public final long objectFieldOffset(Field f)
{
return unsafe.objectFieldOffset( f ) ;
}
/**
* Returns the offset of a static field.
*/
public final long staticFieldOffset(Field f)
{
return unsafe.staticFieldOffset( f ) ;
}
/**
+ * Returns the location of a given static field.
+ */
public final Object staticFieldBase(Field f) {
return unsafe.staticFieldBase(f);
}
/**
* Ensure that the class has been initalized.
* @param cl the class to ensure is initialized
*/
public final void ensureClassInitialized(Class cl) {
unsafe.ensureClassInitialized(cl); // This method was deprecated in JDK15 and removed in JDK22 so it must be overriden by MR version of this class.
}
/** Throw the exception.
* The exception may be an undeclared checked exception.
*/
public final void throwException(Throwable ee)
{
unsafe.throwException( ee ) ;
}
/**
* Obtain a constructor for Class cl.
* This is used to create a constructor for Serializable classes that
* construct an instance of the Serializable class using the
* no args constructor of the first non-Serializable superclass
* of the Serializable class.
*/
public final Constructor newConstructorForSerialization( Class cl ) {
return reflectionFactory.newConstructorForSerialization( cl ) ;
}
public final Constructor newConstructorForExternalization(Class cl) {
return reflectionFactory.newConstructorForExternalization( cl ) ;
}
/**
* Returns true if the given class defines a static initializer method,
* false otherwise.
*/
public final boolean hasStaticInitializerForSerialization(Class cl) {
return reflectionFactory.hasStaticInitializerForSerialization(cl);
}
public final MethodHandle writeObjectForSerialization(Class cl) {
return reflectionFactory.writeObjectForSerialization(cl);
}
public final MethodHandle readObjectForSerialization(Class cl) {
return reflectionFactory.readObjectForSerialization(cl);
}
public final MethodHandle readObjectNoDataForSerialization(Class cl) {
return reflectionFactory.readObjectNoDataForSerialization(cl);
}
public final MethodHandle readResolveForSerialization(Class cl) {
return reflectionFactory.readResolveForSerialization(cl);
}
public final MethodHandle writeReplaceForSerialization(Class cl) {
return reflectionFactory.writeReplaceForSerialization(cl);
}
/**
* Return a new OptionalDataException instance.
* @return a new OptionalDataException instance
*/
public final OptionalDataException newOptionalDataExceptionForSerialization(boolean bool) {
return reflectionFactory.newOptionalDataExceptionForSerialization(bool);
}
}