sun.corba.Bridge Maven / Gradle / Ivy
/*
* Copyright (c) 2004, 2010, 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.lang.reflect.Field ;
import java.lang.reflect.Method ;
import java.lang.reflect.Constructor ;
import java.lang.reflect.InvocationTargetException ;
import java.io.ObjectInputStream ;
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:
*
* - RuntimePermission "reflectionFactoryAccess"
* - BridgePermission "getBridge"
* - ReflectPermission "suppressAccessChecks"
*
*
* 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 Class[] NO_ARGS = new Class[] {};
private static final Permission getBridgePermission =
new BridgePermission( "getBridge" ) ;
private static Bridge bridge = null ;
// latestUserDefinedLoader() is a private static method
// in ObjectInputStream in JDK 1.3 through 1.5.
// We use reflection in a doPrivileged block to get a
// Method reference and make it accessible.
private final Method latestUserDefinedLoaderMethod ;
private final Unsafe unsafe ;
private final ReflectionFactory reflectionFactory ;
private Method getLatestUserDefinedLoaderMethod()
{
return (Method) AccessController.doPrivileged(
new PrivilegedAction()
{
public Object run()
{
Method result = null;
try {
Class io = ObjectInputStream.class;
result = io.getDeclaredMethod(
"latestUserDefinedLoader", NO_ARGS);
result.setAccessible(true);
} catch (NoSuchMethodException nsme) {
Error err = new Error( "java.io.ObjectInputStream" +
" latestUserDefinedLoader " + nsme );
err.initCause(nsme) ;
throw err ;
}
return result;
}
}
);
}
private Unsafe getUnsafe() {
Field fld = (Field)AccessController.doPrivileged(
new PrivilegedAction()
{
public Object run()
{
Field fld = null ;
try {
Class unsafeClass = sun.misc.Unsafe.class ;
fld = unsafeClass.getDeclaredField( "theUnsafe" ) ;
fld.setAccessible( true ) ;
return fld ;
} catch (NoSuchFieldException exc) {
Error err = new Error( "Could not access Unsafe" ) ;
err.initCause( exc ) ;
throw err ;
}
}
}
) ;
Unsafe unsafe = null;
try {
unsafe = (Unsafe)(fld.get( null )) ;
} catch (Throwable t) {
Error err = new Error( "Could not access Unsafe" ) ;
err.initCause( t ) ;
throw err ;
}
return unsafe ;
}
private Bridge()
{
latestUserDefinedLoaderMethod = getLatestUserDefinedLoaderMethod();
unsafe = getUnsafe() ;
reflectionFactory = ReflectionFactory.getReflectionFactory();
}
/** Fetch the Bridge singleton. This requires the following
* permissions:
*
* - RuntimePermission "reflectionFactoryAccess"
* - BridgePermission "getBridge"
* - ReflectPermission "suppressAccessChecks"
*
* @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 ;
}
/** Obtain the latest user defined ClassLoader from the call stack.
* This is required by the RMI-IIOP specification.
*/
public final ClassLoader getLatestUserDefinedLoader()
{
try {
// Invoke the ObjectInputStream.latestUserDefinedLoader method
return (ClassLoader)latestUserDefinedLoaderMethod.invoke(null,
(Object[])NO_ARGS);
} catch (InvocationTargetException ite) {
Error err = new Error(
"sun.corba.Bridge.latestUserDefinedLoader: " + ite ) ;
err.initCause( ite ) ;
throw err ;
} catch (IllegalAccessException iae) {
Error err = new Error(
"sun.corba.Bridge.latestUserDefinedLoader: " + iae ) ;
err.initCause( iae ) ;
throw err ;
}
}
/**
* 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 ) ;
}
/** 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 using constructor cons which
* may be the constructor defined in a superclass of cl. This is
* used to create a constructor for Serializable classes that
* constructs 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,
Constructor cons )
{
return reflectionFactory.newConstructorForSerialization( cl, cons ) ;
}
}