| /* |
| * Copyright (c) 2000, 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. 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 com.sun.jmx.mbeanserver; |
| |
| |
| import static com.sun.jmx.defaults.JmxProperties.MBEANSERVER_LOGGER; |
| import java.io.ByteArrayInputStream; |
| import java.io.IOException; |
| import java.io.ObjectInputStream; |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Modifier; |
| import java.security.AccessControlContext; |
| import java.security.AccessController; |
| import java.security.Permission; |
| import java.security.Permissions; |
| import java.security.PrivilegedAction; |
| import java.security.ProtectionDomain; |
| import java.util.Map; |
| import java.util.logging.Level; |
| |
| import javax.management.InstanceNotFoundException; |
| import javax.management.MBeanException; |
| import javax.management.MBeanPermission; |
| import javax.management.NotCompliantMBeanException; |
| import javax.management.ObjectName; |
| import javax.management.OperationsException; |
| import javax.management.ReflectionException; |
| import javax.management.RuntimeErrorException; |
| import javax.management.RuntimeMBeanException; |
| import javax.management.RuntimeOperationsException; |
| import sun.reflect.misc.ConstructorUtil; |
| import sun.reflect.misc.ReflectUtil; |
| |
| /** |
| * Implements the MBeanInstantiator interface. Provides methods for |
| * instantiating objects, finding the class given its name and using |
| * different class loaders, deserializing objects in the context of a |
| * given class loader. |
| * |
| * @since 1.5 |
| */ |
| public class MBeanInstantiator { |
| private final ModifiableClassLoaderRepository clr; |
| // private MetaData meta = null; |
| |
| MBeanInstantiator(ModifiableClassLoaderRepository clr) { |
| this.clr = clr; |
| } |
| |
| |
| /** |
| * This methods tests if the MBean class makes it possible to |
| * instantiate an MBean of this class in the MBeanServer. |
| * e.g. it must have a public constructor, be a concrete class... |
| */ |
| public void testCreation(Class<?> c) throws NotCompliantMBeanException { |
| Introspector.testCreation(c); |
| } |
| |
| /** |
| * Loads the class with the specified name using this object's |
| * Default Loader Repository. |
| **/ |
| public Class<?> findClassWithDefaultLoaderRepository(String className) |
| throws ReflectionException { |
| |
| Class<?> theClass; |
| if (className == null) { |
| throw new RuntimeOperationsException(new |
| IllegalArgumentException("The class name cannot be null"), |
| "Exception occurred during object instantiation"); |
| } |
| |
| ReflectUtil.checkPackageAccess(className); |
| try { |
| if (clr == null) throw new ClassNotFoundException(className); |
| theClass = clr.loadClass(className); |
| } |
| catch (ClassNotFoundException ee) { |
| throw new ReflectionException(ee, |
| "The MBean class could not be loaded by the default loader repository"); |
| } |
| |
| return theClass; |
| } |
| |
| |
| /** |
| * Gets the class for the specified class name using the MBean |
| * Interceptor's classloader |
| */ |
| public Class<?> findClass(String className, ClassLoader loader) |
| throws ReflectionException { |
| |
| return loadClass(className,loader); |
| } |
| |
| /** |
| * Gets the class for the specified class name using the specified |
| * class loader |
| */ |
| public Class<?> findClass(String className, ObjectName aLoader) |
| throws ReflectionException, InstanceNotFoundException { |
| |
| if (aLoader == null) |
| throw new RuntimeOperationsException(new |
| IllegalArgumentException(), "Null loader passed in parameter"); |
| |
| // Retrieve the class loader from the repository |
| ClassLoader loader = null; |
| synchronized (this) { |
| loader = getClassLoader(aLoader); |
| } |
| if (loader == null) { |
| throw new InstanceNotFoundException("The loader named " + |
| aLoader + " is not registered in the MBeanServer"); |
| } |
| return findClass(className,loader); |
| } |
| |
| |
| /** |
| * Return an array of Class corresponding to the given signature, using |
| * the specified class loader. |
| */ |
| public Class<?>[] findSignatureClasses(String signature[], |
| ClassLoader loader) |
| throws ReflectionException { |
| |
| if (signature == null) return null; |
| final ClassLoader aLoader = loader; |
| final int length= signature.length; |
| final Class<?> tab[]=new Class<?>[length]; |
| |
| if (length == 0) return tab; |
| try { |
| for (int i= 0; i < length; i++) { |
| // Start handling primitive types (int. boolean and so |
| // forth) |
| // |
| |
| final Class<?> primCla = primitiveClasses.get(signature[i]); |
| if (primCla != null) { |
| tab[i] = primCla; |
| continue; |
| } |
| |
| ReflectUtil.checkPackageAccess(signature[i]); |
| // Ok we do not have a primitive type ! We need to build |
| // the signature of the method |
| // |
| if (aLoader != null) { |
| // We need to load the class through the class |
| // loader of the target object. |
| // |
| tab[i] = Class.forName(signature[i], false, aLoader); |
| } else { |
| // Load through the default class loader |
| // |
| tab[i] = findClass(signature[i], |
| this.getClass().getClassLoader()); |
| } |
| } |
| } catch (ClassNotFoundException e) { |
| if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) { |
| MBEANSERVER_LOGGER.logp(Level.FINEST, |
| MBeanInstantiator.class.getName(), |
| "findSignatureClasses", |
| "The parameter class could not be found", e); |
| } |
| throw new ReflectionException(e, |
| "The parameter class could not be found"); |
| } catch (RuntimeException e) { |
| if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) { |
| MBEANSERVER_LOGGER.logp(Level.FINEST, |
| MBeanInstantiator.class.getName(), |
| "findSignatureClasses", |
| "Unexpected exception", e); |
| } |
| throw e; |
| } |
| return tab; |
| } |
| |
| |
| /** |
| * Instantiates an object given its class, using its empty constructor. |
| * The call returns a reference to the newly created object. |
| */ |
| public Object instantiate(Class<?> theClass) |
| throws ReflectionException, MBeanException { |
| |
| checkMBeanPermission(theClass, null, null, "instantiate"); |
| |
| Object moi; |
| |
| // ------------------------------ |
| // ------------------------------ |
| Constructor<?> cons = findConstructor(theClass, null); |
| if (cons == null) { |
| throw new ReflectionException(new |
| NoSuchMethodException("No such constructor")); |
| } |
| // Instantiate the new object |
| try { |
| ReflectUtil.checkPackageAccess(theClass); |
| ensureClassAccess(theClass); |
| moi= cons.newInstance(); |
| } catch (InvocationTargetException e) { |
| // Wrap the exception. |
| Throwable t = e.getTargetException(); |
| if (t instanceof RuntimeException) { |
| throw new RuntimeMBeanException((RuntimeException)t, |
| "RuntimeException thrown in the MBean's empty constructor"); |
| } else if (t instanceof Error) { |
| throw new RuntimeErrorException((Error) t, |
| "Error thrown in the MBean's empty constructor"); |
| } else { |
| throw new MBeanException((Exception) t, |
| "Exception thrown in the MBean's empty constructor"); |
| } |
| } catch (NoSuchMethodError error) { |
| throw new ReflectionException(new |
| NoSuchMethodException("No constructor"), |
| "No such constructor"); |
| } catch (InstantiationException e) { |
| throw new ReflectionException(e, |
| "Exception thrown trying to invoke the MBean's empty constructor"); |
| } catch (IllegalAccessException e) { |
| throw new ReflectionException(e, |
| "Exception thrown trying to invoke the MBean's empty constructor"); |
| } catch (IllegalArgumentException e) { |
| throw new ReflectionException(e, |
| "Exception thrown trying to invoke the MBean's empty constructor"); |
| } |
| return moi; |
| |
| } |
| |
| |
| |
| /** |
| * Instantiates an object given its class, the parameters and |
| * signature of its constructor The call returns a reference to |
| * the newly created object. |
| */ |
| public Object instantiate(Class<?> theClass, Object params[], |
| String signature[], ClassLoader loader) |
| throws ReflectionException, MBeanException { |
| |
| checkMBeanPermission(theClass, null, null, "instantiate"); |
| |
| // Instantiate the new object |
| // ------------------------------ |
| // ------------------------------ |
| final Class<?>[] tab; |
| Object moi; |
| try { |
| // Build the signature of the method |
| // |
| ClassLoader aLoader= theClass.getClassLoader(); |
| // Build the signature of the method |
| // |
| tab = |
| ((signature == null)?null: |
| findSignatureClasses(signature,aLoader)); |
| } |
| // Exception IllegalArgumentException raised in Jdk1.1.8 |
| catch (IllegalArgumentException e) { |
| throw new ReflectionException(e, |
| "The constructor parameter classes could not be loaded"); |
| } |
| |
| // Query the metadata service to get the right constructor |
| Constructor<?> cons = findConstructor(theClass, tab); |
| |
| if (cons == null) { |
| throw new ReflectionException(new |
| NoSuchMethodException("No such constructor")); |
| } |
| try { |
| ReflectUtil.checkPackageAccess(theClass); |
| ensureClassAccess(theClass); |
| moi = cons.newInstance(params); |
| } |
| catch (NoSuchMethodError error) { |
| throw new ReflectionException(new |
| NoSuchMethodException("No such constructor found"), |
| "No such constructor" ); |
| } |
| catch (InstantiationException e) { |
| throw new ReflectionException(e, |
| "Exception thrown trying to invoke the MBean's constructor"); |
| } |
| catch (IllegalAccessException e) { |
| throw new ReflectionException(e, |
| "Exception thrown trying to invoke the MBean's constructor"); |
| } |
| catch (InvocationTargetException e) { |
| // Wrap the exception. |
| Throwable th = e.getTargetException(); |
| if (th instanceof RuntimeException) { |
| throw new RuntimeMBeanException((RuntimeException)th, |
| "RuntimeException thrown in the MBean's constructor"); |
| } else if (th instanceof Error) { |
| throw new RuntimeErrorException((Error) th, |
| "Error thrown in the MBean's constructor"); |
| } else { |
| throw new MBeanException((Exception) th, |
| "Exception thrown in the MBean's constructor"); |
| } |
| } |
| return moi; |
| } |
| |
| /** |
| * De-serializes a byte array in the context of a classloader. |
| * |
| * @param loader the classloader to use for de-serialization |
| * @param data The byte array to be de-sererialized. |
| * |
| * @return The de-serialized object stream. |
| * |
| * @exception OperationsException Any of the usual Input/Output related |
| * exceptions. |
| */ |
| public ObjectInputStream deserialize(ClassLoader loader, byte[] data) |
| throws OperationsException { |
| |
| // Check parameter validity |
| if (data == null) { |
| throw new RuntimeOperationsException(new |
| IllegalArgumentException(), "Null data passed in parameter"); |
| } |
| if (data.length == 0) { |
| throw new RuntimeOperationsException(new |
| IllegalArgumentException(), "Empty data passed in parameter"); |
| } |
| |
| // Object deserialization |
| ByteArrayInputStream bIn; |
| ObjectInputStream objIn; |
| |
| bIn = new ByteArrayInputStream(data); |
| try { |
| objIn = new ObjectInputStreamWithLoader(bIn,loader); |
| } catch (IOException e) { |
| throw new OperationsException( |
| "An IOException occurred trying to de-serialize the data"); |
| } |
| |
| return objIn; |
| } |
| |
| /** |
| * De-serializes a byte array in the context of a given MBean class loader. |
| * <P>The class loader is the one that loaded the class with name |
| * "className". |
| * <P>The name of the class loader to be used for loading the specified |
| * class is specified. If null, a default one has to be provided (for a |
| * MBean Server, its own class loader will be used). |
| * |
| * @param className The name of the class whose class loader should |
| * be used for the de-serialization. |
| * @param data The byte array to be de-sererialized. |
| * @param loaderName The name of the class loader to be used for loading |
| * the specified class. If null, a default one has to be provided (for a |
| * MBean Server, its own class loader will be used). |
| * |
| * @return The de-serialized object stream. |
| * |
| * @exception InstanceNotFoundException The specified class loader MBean is |
| * not found. |
| * @exception OperationsException Any of the usual Input/Output related |
| * exceptions. |
| * @exception ReflectionException The specified class could not be loaded |
| * by the specified class loader. |
| */ |
| public ObjectInputStream deserialize(String className, |
| ObjectName loaderName, |
| byte[] data, |
| ClassLoader loader) |
| throws InstanceNotFoundException, |
| OperationsException, |
| ReflectionException { |
| |
| // Check parameter validity |
| if (data == null) { |
| throw new RuntimeOperationsException(new |
| IllegalArgumentException(), "Null data passed in parameter"); |
| } |
| if (data.length == 0) { |
| throw new RuntimeOperationsException(new |
| IllegalArgumentException(), "Empty data passed in parameter"); |
| } |
| if (className == null) { |
| throw new RuntimeOperationsException(new |
| IllegalArgumentException(), "Null className passed in parameter"); |
| } |
| |
| ReflectUtil.checkPackageAccess(className); |
| Class<?> theClass; |
| if (loaderName == null) { |
| // Load the class using the agent class loader |
| theClass = findClass(className, loader); |
| |
| } else { |
| // Get the class loader MBean |
| try { |
| ClassLoader instance = null; |
| |
| instance = getClassLoader(loaderName); |
| if (instance == null) |
| throw new ClassNotFoundException(className); |
| theClass = Class.forName(className, false, instance); |
| } |
| catch (ClassNotFoundException e) { |
| throw new ReflectionException(e, |
| "The MBean class could not be loaded by the " + |
| loaderName.toString() + " class loader"); |
| } |
| } |
| |
| // Object deserialization |
| ByteArrayInputStream bIn; |
| ObjectInputStream objIn; |
| |
| bIn = new ByteArrayInputStream(data); |
| try { |
| objIn = new ObjectInputStreamWithLoader(bIn, |
| theClass.getClassLoader()); |
| } catch (IOException e) { |
| throw new OperationsException( |
| "An IOException occurred trying to de-serialize the data"); |
| } |
| |
| return objIn; |
| } |
| |
| |
| /** |
| * Instantiates an object using the list of all class loaders registered |
| * in the MBean Interceptor |
| * (using its {@link javax.management.loading.ClassLoaderRepository}). |
| * <P>The object's class should have a public constructor. |
| * <P>It returns a reference to the newly created object. |
| * <P>The newly created object is not registered in the MBean Interceptor. |
| * |
| * @param className The class name of the object to be instantiated. |
| * |
| * @return The newly instantiated object. |
| * |
| * @exception ReflectionException Wraps a |
| * <CODE>java.lang.ClassNotFoundException</CODE> or the |
| * <CODE>java.lang.Exception</CODE> that occurred when trying to invoke the |
| * object's constructor. |
| * @exception MBeanException The constructor of the object has thrown an |
| * exception |
| * @exception RuntimeOperationsException Wraps a |
| * <CODE>java.lang.IllegalArgumentException</CODE>: the className passed in |
| * parameter is null. |
| */ |
| public Object instantiate(String className) |
| throws ReflectionException, |
| MBeanException { |
| |
| return instantiate(className, (Object[]) null, (String[]) null, null); |
| } |
| |
| |
| |
| /** |
| * Instantiates an object using the class Loader specified by its |
| * <CODE>ObjectName</CODE>. |
| * <P>If the loader name is null, a default one has to be provided (for a |
| * MBean Server, the ClassLoader that loaded it will be used). |
| * <P>The object's class should have a public constructor. |
| * <P>It returns a reference to the newly created object. |
| * <P>The newly created object is not registered in the MBean Interceptor. |
| * |
| * @param className The class name of the MBean to be instantiated. |
| * @param loaderName The object name of the class loader to be used. |
| * |
| * @return The newly instantiated object. |
| * |
| * @exception ReflectionException Wraps a |
| * <CODE>java.lang.ClassNotFoundException</CODE> or the |
| * <CODE>java.lang.Exception</CODE> that occurred when trying to invoke the |
| * object's constructor. |
| * @exception MBeanException The constructor of the object has thrown an |
| * exception. |
| * @exception InstanceNotFoundException The specified class loader is not |
| * registered in the MBeanServerInterceptor. |
| * @exception RuntimeOperationsException Wraps a |
| * <CODE>java.lang.IllegalArgumentException</CODE>: the className passed in |
| * parameter is null. |
| */ |
| public Object instantiate(String className, ObjectName loaderName, |
| ClassLoader loader) |
| throws ReflectionException, MBeanException, |
| InstanceNotFoundException { |
| |
| return instantiate(className, loaderName, (Object[]) null, |
| (String[]) null, loader); |
| } |
| |
| |
| /** |
| * Instantiates an object using the list of all class loaders registered |
| * in the MBean server |
| * (using its {@link javax.management.loading.ClassLoaderRepository}). |
| * <P>The object's class should have a public constructor. |
| * <P>The call returns a reference to the newly created object. |
| * <P>The newly created object is not registered in the MBean Interceptor. |
| * |
| * @param className The class name of the object to be instantiated. |
| * @param params An array containing the parameters of the constructor to |
| * be invoked. |
| * @param signature An array containing the signature of the constructor to |
| * be invoked. |
| * |
| * @return The newly instantiated object. |
| * |
| * @exception ReflectionException Wraps a |
| * <CODE>java.lang.ClassNotFoundException</CODE> or the |
| * <CODE>java.lang.Exception</CODE> that occurred when trying to invoke the |
| * object's constructor. |
| * @exception MBeanException The constructor of the object has thrown an |
| * exception |
| * @exception RuntimeOperationsException Wraps a |
| * <CODE>java.lang.IllegalArgumentException</CODE>: the className passed in |
| * parameter is null. |
| */ |
| public Object instantiate(String className, |
| Object params[], |
| String signature[], |
| ClassLoader loader) |
| throws ReflectionException, |
| MBeanException { |
| |
| Class<?> theClass = findClassWithDefaultLoaderRepository(className); |
| return instantiate(theClass, params, signature, loader); |
| } |
| |
| |
| |
| /** |
| * Instantiates an object. The class loader to be used is identified by its |
| * object name. |
| * <P>If the object name of the loader is null, a default has to be |
| * provided (for example, for a MBean Server, the ClassLoader that loaded |
| * it will be used). |
| * <P>The object's class should have a public constructor. |
| * <P>The call returns a reference to the newly created object. |
| * <P>The newly created object is not registered in the MBean server. |
| * |
| * @param className The class name of the object to be instantiated. |
| * @param params An array containing the parameters of the constructor to |
| * be invoked. |
| * @param signature An array containing the signature of the constructor to |
| * be invoked. |
| * @param loaderName The object name of the class loader to be used. |
| * |
| * @return The newly instantiated object. |
| * |
| * @exception ReflectionException Wraps a |
| * <CODE>java.lang.ClassNotFoundException</CODE> or the |
| * <CODE>java.lang.Exception</CODE> that occurred when trying to invoke the |
| * object's constructor. |
| * @exception MBeanException The constructor of the object has thrown an |
| * exception |
| * @exception InstanceNotFoundException The specified class loader is not |
| * registered in the MBean Interceptor. |
| * @exception RuntimeOperationsException Wraps a |
| * <CODE>java.lang.IllegalArgumentException</CODE>: the className passed in |
| * parameter is null. |
| */ |
| public Object instantiate(String className, |
| ObjectName loaderName, |
| Object params[], |
| String signature[], |
| ClassLoader loader) |
| throws ReflectionException, |
| MBeanException, |
| InstanceNotFoundException { |
| |
| // ------------------------------ |
| // ------------------------------ |
| Class<?> theClass; |
| |
| if (loaderName == null) { |
| theClass = findClass(className, loader); |
| } else { |
| theClass = findClass(className, loaderName); |
| } |
| return instantiate(theClass, params, signature, loader); |
| } |
| |
| |
| /** |
| * Return the Default Loader Repository used by this instantiator object. |
| **/ |
| public ModifiableClassLoaderRepository getClassLoaderRepository() { |
| checkMBeanPermission((String)null, null, null, "getClassLoaderRepository"); |
| return clr; |
| } |
| |
| /** |
| * Load a class with the specified loader, or with this object |
| * class loader if the specified loader is null. |
| **/ |
| static Class<?> loadClass(String className, ClassLoader loader) |
| throws ReflectionException { |
| Class<?> theClass; |
| if (className == null) { |
| throw new RuntimeOperationsException(new |
| IllegalArgumentException("The class name cannot be null"), |
| "Exception occurred during object instantiation"); |
| } |
| ReflectUtil.checkPackageAccess(className); |
| try { |
| if (loader == null) |
| loader = MBeanInstantiator.class.getClassLoader(); |
| if (loader != null) { |
| theClass = Class.forName(className, false, loader); |
| } else { |
| theClass = Class.forName(className); |
| } |
| } catch (ClassNotFoundException e) { |
| throw new ReflectionException(e, |
| "The MBean class could not be loaded"); |
| } |
| return theClass; |
| } |
| |
| |
| |
| /** |
| * Load the classes specified in the signature with the given loader, |
| * or with this object class loader. |
| **/ |
| static Class<?>[] loadSignatureClasses(String signature[], |
| ClassLoader loader) |
| throws ReflectionException { |
| |
| if (signature == null) return null; |
| final ClassLoader aLoader = |
| (loader==null?MBeanInstantiator.class.getClassLoader():loader); |
| final int length= signature.length; |
| final Class<?> tab[]=new Class<?>[length]; |
| |
| if (length == 0) return tab; |
| try { |
| for (int i= 0; i < length; i++) { |
| // Start handling primitive types (int. boolean and so |
| // forth) |
| // |
| |
| final Class<?> primCla = primitiveClasses.get(signature[i]); |
| if (primCla != null) { |
| tab[i] = primCla; |
| continue; |
| } |
| |
| // Ok we do not have a primitive type ! We need to build |
| // the signature of the method |
| // |
| // We need to load the class through the class |
| // loader of the target object. |
| // |
| ReflectUtil.checkPackageAccess(signature[i]); |
| tab[i] = Class.forName(signature[i], false, aLoader); |
| } |
| } catch (ClassNotFoundException e) { |
| if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) { |
| MBEANSERVER_LOGGER.logp(Level.FINEST, |
| MBeanInstantiator.class.getName(), |
| "findSignatureClasses", |
| "The parameter class could not be found", e); |
| } |
| throw new ReflectionException(e, |
| "The parameter class could not be found"); |
| } catch (RuntimeException e) { |
| if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) { |
| MBEANSERVER_LOGGER.logp(Level.FINEST, |
| MBeanInstantiator.class.getName(), |
| "findSignatureClasses", |
| "Unexpected exception", e); |
| } |
| throw e; |
| } |
| return tab; |
| } |
| |
| private Constructor<?> findConstructor(Class<?> c, Class<?>[] params) { |
| try { |
| return ConstructorUtil.getConstructor(c, params); |
| } catch (Exception e) { |
| return null; |
| } |
| } |
| |
| |
| private static final Map<String, Class<?>> primitiveClasses = Util.newMap(); |
| static { |
| for (Class<?> c : new Class<?>[] {byte.class, short.class, int.class, |
| long.class, float.class, double.class, |
| char.class, boolean.class}) |
| primitiveClasses.put(c.getName(), c); |
| } |
| |
| private static void checkMBeanPermission(Class<?> clazz, |
| String member, |
| ObjectName objectName, |
| String actions) { |
| if (clazz != null) { |
| checkMBeanPermission(clazz.getName(), member, objectName, actions); |
| } |
| } |
| |
| private static void checkMBeanPermission(String classname, |
| String member, |
| ObjectName objectName, |
| String actions) |
| throws SecurityException { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) { |
| Permission perm = new MBeanPermission(classname, |
| member, |
| objectName, |
| actions); |
| sm.checkPermission(perm); |
| } |
| } |
| |
| private static void ensureClassAccess(Class clazz) |
| throws IllegalAccessException |
| { |
| int mod = clazz.getModifiers(); |
| if (!Modifier.isPublic(mod)) { |
| throw new IllegalAccessException("Class is not public and can't be instantiated"); |
| } |
| } |
| |
| private ClassLoader getClassLoader(final ObjectName name) { |
| if(clr == null){ |
| return null; |
| } |
| // Restrict to getClassLoader permission only |
| Permissions permissions = new Permissions(); |
| permissions.add(new MBeanPermission("*", null, name, "getClassLoader")); |
| ProtectionDomain protectionDomain = new ProtectionDomain(null, permissions); |
| ProtectionDomain[] domains = {protectionDomain}; |
| AccessControlContext ctx = new AccessControlContext(domains); |
| ClassLoader loader = AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() { |
| public ClassLoader run() { |
| return clr.getClassLoader(name); |
| } |
| }, ctx); |
| return loader; |
| } |
| } |
