Back to index...

	/*
	* Copyright (c) 1999, 2011, 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.jndi.toolkit.corba;

	// Needed for RMI/IIOP
	import java.rmi.Remote;

	import java.lang.reflect.Method;
	import java.lang.reflect.InvocationTargetException;
	import java.util.Hashtable;
	import java.util.Properties;
	import java.util.Enumeration;

	import org.omg.CORBA.ORB;

	import javax.naming.*;

	import com.sun.jndi.cosnaming.CNCtx;

	/**
	* Contains utilities for performing CORBA-related tasks:
	* 1. Get the org.omg.CORBA.Object for a java.rmi.Remote object.
	* 2. Create an ORB to use for a given host/port, and environment properties.
	*
	* @author Simon Nash
	* @author Bryan Atsatt
	*/

	public class CorbaUtils {
	/**
	* Returns the CORBA object reference associated with a Remote
	* object by using the javax.rmi.CORBA package.
	*<p>
	* Use reflection to avoid hard dependencies on javax.rmi.CORBA package.
	* This method effective does the following:
	*<blockquote><pre>
	* java.lang.Object stub;
	* try {
	* stub = PortableRemoteObject.toStub(remoteObj);
	* } catch (Exception e) {
	* throw new ConfigurationException("Object not exported or not found");
	* }
	* if (!(stub instanceof javax.rmi.CORBA.Stub)) {
	* return null; // JRMP impl or JRMP stub
	* }
	* try {
	* ((javax.rmi.CORBA.Stub)stub).connect(orb); // try to connect IIOP stub
	* } catch (RemoteException e) {
	* // ignore 'already connected' error
	* }
	* return (javax.rmi.CORBA.Stub)stub;
	*
	* @param remoteObj The non-null remote object for
	* @param orb The non-null ORB to connect the remote object to
	* @return The CORBA Object for remoteObj; null if <tt>remoteObj</tt>
	* is a JRMP implementation or JRMP stub.
	* @exception ClassNotFoundException The RMI-IIOP package is not available
	* @exception ConfigurationException The CORBA Object cannot be obtained
	* because of configuration problems.
	*/
	public static org.omg.CORBA.Object remoteToCorba(Remote remoteObj, ORB orb)
	throws ClassNotFoundException, ConfigurationException {
	synchronized (CorbaUtils.class) {
	if (toStubMethod == null) {
	initMethodHandles();
	}
	}

	// First, get remoteObj's stub

	// javax.rmi.CORBA.Stub stub = PortableRemoteObject.toStub(remoteObj);

	java.lang.Object stub;

	try {
	stub = toStubMethod.invoke(null, new java.lang.Object[]{remoteObj});

	} catch (InvocationTargetException e) {
	Throwable realException = e.getTargetException();
	// realException.printStackTrace();

	ConfigurationException ce = new ConfigurationException(
	"Problem with PortableRemoteObject.toStub(); object not exported or stub not found");
	ce.setRootCause(realException);
	throw ce;

	} catch (IllegalAccessException e) {
	ConfigurationException ce = new ConfigurationException(
	"Cannot invoke javax.rmi.PortableRemoteObject.toStub(java.rmi.Remote)");

	ce.setRootCause(e);
	throw ce;
	}

	// Next, make sure that the stub is javax.rmi.CORBA.Stub

	if (!corbaStubClass.isInstance(stub)) {
	return null; // JRMP implementation or JRMP stub
	}

	// Next, make sure that the stub is connected
	// Invoke stub.connect(orb)
	try {
	connectMethod.invoke(stub, new java.lang.Object[]{orb});

	} catch (InvocationTargetException e) {
	Throwable realException = e.getTargetException();
	// realException.printStackTrace();

	if (!(realException instanceof java.rmi.RemoteException)) {
	ConfigurationException ce = new ConfigurationException(
	"Problem invoking javax.rmi.CORBA.Stub.connect()");
	ce.setRootCause(realException);
	throw ce;
	}
	// ignore RemoteException because stub might have already
	// been connected
	} catch (IllegalAccessException e) {
	ConfigurationException ce = new ConfigurationException(
	"Cannot invoke javax.rmi.CORBA.Stub.connect()");
	ce.setRootCause(e);
	throw ce;
	}
	// Finally, return stub
	return (org.omg.CORBA.Object)stub;
	}

	/**
	* Get ORB using given server and port number, and properties from environment.
	*
	* @param server Possibly null server; if null means use default;
	* For applet, it is the applet host; for app, it is localhost.
	* @param port Port number, -1 means default port
	* @param env Possibly null environment. Contains environment properties.
	* Could contain ORB itself; or applet used for initializing ORB.
	* Use all String properties from env for initializing ORB
	* @return A non-null ORB.
	*/
	public static ORB getOrb(String server, int port, Hashtable<?,?> env) {
	// See if we can get info from environment
	Properties orbProp;

	// Extract any org.omg.CORBA properties from environment
	if (env != null) {
	if (env instanceof Properties) {
	// Already a Properties, just clone
	orbProp = (Properties) env.clone();
	} else {
	// Get all String properties
	Enumeration<?> envProp;
	orbProp = new Properties();
	for (envProp = env.keys(); envProp.hasMoreElements();) {
	String key = (String)envProp.nextElement();
	Object val = env.get(key);
	if (val instanceof String) {
	orbProp.put(key, val);
	}
	}
	}
	} else {
	orbProp = new Properties();
	}

	if (server != null) {
	orbProp.put("org.omg.CORBA.ORBInitialHost", server);
	}
	if (port >= 0) {
	orbProp.put("org.omg.CORBA.ORBInitialPort", ""+port);
	}

	// Get Applet from environment
	if (env != null) {
	Object applet = env.get(Context.APPLET);
	if (applet != null) {
	// Create ORBs for an applet
	return initAppletORB(applet, orbProp);
	}
	}

	// Create ORBs using orbProp for a standalone application
	return ORB.init(new String[0], orbProp);
	}

	/**
	* Check whether object factory code base is trusted.
	* Classes may only be loaded from an arbitrary URL code base when
	* the system property com.sun.jndi.rmi.object.trustURLCodebase
	* has been set to "true".
	*/
	public static boolean isObjectFactoryTrusted(Object obj)
	throws NamingException {

	// Extract Reference, if possible
	Reference ref = null;
	if (obj instanceof Reference) {
	ref = (Reference) obj;
	} else if (obj instanceof Referenceable) {
	ref = ((Referenceable)(obj)).getReference();
	}

	if (ref != null && ref.getFactoryClassLocation() != null &&
	!CNCtx.trustURLCodebase) {
	throw new ConfigurationException(
	"The object factory is untrusted. Set the system property" +
	" 'com.sun.jndi.cosnaming.object.trustURLCodebase' to 'true'.");
	}
	return true;
	}

	/**
	* This method returns a new ORB instance for the given applet
	* without creating a static dependency on java.applet.
	*/
	private static ORB initAppletORB(Object applet, Properties orbProp) {
	try {
	Class<?> appletClass = Class.forName("java.applet.Applet", true, null);
	if (!appletClass.isInstance(applet)) {
	throw new ClassCastException(applet.getClass().getName());
	}

	// invoke the static method ORB.init(applet, orbProp);
	Method method = ORB.class.getMethod("init", appletClass, Properties.class);
	return (ORB) method.invoke(null, applet, orbProp);
	} catch (ClassNotFoundException e) {
	// java.applet.Applet doesn't exist and the applet parameter is
	// non-null; so throw CCE
	throw new ClassCastException(applet.getClass().getName());
	} catch (NoSuchMethodException e) {
	throw new AssertionError(e);
	} catch (InvocationTargetException e) {
	Throwable cause = e.getCause();
	if (cause instanceof RuntimeException) {
	throw (RuntimeException) cause;
	} else if (cause instanceof Error) {
	throw (Error) cause;
	}
	throw new AssertionError(e);
	} catch (IllegalAccessException iae) {
	throw new AssertionError(iae);
	}
	}

	// Fields used for reflection of RMI-IIOP
	private static Method toStubMethod = null;
	private static Method connectMethod = null;
	private static Class<?> corbaStubClass = null;
	/**
	* Initializes reflection method handles for RMI-IIOP.
	* @exception ClassNotFoundException javax.rmi.CORBA.* not available
	*/
	private static void initMethodHandles() throws ClassNotFoundException {
	// Get javax.rmi.CORBA.Stub class
	corbaStubClass = Class.forName("javax.rmi.CORBA.Stub");

	// Get javax.rmi.CORBA.Stub.connect(org.omg.CORBA.ORB) method

	try {
	connectMethod = corbaStubClass.getMethod("connect",
	new Class<?>[] {org.omg.CORBA.ORB.class});
	} catch (NoSuchMethodException e) {
	throw new IllegalStateException(
	"No method definition for javax.rmi.CORBA.Stub.connect(org.omg.CORBA.ORB)");
	}

	// Get javax.rmi.PortableRemoteObject class
	Class<?> proClass = Class.forName("javax.rmi.PortableRemoteObject");

	// Get javax.rmi.PortableRemoteObject.toStub(java.rmi.Remote) method
	try {
	toStubMethod = proClass.getMethod("toStub",
	new Class<?>[] {java.rmi.Remote.class});

	} catch (NoSuchMethodException e) {
	throw new IllegalStateException(
	"No method definition for javax.rmi.PortableRemoteObject.toStub(java.rmi.Remote)");
	}
	}
	}

Back to index...