/*
* 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 org.jboss.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:
* <ul>
* <li>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.</li>
* <li>putXXX/getXXX methods that allow unchecked access to fields of objects. This is used for setting uninitialized
* non-static final fields (which is impossible with reflection) and for speed.</li>
* <li>objectFieldOffset to obtain the field offsets for use in the putXXX/getXXX methods</li>
* <li>newConstructorForSerialization to get the special constructor required for a Serializable class</li>
* <li>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)</li>
* </ul>
* The code that calls Bridge.get() must have the following Permissions:
* <ul>
* <li>RuntimePermission "reflectionFactoryAccess"</li>
* <li>BridgePermission "getBridge"</li>
* <li>ReflectPermission "suppressAccessChecks"</li>
* </ul>
* <p>
* 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.
* <p>
* 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 AccessController.doPrivileged(new PrivilegedAction<Method>()
{
public Method 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 = AccessController.doPrivileged(new PrivilegedAction<Field>()
{
public Field 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;
}
@SuppressWarnings("unchecked")
private Bridge()
{
latestUserDefinedLoaderMethod = getLatestUserDefinedLoaderMethod();
unsafe = getUnsafe();
reflectionFactory = (ReflectionFactory) AccessController
.doPrivileged(new ReflectionFactory.GetReflectionFactoryAction());
}
/**
* Fetch the Bridge singleton. This requires the following permissions:
* <ul>
* <li>RuntimePermission "reflectionFactoryAccess"</li>
* <li>BridgePermission "getBridge"</li>
* <li>ReflectPermission "suppressAccessChecks"</li>
* </ul>
*
* @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 <code>o</code> 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 <code>o</code> 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.
* <p>
* 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.
* <p>
* The field must be of the same type as the method parameter <code>x</code>.
*
* @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);
}
}