1 /*

     2  * Copyright (c) 2002, 2016, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package javax.management.remote.rmi;

    27 

    28 import com.sun.jmx.mbeanserver.Util;

    29 import com.sun.jmx.remote.internal.ClientCommunicatorAdmin;

    30 import com.sun.jmx.remote.internal.ClientListenerInfo;

    31 import com.sun.jmx.remote.internal.ClientNotifForwarder;

    32 import com.sun.jmx.remote.internal.ProxyRef;

    33 import com.sun.jmx.remote.util.ClassLogger;

    34 import com.sun.jmx.remote.util.EnvHelp;

    35 import java.io.ByteArrayInputStream;

    36 import java.io.IOException;

    37 import java.io.InputStream;

    38 import java.io.InvalidObjectException;

    39 import java.io.ObjectInputStream;

    40 import java.io.ObjectStreamClass;

    41 import java.io.Serializable;

    42 import java.lang.ref.WeakReference;

    43 import java.lang.reflect.Constructor;

    44 import java.lang.reflect.InvocationHandler;

    45 import java.lang.reflect.InvocationTargetException;

    46 import java.lang.reflect.Module;

    47 import java.lang.reflect.Proxy;

    48 import java.net.MalformedURLException;

    49 import java.rmi.MarshalledObject;

    50 import java.rmi.NoSuchObjectException;

    51 import java.rmi.Remote;

    52 import java.rmi.ServerException;

    53 import java.rmi.UnmarshalException;

    54 import java.rmi.server.RMIClientSocketFactory;

    55 import java.rmi.server.RemoteObject;

    56 import java.rmi.server.RemoteObjectInvocationHandler;

    57 import java.rmi.server.RemoteRef;

    58 import java.security.AccessController;

    59 import java.security.PrivilegedAction;

    60 import java.security.PrivilegedExceptionAction;

    61 import java.security.ProtectionDomain;

    62 import java.util.Arrays;

    63 import java.util.Collections;

    64 import java.util.HashMap;

    65 import java.util.Hashtable;

    66 import java.util.Map;

    67 import java.util.Objects;

    68 import java.util.Set;

    69 import java.util.WeakHashMap;

    70 import java.util.stream.Collectors;

    71 import javax.management.Attribute;

    72 import javax.management.AttributeList;

    73 import javax.management.AttributeNotFoundException;

    74 import javax.management.InstanceAlreadyExistsException;

    75 import javax.management.InstanceNotFoundException;

    76 import javax.management.IntrospectionException;

    77 import javax.management.InvalidAttributeValueException;

    78 import javax.management.ListenerNotFoundException;

    79 import javax.management.MBeanException;

    80 import javax.management.MBeanInfo;

    81 import javax.management.MBeanRegistrationException;

    82 import javax.management.MBeanServerConnection;

    83 import javax.management.MBeanServerDelegate;

    84 import javax.management.MBeanServerNotification;

    85 import javax.management.NotCompliantMBeanException;

    86 import javax.management.Notification;

    87 import javax.management.NotificationBroadcasterSupport;

    88 import javax.management.NotificationFilter;

    89 import javax.management.NotificationFilterSupport;

    90 import javax.management.NotificationListener;

    91 import javax.management.ObjectInstance;

    92 import javax.management.ObjectName;

    93 import javax.management.QueryExp;

    94 import javax.management.ReflectionException;

    95 import javax.management.remote.JMXConnectionNotification;

    96 import javax.management.remote.JMXConnector;

    97 import javax.management.remote.JMXConnectorFactory;

    98 import javax.management.remote.JMXServiceURL;

    99 import javax.management.remote.NotificationResult;

   100 import javax.management.remote.JMXAddressable;

   101 import javax.naming.InitialContext;

   102 import javax.naming.NamingException;

   103 import javax.rmi.ssl.SslRMIClientSocketFactory;

   104 import javax.security.auth.Subject;

   105 import jdk.internal.module.Modules;

   106 import sun.reflect.misc.ReflectUtil;

   107 import sun.rmi.server.UnicastRef2;

   108 import sun.rmi.transport.LiveRef;

   109 

   110 /**

   111  * <p>A connection to a remote RMI connector.  Usually, such

   112  * connections are made using {@link

   113  * javax.management.remote.JMXConnectorFactory JMXConnectorFactory}.

   114  * However, specialized applications can use this class directly, for

   115  * example with an {@link RMIServer} stub obtained without going

   116  * through JNDI.</p>

   117  *

   118  * @since 1.5

   119  */

   120 public class RMIConnector implements JMXConnector, Serializable, JMXAddressable {

   121 

   122     private static final ClassLogger logger =

   123             new ClassLogger("javax.management.remote.rmi", "RMIConnector");

   124 

   125     private static final long serialVersionUID = 817323035842634473L;

   126 

   127     private RMIConnector(RMIServer rmiServer, JMXServiceURL address,

   128             Map<String, ?> environment) {

   129         if (rmiServer == null && address == null) throw new

   130                 IllegalArgumentException("rmiServer and jmxServiceURL both null");

   131         initTransients();

   132 

   133         this.rmiServer = rmiServer;

   134         this.jmxServiceURL = address;

   135         if (environment == null) {

   136             this.env = Collections.emptyMap();

   137         } else {

   138             EnvHelp.checkAttributes(environment);

   139             this.env = Collections.unmodifiableMap(environment);

   140         }

   141     }

   142 

   143     /**

   144      * <p>Constructs an {@code RMIConnector} that will connect

   145      * the RMI connector server with the given address.</p>

   146      *

   147      * <p>The address can refer directly to the connector server,

   148      * using the following syntax:</p>

   149      *

   150      * <pre>

   151      * service:jmx:rmi://<em>[host[:port]]</em>/stub/<em>encoded-stub</em>

   152      * </pre>

   153      *

   154      * <p>(Here, the square brackets {@code []} are not part of the

   155      * address but indicate that the host and port are optional.)</p>

   156      *

   157      * <p>The address can instead indicate where to find an RMI stub

   158      * through JNDI, using the following syntax:</p>

   159      *

   160      * <pre>

   161      * service:jmx:rmi://<em>[host[:port]]</em>/jndi/<em>jndi-name</em>

   162      * </pre>

   163      *

   164      * <p>An implementation may also recognize additional address

   165      * syntaxes, for example:</p>

   166      *

   167      * <pre>

   168      * service:jmx:iiop://<em>[host[:port]]</em>/stub/<em>encoded-stub</em>

   169      * </pre>

   170      *

   171      * @param url the address of the RMI connector server.

   172      *

   173      * @param environment additional attributes specifying how to make

   174      * the connection.  For JNDI-based addresses, these attributes can

   175      * usefully include JNDI attributes recognized by {@link

   176      * InitialContext#InitialContext(Hashtable) InitialContext}.  This

   177      * parameter can be null, which is equivalent to an empty Map.

   178      *

   179      * @exception IllegalArgumentException if {@code url}

   180      * is null.

   181      */

   182     public RMIConnector(JMXServiceURL url, Map<String,?> environment) {

   183         this(null, url, environment);

   184     }

   185 

   186     /**

   187      * <p>Constructs an {@code RMIConnector} using the given RMI stub.

   188      *

   189      * @param rmiServer an RMI stub representing the RMI connector server.

   190      * @param environment additional attributes specifying how to make

   191      * the connection.  This parameter can be null, which is

   192      * equivalent to an empty Map.

   193      *

   194      * @exception IllegalArgumentException if {@code rmiServer}

   195      * is null.

   196      */

   197     public RMIConnector(RMIServer rmiServer, Map<String,?> environment) {

   198         this(rmiServer, null, environment);

   199     }

   200 

   201     /**

   202      * <p>Returns a string representation of this object.  In general,

   203      * the {@code toString} method returns a string that

   204      * "textually represents" this object. The result should be a

   205      * concise but informative representation that is easy for a

   206      * person to read.</p>

   207      *

   208      * @return a String representation of this object.

   209      **/

   210     @Override

   211     public String toString() {

   212         final StringBuilder b = new StringBuilder(this.getClass().getName());

   213         b.append(":");

   214         if (rmiServer != null) {

   215             b.append(" rmiServer=").append(rmiServer.toString());

   216         }

   217         if (jmxServiceURL != null) {

   218             if (rmiServer!=null) b.append(",");

   219             b.append(" jmxServiceURL=").append(jmxServiceURL.toString());

   220         }

   221         return b.toString();

   222     }

   223 

   224     /**

   225      * <p>The address of this connector.</p>

   226      *

   227      * @return the address of this connector, or null if it

   228      * does not have one.

   229      *

   230      * @since 1.6

   231      */

   232     public JMXServiceURL getAddress() {

   233         return jmxServiceURL;

   234     }

   235 

   236     //--------------------------------------------------------------------

   237     // implements JMXConnector interface

   238     //--------------------------------------------------------------------

   239 

   240     /**

   241      * @throws IOException if the connection could not be made because of a

   242      *   communication problem

   243      */

   244     public void connect() throws IOException {

   245         connect(null);

   246     }

   247 

   248     /**

   249      * @throws IOException if the connection could not be made because of a

   250      *   communication problem

   251      */

   252     public synchronized void connect(Map<String,?> environment)

   253     throws IOException {

   254         final boolean tracing = logger.traceOn();

   255         String        idstr   = (tracing?"["+this.toString()+"]":null);

   256 

   257         if (terminated) {

   258             logger.trace("connect",idstr + " already closed.");

   259             throw new IOException("Connector closed");

   260         }

   261         if (connected) {

   262             logger.trace("connect",idstr + " already connected.");

   263             return;

   264         }

   265 

   266         try {

   267             if (tracing) logger.trace("connect",idstr + " connecting...");

   268 

   269             final Map<String, Object> usemap =

   270                     new HashMap<String, Object>((this.env==null) ?

   271                         Collections.<String, Object>emptyMap() : this.env);

   272 

   273 

   274             if (environment != null) {

   275                 EnvHelp.checkAttributes(environment);

   276                 usemap.putAll(environment);

   277             }

   278 

   279             // Get RMIServer stub from directory or URL encoding if needed.

   280             if (tracing) logger.trace("connect",idstr + " finding stub...");

   281             RMIServer stub = (rmiServer!=null)?rmiServer:

   282                 findRMIServer(jmxServiceURL, usemap);

   283 

   284             // Check for secure RMIServer stub if the corresponding

   285             // client-side environment property is set to "true".

   286             //

   287             String stringBoolean =  (String) usemap.get("jmx.remote.x.check.stub");

   288             boolean checkStub = EnvHelp.computeBooleanFromString(stringBoolean);

   289 

   290             if (checkStub) checkStub(stub, rmiServerImplStubClass);

   291 

   292             if (tracing) logger.trace("connect",idstr + " connecting stub...");

   293             idstr = (tracing?"["+this.toString()+"]":null);

   294 

   295             // Calling newClient on the RMIServer stub.

   296             if (tracing)

   297                 logger.trace("connect",idstr + " getting connection...");

   298             Object credentials = usemap.get(CREDENTIALS);

   299 

   300             try {

   301                 connection = getConnection(stub, credentials, checkStub);

   302             } catch (java.rmi.RemoteException re) {

   303                 throw re;

   304             }

   305 

   306             // Always use one of:

   307             //   ClassLoader provided in Map at connect time,

   308             //   or contextClassLoader at connect time.

   309             if (tracing)

   310                 logger.trace("connect",idstr + " getting class loader...");

   311             defaultClassLoader = EnvHelp.resolveClientClassLoader(usemap);

   312 

   313             usemap.put(JMXConnectorFactory.DEFAULT_CLASS_LOADER,

   314                     defaultClassLoader);

   315 

   316             rmiNotifClient = new RMINotifClient(defaultClassLoader, usemap);

   317 

   318             env = usemap;

   319             final long checkPeriod = EnvHelp.getConnectionCheckPeriod(usemap);

   320             communicatorAdmin = new RMIClientCommunicatorAdmin(checkPeriod);

   321 

   322             connected = true;

   323 

   324             // The connectionId variable is used in doStart(), when

   325             // reconnecting, to identify the "old" connection.

   326             //

   327             connectionId = getConnectionId();

   328 

   329             Notification connectedNotif =

   330                     new JMXConnectionNotification(JMXConnectionNotification.OPENED,

   331                     this,

   332                     connectionId,

   333                     clientNotifSeqNo++,

   334                     "Successful connection",

   335                     null);

   336             sendNotification(connectedNotif);

   337 

   338             if (tracing) logger.trace("connect",idstr + " done...");

   339         } catch (IOException e) {

   340             if (tracing)

   341                 logger.trace("connect",idstr + " failed to connect: " + e);

   342             throw e;

   343         } catch (RuntimeException e) {

   344             if (tracing)

   345                 logger.trace("connect",idstr + " failed to connect: " + e);

   346             throw e;

   347         } catch (NamingException e) {

   348             final String msg = "Failed to retrieve RMIServer stub: " + e;

   349             if (tracing) logger.trace("connect",idstr + " " + msg);

   350             throw EnvHelp.initCause(new IOException(msg),e);

   351         }

   352     }

   353 

   354     public synchronized String getConnectionId() throws IOException {

   355         if (terminated || !connected) {

   356             if (logger.traceOn())

   357                 logger.trace("getConnectionId","["+this.toString()+

   358                         "] not connected.");

   359 

   360             throw new IOException("Not connected");

   361         }

   362 

   363         // we do a remote call to have an IOException if the connection is broken.

   364         // see the bug 4939578

   365         return connection.getConnectionId();

   366     }

   367 

   368     public synchronized MBeanServerConnection getMBeanServerConnection()

   369     throws IOException {

   370         return getMBeanServerConnection(null);

   371     }

   372 

   373     public synchronized MBeanServerConnection

   374             getMBeanServerConnection(Subject delegationSubject)

   375             throws IOException {

   376 

   377         if (terminated) {

   378             if (logger.traceOn())

   379                 logger.trace("getMBeanServerConnection","[" + this.toString() +

   380                         "] already closed.");

   381             throw new IOException("Connection closed");

   382         } else if (!connected) {

   383             if (logger.traceOn())

   384                 logger.trace("getMBeanServerConnection","[" + this.toString() +

   385                         "] is not connected.");

   386             throw new IOException("Not connected");

   387         }

   388 

   389         return getConnectionWithSubject(delegationSubject);

   390     }

   391 

   392     public void

   393             addConnectionNotificationListener(NotificationListener listener,

   394             NotificationFilter filter,

   395             Object handback) {

   396         if (listener == null)

   397             throw new NullPointerException("listener");

   398         connectionBroadcaster.addNotificationListener(listener, filter,

   399                 handback);

   400     }

   401 

   402     public void

   403             removeConnectionNotificationListener(NotificationListener listener)

   404             throws ListenerNotFoundException {

   405         if (listener == null)

   406             throw new NullPointerException("listener");

   407         connectionBroadcaster.removeNotificationListener(listener);

   408     }

   409 

   410     public void

   411             removeConnectionNotificationListener(NotificationListener listener,

   412             NotificationFilter filter,

   413             Object handback)

   414             throws ListenerNotFoundException {

   415         if (listener == null)

   416             throw new NullPointerException("listener");

   417         connectionBroadcaster.removeNotificationListener(listener, filter,

   418                 handback);

   419     }

   420 

   421     private void sendNotification(Notification n) {

   422         connectionBroadcaster.sendNotification(n);

   423     }

   424 

   425     public synchronized void close() throws IOException {

   426         close(false);

   427     }

   428 

   429     // allows to do close after setting the flag "terminated" to true.

   430     // It is necessary to avoid a deadlock, see 6296324

   431     private synchronized void close(boolean intern) throws IOException {

   432         final boolean tracing = logger.traceOn();

   433         final boolean debug   = logger.debugOn();

   434         final String  idstr   = (tracing?"["+this.toString()+"]":null);

   435 

   436         if (!intern) {

   437             // Return if already cleanly closed.

   438             //

   439             if (terminated) {

   440                 if (closeException == null) {

   441                     if (tracing) logger.trace("close",idstr + " already closed.");

   442                     return;

   443                 }

   444             } else {

   445                 terminated = true;

   446             }

   447         }

   448 

   449         if (closeException != null && tracing) {

   450             // Already closed, but not cleanly. Attempt again.

   451             //

   452             if (tracing) {

   453                 logger.trace("close",idstr + " had failed: " + closeException);

   454                 logger.trace("close",idstr + " attempting to close again.");

   455             }

   456         }

   457 

   458         String savedConnectionId = null;

   459         if (connected) {

   460             savedConnectionId = connectionId;

   461         }

   462 

   463         closeException = null;

   464 

   465         if (tracing) logger.trace("close",idstr + " closing.");

   466 

   467         if (communicatorAdmin != null) {

   468             communicatorAdmin.terminate();

   469         }

   470 

   471         if (rmiNotifClient != null) {

   472             try {

   473                 rmiNotifClient.terminate();

   474                 if (tracing) logger.trace("close",idstr +

   475                         " RMI Notification client terminated.");

   476             } catch (RuntimeException x) {

   477                 closeException = x;

   478                 if (tracing) logger.trace("close",idstr +

   479                         " Failed to terminate RMI Notification client: " + x);

   480                 if (debug) logger.debug("close",x);

   481             }

   482         }

   483 

   484         if (connection != null) {

   485             try {

   486                 connection.close();

   487                 if (tracing) logger.trace("close",idstr + " closed.");

   488             } catch (NoSuchObjectException nse) {

   489                 // OK, the server maybe closed itself.

   490             } catch (IOException e) {

   491                 closeException = e;

   492                 if (tracing) logger.trace("close",idstr +

   493                         " Failed to close RMIServer: " + e);

   494                 if (debug) logger.debug("close",e);

   495             }

   496         }

   497 

   498         // Clean up MBeanServerConnection table

   499         //

   500         rmbscMap.clear();

   501 

   502         /* Send notification of closure.  We don't do this if the user

   503          * never called connect() on the connector, because there's no

   504          * connection id in that case.  */

   505 

   506         if (savedConnectionId != null) {

   507             Notification closedNotif =

   508                     new JMXConnectionNotification(JMXConnectionNotification.CLOSED,

   509                     this,

   510                     savedConnectionId,

   511                     clientNotifSeqNo++,

   512                     "Client has been closed",

   513                     null);

   514             sendNotification(closedNotif);

   515         }

   516 

   517         // throw exception if needed

   518         //

   519         if (closeException != null) {

   520             if (tracing) logger.trace("close",idstr + " failed to close: " +

   521                     closeException);

   522             if (closeException instanceof IOException)

   523                 throw (IOException) closeException;

   524             if (closeException instanceof RuntimeException)

   525                 throw (RuntimeException) closeException;

   526             final IOException x =

   527                     new IOException("Failed to close: " + closeException);

   528             throw EnvHelp.initCause(x,closeException);

   529         }

   530     }

   531 

   532     // added for re-connection

   533     private Integer addListenerWithSubject(ObjectName name,

   534                                            MarshalledObject<NotificationFilter> filter,

   535                                            Subject delegationSubject,

   536                                            boolean reconnect)

   537         throws InstanceNotFoundException, IOException {

   538 

   539         final boolean debug = logger.debugOn();

   540         if (debug)

   541             logger.debug("addListenerWithSubject",

   542                     "(ObjectName,MarshalledObject,Subject)");

   543 

   544         final ObjectName[] names = new ObjectName[] {name};

   545         final MarshalledObject<NotificationFilter>[] filters =

   546                 Util.cast(new MarshalledObject<?>[] {filter});

   547         final Subject[] delegationSubjects = new Subject[] {

   548             delegationSubject

   549         };

   550 

   551         final Integer[] listenerIDs =

   552                 addListenersWithSubjects(names,filters,delegationSubjects,

   553                 reconnect);

   554 

   555         if (debug) logger.debug("addListenerWithSubject","listenerID="

   556                 + listenerIDs[0]);

   557         return listenerIDs[0];

   558     }

   559 

   560     // added for re-connection

   561     private Integer[] addListenersWithSubjects(ObjectName[]       names,

   562                              MarshalledObject<NotificationFilter>[] filters,

   563                              Subject[]          delegationSubjects,

   564                              boolean            reconnect)

   565         throws InstanceNotFoundException, IOException {

   566 

   567         final boolean debug = logger.debugOn();

   568         if (debug)

   569             logger.debug("addListenersWithSubjects",

   570                     "(ObjectName[],MarshalledObject[],Subject[])");

   571 

   572         final ClassLoader old = pushDefaultClassLoader();

   573         Integer[] listenerIDs = null;

   574 

   575         try {

   576             listenerIDs = connection.addNotificationListeners(names,

   577                     filters,

   578                     delegationSubjects);

   579         } catch (NoSuchObjectException noe) {

   580             // maybe reconnect

   581             if (reconnect) {

   582                 communicatorAdmin.gotIOException(noe);

   583 

   584                 listenerIDs = connection.addNotificationListeners(names,

   585                         filters,

   586                         delegationSubjects);

   587             } else {

   588                 throw noe;

   589             }

   590         } catch (IOException ioe) {

   591             // send a failed notif if necessary

   592             communicatorAdmin.gotIOException(ioe);

   593         } finally {

   594             popDefaultClassLoader(old);

   595         }

   596 

   597         if (debug) logger.debug("addListenersWithSubjects","registered "

   598                 + ((listenerIDs==null)?0:listenerIDs.length)

   599                 + " listener(s)");

   600         return listenerIDs;

   601     }

   602 

   603     //--------------------------------------------------------------------

   604     // Implementation of MBeanServerConnection

   605     //--------------------------------------------------------------------

   606     private class RemoteMBeanServerConnection implements MBeanServerConnection {

   607         private Subject delegationSubject;

   608 

   609         public RemoteMBeanServerConnection() {

   610             this(null);

   611         }

   612 

   613         public RemoteMBeanServerConnection(Subject delegationSubject) {

   614             this.delegationSubject = delegationSubject;

   615         }

   616 

   617         public ObjectInstance createMBean(String className,

   618                 ObjectName name)

   619                 throws ReflectionException,

   620                 InstanceAlreadyExistsException,

   621                 MBeanRegistrationException,

   622                 MBeanException,

   623                 NotCompliantMBeanException,

   624                 IOException {

   625             if (logger.debugOn())

   626                 logger.debug("createMBean(String,ObjectName)",

   627                         "className=" + className + ", name=" +

   628                         name);

   629 

   630             final ClassLoader old = pushDefaultClassLoader();

   631             try {

   632                 return connection.createMBean(className,

   633                         name,

   634                         delegationSubject);

   635             } catch (IOException ioe) {

   636                 communicatorAdmin.gotIOException(ioe);

   637 

   638                 return connection.createMBean(className,

   639                         name,

   640                         delegationSubject);

   641             } finally {

   642                 popDefaultClassLoader(old);

   643             }

   644         }

   645 

   646         public ObjectInstance createMBean(String className,

   647                 ObjectName name,

   648                 ObjectName loaderName)

   649                 throws ReflectionException,

   650                 InstanceAlreadyExistsException,

   651                 MBeanRegistrationException,

   652                 MBeanException,

   653                 NotCompliantMBeanException,

   654                 InstanceNotFoundException,

   655                 IOException {

   656 

   657             if (logger.debugOn())

   658                 logger.debug("createMBean(String,ObjectName,ObjectName)",

   659                         "className=" + className + ", name="

   660                         + name + ", loaderName="

   661                         + loaderName + ")");

   662 

   663             final ClassLoader old = pushDefaultClassLoader();

   664             try {

   665                 return connection.createMBean(className,

   666                         name,

   667                         loaderName,

   668                         delegationSubject);

   669 

   670             } catch (IOException ioe) {

   671                 communicatorAdmin.gotIOException(ioe);

   672 

   673                 return connection.createMBean(className,

   674                         name,

   675                         loaderName,

   676                         delegationSubject);

   677 

   678             } finally {

   679                 popDefaultClassLoader(old);

   680             }

   681         }

   682 

   683         public ObjectInstance createMBean(String className,

   684                 ObjectName name,

   685                 Object params[],

   686                 String signature[])

   687                 throws ReflectionException,

   688                 InstanceAlreadyExistsException,

   689                 MBeanRegistrationException,

   690                 MBeanException,

   691                 NotCompliantMBeanException,

   692                 IOException {

   693             if (logger.debugOn())

   694                 logger.debug("createMBean(String,ObjectName,Object[],String[])",

   695                         "className=" + className + ", name="

   696                         + name + ", signature=" + strings(signature));

   697 

   698             final MarshalledObject<Object[]> sParams =

   699                     new MarshalledObject<Object[]>(params);

   700             final ClassLoader old = pushDefaultClassLoader();

   701             try {

   702                 return connection.createMBean(className,

   703                         name,

   704                         sParams,

   705                         signature,

   706                         delegationSubject);

   707             } catch (IOException ioe) {

   708                 communicatorAdmin.gotIOException(ioe);

   709 

   710                 return connection.createMBean(className,

   711                         name,

   712                         sParams,

   713                         signature,

   714                         delegationSubject);

   715             } finally {

   716                 popDefaultClassLoader(old);

   717             }

   718         }

   719 

   720         public ObjectInstance createMBean(String className,

   721                 ObjectName name,

   722                 ObjectName loaderName,

   723                 Object params[],

   724                 String signature[])

   725                 throws ReflectionException,

   726                 InstanceAlreadyExistsException,

   727                 MBeanRegistrationException,

   728                 MBeanException,

   729                 NotCompliantMBeanException,

   730                 InstanceNotFoundException,

   731                 IOException {

   732             if (logger.debugOn()) logger.debug(

   733                     "createMBean(String,ObjectName,ObjectName,Object[],String[])",

   734                     "className=" + className + ", name=" + name + ", loaderName="

   735                     + loaderName + ", signature=" + strings(signature));

   736 

   737             final MarshalledObject<Object[]> sParams =

   738                     new MarshalledObject<Object[]>(params);

   739             final ClassLoader old = pushDefaultClassLoader();

   740             try {

   741                 return connection.createMBean(className,

   742                         name,

   743                         loaderName,

   744                         sParams,

   745                         signature,

   746                         delegationSubject);

   747             } catch (IOException ioe) {

   748                 communicatorAdmin.gotIOException(ioe);

   749 

   750                 return connection.createMBean(className,

   751                         name,

   752                         loaderName,

   753                         sParams,

   754                         signature,

   755                         delegationSubject);

   756             } finally {

   757                 popDefaultClassLoader(old);

   758             }

   759         }

   760 

   761         public void unregisterMBean(ObjectName name)

   762         throws InstanceNotFoundException,

   763                 MBeanRegistrationException,

   764                 IOException {

   765             if (logger.debugOn())

   766                 logger.debug("unregisterMBean", "name=" + name);

   767 

   768             final ClassLoader old = pushDefaultClassLoader();

   769             try {

   770                 connection.unregisterMBean(name, delegationSubject);

   771             } catch (IOException ioe) {

   772                 communicatorAdmin.gotIOException(ioe);

   773 

   774                 connection.unregisterMBean(name, delegationSubject);

   775             } finally {

   776                 popDefaultClassLoader(old);

   777             }

   778         }

   779 

   780         public ObjectInstance getObjectInstance(ObjectName name)

   781         throws InstanceNotFoundException,

   782                 IOException {

   783             if (logger.debugOn())

   784                 logger.debug("getObjectInstance", "name=" + name);

   785 

   786             final ClassLoader old = pushDefaultClassLoader();

   787             try {

   788                 return connection.getObjectInstance(name, delegationSubject);

   789             } catch (IOException ioe) {

   790                 communicatorAdmin.gotIOException(ioe);

   791 

   792                 return connection.getObjectInstance(name, delegationSubject);

   793             } finally {

   794                 popDefaultClassLoader(old);

   795             }

   796         }

   797 

   798         public Set<ObjectInstance> queryMBeans(ObjectName name,

   799                 QueryExp query)

   800                 throws IOException {

   801             if (logger.debugOn()) logger.debug("queryMBeans",

   802                     "name=" + name + ", query=" + query);

   803 

   804             final MarshalledObject<QueryExp> sQuery =

   805                     new MarshalledObject<QueryExp>(query);

   806             final ClassLoader old = pushDefaultClassLoader();

   807             try {

   808                 return connection.queryMBeans(name, sQuery, delegationSubject);

   809             } catch (IOException ioe) {

   810                 communicatorAdmin.gotIOException(ioe);

   811 

   812                 return connection.queryMBeans(name, sQuery, delegationSubject);

   813             } finally {

   814                 popDefaultClassLoader(old);

   815             }

   816         }

   817 

   818         public Set<ObjectName> queryNames(ObjectName name,

   819                 QueryExp query)

   820                 throws IOException {

   821             if (logger.debugOn()) logger.debug("queryNames",

   822                     "name=" + name + ", query=" + query);

   823 

   824             final MarshalledObject<QueryExp> sQuery =

   825                     new MarshalledObject<QueryExp>(query);

   826             final ClassLoader old = pushDefaultClassLoader();

   827             try {

   828                 return connection.queryNames(name, sQuery, delegationSubject);

   829             } catch (IOException ioe) {

   830                 communicatorAdmin.gotIOException(ioe);

   831 

   832                 return connection.queryNames(name, sQuery, delegationSubject);

   833             } finally {

   834                 popDefaultClassLoader(old);

   835             }

   836         }

   837 

   838         public boolean isRegistered(ObjectName name)

   839         throws IOException {

   840             if (logger.debugOn())

   841                 logger.debug("isRegistered", "name=" + name);

   842 

   843             final ClassLoader old = pushDefaultClassLoader();

   844             try {

   845                 return connection.isRegistered(name, delegationSubject);

   846             } catch (IOException ioe) {

   847                 communicatorAdmin.gotIOException(ioe);

   848 

   849                 return connection.isRegistered(name, delegationSubject);

   850             } finally {

   851                 popDefaultClassLoader(old);

   852             }

   853         }

   854 

   855         public Integer getMBeanCount()

   856         throws IOException {

   857             if (logger.debugOn()) logger.debug("getMBeanCount", "");

   858 

   859             final ClassLoader old = pushDefaultClassLoader();

   860             try {

   861                 return connection.getMBeanCount(delegationSubject);

   862             } catch (IOException ioe) {

   863                 communicatorAdmin.gotIOException(ioe);

   864 

   865                 return connection.getMBeanCount(delegationSubject);

   866             } finally {

   867                 popDefaultClassLoader(old);

   868             }

   869         }

   870 

   871         public Object getAttribute(ObjectName name,

   872                 String attribute)

   873                 throws MBeanException,

   874                 AttributeNotFoundException,

   875                 InstanceNotFoundException,

   876                 ReflectionException,

   877                 IOException {

   878             if (logger.debugOn()) logger.debug("getAttribute",

   879                     "name=" + name + ", attribute="

   880                     + attribute);

   881 

   882             final ClassLoader old = pushDefaultClassLoader();

   883             try {

   884                 return connection.getAttribute(name,

   885                         attribute,

   886                         delegationSubject);

   887             } catch (IOException ioe) {

   888                 communicatorAdmin.gotIOException(ioe);

   889 

   890                 return connection.getAttribute(name,

   891                         attribute,

   892                         delegationSubject);

   893             } finally {

   894                 popDefaultClassLoader(old);

   895             }

   896         }

   897 

   898         public AttributeList getAttributes(ObjectName name,

   899                 String[] attributes)

   900                 throws InstanceNotFoundException,

   901                 ReflectionException,

   902                 IOException {

   903             if (logger.debugOn()) logger.debug("getAttributes",

   904                     "name=" + name + ", attributes="

   905                     + strings(attributes));

   906 

   907             final ClassLoader old = pushDefaultClassLoader();

   908             try {

   909                 return connection.getAttributes(name,

   910                         attributes,

   911                         delegationSubject);

   912 

   913             } catch (IOException ioe) {

   914                 communicatorAdmin.gotIOException(ioe);

   915 

   916                 return connection.getAttributes(name,

   917                         attributes,

   918                         delegationSubject);

   919             } finally {

   920                 popDefaultClassLoader(old);

   921             }

   922         }

   923 

   924 

   925         public void setAttribute(ObjectName name,

   926                 Attribute attribute)

   927                 throws InstanceNotFoundException,

   928                 AttributeNotFoundException,

   929                 InvalidAttributeValueException,

   930                 MBeanException,

   931                 ReflectionException,

   932                 IOException {

   933 

   934             if (logger.debugOn()) logger.debug("setAttribute",

   935                     "name=" + name + ", attribute name="

   936                     + attribute.getName());

   937 

   938             final MarshalledObject<Attribute> sAttribute =

   939                     new MarshalledObject<Attribute>(attribute);

   940             final ClassLoader old = pushDefaultClassLoader();

   941             try {

   942                 connection.setAttribute(name, sAttribute, delegationSubject);

   943             } catch (IOException ioe) {

   944                 communicatorAdmin.gotIOException(ioe);

   945 

   946                 connection.setAttribute(name, sAttribute, delegationSubject);

   947             } finally {

   948                 popDefaultClassLoader(old);

   949             }

   950         }

   951 

   952         public AttributeList setAttributes(ObjectName name,

   953                 AttributeList attributes)

   954                 throws InstanceNotFoundException,

   955                 ReflectionException,

   956                 IOException {

   957 

   958             if (logger.debugOn()) {

   959                 logger.debug("setAttributes",

   960                     "name=" + name + ", attribute names="

   961                     + getAttributesNames(attributes));

   962             }

   963 

   964             final MarshalledObject<AttributeList> sAttributes =

   965                     new MarshalledObject<AttributeList>(attributes);

   966             final ClassLoader old = pushDefaultClassLoader();

   967             try {

   968                 return connection.setAttributes(name,

   969                         sAttributes,

   970                         delegationSubject);

   971             } catch (IOException ioe) {

   972                 communicatorAdmin.gotIOException(ioe);

   973 

   974                 return connection.setAttributes(name,

   975                         sAttributes,

   976                         delegationSubject);

   977             } finally {

   978                 popDefaultClassLoader(old);

   979             }

   980         }

   981 

   982 

   983         public Object invoke(ObjectName name,

   984                 String operationName,

   985                 Object params[],

   986                 String signature[])

   987                 throws InstanceNotFoundException,

   988                 MBeanException,

   989                 ReflectionException,

   990                 IOException {

   991 

   992             if (logger.debugOn()) logger.debug("invoke",

   993                     "name=" + name

   994                     + ", operationName=" + operationName

   995                     + ", signature=" + strings(signature));

   996 

   997             final MarshalledObject<Object[]> sParams =

   998                     new MarshalledObject<Object[]>(params);

   999             final ClassLoader old = pushDefaultClassLoader();

  1000             try {

  1001                 return connection.invoke(name,

  1002                         operationName,

  1003                         sParams,

  1004                         signature,

  1005                         delegationSubject);

  1006             } catch (IOException ioe) {

  1007                 communicatorAdmin.gotIOException(ioe);

  1008 

  1009                 return connection.invoke(name,

  1010                         operationName,

  1011                         sParams,

  1012                         signature,

  1013                         delegationSubject);

  1014             } finally {

  1015                 popDefaultClassLoader(old);

  1016             }

  1017         }

  1018 

  1019 

  1020         public String getDefaultDomain()

  1021         throws IOException {

  1022             if (logger.debugOn()) logger.debug("getDefaultDomain", "");

  1023 

  1024             final ClassLoader old = pushDefaultClassLoader();

  1025             try {

  1026                 return connection.getDefaultDomain(delegationSubject);

  1027             } catch (IOException ioe) {

  1028                 communicatorAdmin.gotIOException(ioe);

  1029 

  1030                 return connection.getDefaultDomain(delegationSubject);

  1031             } finally {

  1032                 popDefaultClassLoader(old);

  1033             }

  1034         }

  1035 

  1036         public String[] getDomains() throws IOException {

  1037             if (logger.debugOn()) logger.debug("getDomains", "");

  1038 

  1039             final ClassLoader old = pushDefaultClassLoader();

  1040             try {

  1041                 return connection.getDomains(delegationSubject);

  1042             } catch (IOException ioe) {

  1043                 communicatorAdmin.gotIOException(ioe);

  1044 

  1045                 return connection.getDomains(delegationSubject);

  1046             } finally {

  1047                 popDefaultClassLoader(old);

  1048             }

  1049         }

  1050 

  1051         public MBeanInfo getMBeanInfo(ObjectName name)

  1052         throws InstanceNotFoundException,

  1053                 IntrospectionException,

  1054                 ReflectionException,

  1055                 IOException {

  1056 

  1057             if (logger.debugOn()) logger.debug("getMBeanInfo", "name=" + name);

  1058             final ClassLoader old = pushDefaultClassLoader();

  1059             try {

  1060                 return connection.getMBeanInfo(name, delegationSubject);

  1061             } catch (IOException ioe) {

  1062                 communicatorAdmin.gotIOException(ioe);

  1063 

  1064                 return connection.getMBeanInfo(name, delegationSubject);

  1065             } finally {

  1066                 popDefaultClassLoader(old);

  1067             }

  1068         }

  1069 

  1070 

  1071         public boolean isInstanceOf(ObjectName name,

  1072                 String className)

  1073                 throws InstanceNotFoundException,

  1074                 IOException {

  1075             if (logger.debugOn())

  1076                 logger.debug("isInstanceOf", "name=" + name +

  1077                         ", className=" + className);

  1078 

  1079             final ClassLoader old = pushDefaultClassLoader();

  1080             try {

  1081                 return connection.isInstanceOf(name,

  1082                         className,

  1083                         delegationSubject);

  1084             } catch (IOException ioe) {

  1085                 communicatorAdmin.gotIOException(ioe);

  1086 

  1087                 return connection.isInstanceOf(name,

  1088                         className,

  1089                         delegationSubject);

  1090             } finally {

  1091                 popDefaultClassLoader(old);

  1092             }

  1093         }

  1094 

  1095         public void addNotificationListener(ObjectName name,

  1096                 ObjectName listener,

  1097                 NotificationFilter filter,

  1098                 Object handback)

  1099                 throws InstanceNotFoundException,

  1100                 IOException {

  1101 

  1102             if (logger.debugOn())

  1103                 logger.debug("addNotificationListener" +

  1104                         "(ObjectName,ObjectName,NotificationFilter,Object)",

  1105                         "name=" + name + ", listener=" + listener

  1106                         + ", filter=" + filter + ", handback=" + handback);

  1107 

  1108             final MarshalledObject<NotificationFilter> sFilter =

  1109                     new MarshalledObject<NotificationFilter>(filter);

  1110             final MarshalledObject<Object> sHandback =

  1111                     new MarshalledObject<Object>(handback);

  1112             final ClassLoader old = pushDefaultClassLoader();

  1113             try {

  1114                 connection.addNotificationListener(name,

  1115                         listener,

  1116                         sFilter,

  1117                         sHandback,

  1118                         delegationSubject);

  1119             } catch (IOException ioe) {

  1120                 communicatorAdmin.gotIOException(ioe);

  1121 

  1122                 connection.addNotificationListener(name,

  1123                         listener,

  1124                         sFilter,

  1125                         sHandback,

  1126                         delegationSubject);

  1127             } finally {

  1128                 popDefaultClassLoader(old);

  1129             }

  1130         }

  1131 

  1132         public void removeNotificationListener(ObjectName name,

  1133                 ObjectName listener)

  1134                 throws InstanceNotFoundException,