Mercurial > jdk8-mips64-public > corba / file revision

 /*

  * 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:

  * <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 uninitialzed 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 (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)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 ) ;

     }

 }