307 lines
8.9 KiB
Java
307 lines
8.9 KiB
Java
![]() |
/* UnicastServerRef.java --
|
||
|
Copyright (c) 1996, 1997, 1998, 1999, 2002, 2003, 2004
|
||
|
Free Software Foundation, Inc.
|
||
|
|
||
|
This file is part of GNU Classpath.
|
||
|
|
||
|
GNU Classpath is free software; you can redistribute it and/or modify
|
||
|
it under the terms of the GNU General Public License as published by
|
||
|
the Free Software Foundation; either version 2, or (at your option)
|
||
|
any later version.
|
||
|
|
||
|
GNU Classpath 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 for more details.
|
||
|
|
||
|
You should have received a copy of the GNU General Public License
|
||
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
||
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
||
|
02110-1301 USA.
|
||
|
|
||
|
Linking this library statically or dynamically with other modules is
|
||
|
making a combined work based on this library. Thus, the terms and
|
||
|
conditions of the GNU General Public License cover the whole
|
||
|
combination.
|
||
|
|
||
|
As a special exception, the copyright holders of this library give you
|
||
|
permission to link this library with independent modules to produce an
|
||
|
executable, regardless of the license terms of these independent
|
||
|
modules, and to copy and distribute the resulting executable under
|
||
|
terms of your choice, provided that you also meet, for each linked
|
||
|
independent module, the terms and conditions of the license of that
|
||
|
module. An independent module is a module which is not derived from
|
||
|
or based on this library. If you modify this library, you may extend
|
||
|
this exception to your version of the library, but you are not
|
||
|
obligated to do so. If you do not wish to do so, delete this
|
||
|
exception statement from your version. */
|
||
|
|
||
|
|
||
|
package gnu.java.rmi.server;
|
||
|
|
||
|
import java.io.ObjectInputStream;
|
||
|
import java.lang.reflect.Constructor;
|
||
|
import java.lang.reflect.InvocationTargetException;
|
||
|
import java.lang.reflect.Method;
|
||
|
import java.rmi.Remote;
|
||
|
import java.rmi.RemoteException;
|
||
|
import java.rmi.server.ObjID;
|
||
|
import java.rmi.server.RMIServerSocketFactory;
|
||
|
import java.rmi.server.RemoteRef;
|
||
|
import java.rmi.server.RemoteServer;
|
||
|
import java.rmi.server.RemoteStub;
|
||
|
import java.rmi.server.ServerNotActiveException;
|
||
|
import java.rmi.server.ServerRef;
|
||
|
import java.rmi.server.Skeleton;
|
||
|
import java.util.Hashtable;
|
||
|
|
||
|
public class UnicastServerRef
|
||
|
extends UnicastRef
|
||
|
implements ServerRef{ //SHOULD implement ServerRef
|
||
|
|
||
|
final static private Class[] stubprototype = new Class[] { RemoteRef.class };
|
||
|
|
||
|
Remote myself; //save the remote object itself
|
||
|
private Skeleton skel;
|
||
|
private RemoteStub stub;
|
||
|
private Hashtable methods = new Hashtable();
|
||
|
|
||
|
/**
|
||
|
* Used by serialization.
|
||
|
*/
|
||
|
UnicastServerRef()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
public UnicastServerRef(ObjID id, int port, RMIServerSocketFactory ssf) throws RemoteException {
|
||
|
super(id);
|
||
|
manager = UnicastConnectionManager.getInstance(port, ssf);
|
||
|
}
|
||
|
|
||
|
public RemoteStub exportObject(Remote obj) throws RemoteException {
|
||
|
if (myself == null) {
|
||
|
myself = obj;
|
||
|
// Save it to server manager, to let client calls in the same VM to issue
|
||
|
// local call
|
||
|
manager.serverobj = obj;
|
||
|
|
||
|
// Find and install the stub
|
||
|
Class cls = obj.getClass();
|
||
|
Class expCls;
|
||
|
try {
|
||
|
// where ist the _Stub? (check superclasses also)
|
||
|
expCls = findStubSkelClass(cls);
|
||
|
} catch (Exception ex) {
|
||
|
throw new RemoteException("can not find stubs for class: " + cls, ex);
|
||
|
}
|
||
|
|
||
|
stub = (RemoteStub)getHelperClass(expCls, "_Stub");
|
||
|
if (stub == null) {
|
||
|
throw new RemoteException("failed to export: " + cls);
|
||
|
}
|
||
|
|
||
|
// Find and install the skeleton (if there is one)
|
||
|
skel = (Skeleton)getHelperClass(expCls, "_Skel");
|
||
|
|
||
|
// Build hash of methods which may be called.
|
||
|
buildMethodHash(obj.getClass(), true);
|
||
|
|
||
|
// Export it.
|
||
|
UnicastServer.exportObject(this);
|
||
|
}
|
||
|
|
||
|
return (stub);
|
||
|
}
|
||
|
|
||
|
public RemoteStub exportObject(Remote remote, Object obj)
|
||
|
throws RemoteException
|
||
|
{
|
||
|
//FIX ME
|
||
|
return exportObject(remote);
|
||
|
}
|
||
|
|
||
|
public RemoteStub getStub(){
|
||
|
return stub;
|
||
|
}
|
||
|
|
||
|
|
||
|
public boolean unexportObject(Remote obj, boolean force) {
|
||
|
// Remove all hashes of methods which may be called.
|
||
|
buildMethodHash(obj.getClass(), false);
|
||
|
return UnicastServer.unexportObject(this, force);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
*
|
||
|
* The Subs/Skels might not there for the actual class, but maybe
|
||
|
* for one of the superclasses.
|
||
|
*
|
||
|
*/
|
||
|
private Class findStubSkelClass(Class startCls) throws Exception {
|
||
|
Class cls = startCls;
|
||
|
|
||
|
while (true) {
|
||
|
try {
|
||
|
String stubClassname = cls.getName() + "_Stub";
|
||
|
ClassLoader cl = cls.getClassLoader();
|
||
|
Class scls = cl == null ? Class.forName(stubClassname)
|
||
|
: cl.loadClass(stubClassname);
|
||
|
return cls; // found it
|
||
|
} catch (ClassNotFoundException e) {
|
||
|
Class superCls = cls.getSuperclass();
|
||
|
if (superCls == null
|
||
|
|| superCls == java.rmi.server.UnicastRemoteObject.class)
|
||
|
{
|
||
|
throw new Exception("Neither " + startCls
|
||
|
+ " nor one of their superclasses (like" + cls + ")"
|
||
|
+ " has a _Stub");
|
||
|
}
|
||
|
cls = superCls;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
private Object getHelperClass(Class cls, String type) {
|
||
|
try {
|
||
|
String classname = cls.getName();
|
||
|
ClassLoader cl = cls.getClassLoader();
|
||
|
Class scls = cl == null ? Class.forName(classname + type)
|
||
|
: cl.loadClass(classname + type);
|
||
|
if (type.equals("_Stub")) {
|
||
|
try {
|
||
|
// JDK 1.2 stubs
|
||
|
Constructor con = scls.getConstructor(stubprototype);
|
||
|
return (con.newInstance(new Object[]{this}));
|
||
|
}
|
||
|
catch (NoSuchMethodException e) {
|
||
|
}
|
||
|
catch (InstantiationException e) {
|
||
|
}
|
||
|
catch (IllegalAccessException e) {
|
||
|
}
|
||
|
catch (IllegalArgumentException e) {
|
||
|
}
|
||
|
catch (InvocationTargetException e) {
|
||
|
}
|
||
|
// JDK 1.1 stubs
|
||
|
RemoteStub stub = (RemoteStub)scls.newInstance();
|
||
|
UnicastRemoteStub.setStubRef(stub, this);
|
||
|
return (stub);
|
||
|
}
|
||
|
else {
|
||
|
// JDK 1.1 skel
|
||
|
return (scls.newInstance());
|
||
|
}
|
||
|
}
|
||
|
catch (ClassNotFoundException e) {
|
||
|
}
|
||
|
catch (InstantiationException e) {
|
||
|
}
|
||
|
catch (IllegalAccessException e) {
|
||
|
}
|
||
|
return (null);
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
public String getClientHost() throws ServerNotActiveException {
|
||
|
return RemoteServer.getClientHost();
|
||
|
}
|
||
|
|
||
|
private void buildMethodHash(Class cls, boolean build) {
|
||
|
Method[] meths = cls.getMethods();
|
||
|
for (int i = 0; i < meths.length; i++) {
|
||
|
/* Don't need to include any java.xxx related stuff */
|
||
|
if (meths[i].getDeclaringClass().getName().startsWith("java.")) {
|
||
|
continue;
|
||
|
}
|
||
|
long hash = RMIHashes.getMethodHash(meths[i]);
|
||
|
if(build)
|
||
|
methods.put(new Long (hash), meths[i]);
|
||
|
else
|
||
|
methods.remove(new Long (hash));
|
||
|
//System.out.println("meth = " + meths[i] + ", hash = " + hash);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
Class getMethodReturnType(int method, long hash) throws Exception
|
||
|
{
|
||
|
if (method == -1) {
|
||
|
Method meth = (Method)methods.get(new Long (hash));
|
||
|
return meth.getReturnType();
|
||
|
}else
|
||
|
return null;
|
||
|
}
|
||
|
|
||
|
public Object incomingMessageCall(UnicastConnection conn, int method, long hash) throws Exception {
|
||
|
//System.out.println("method = " + method + ", hash = " + hash);
|
||
|
// If method is -1 then this is JDK 1.2 RMI - so use the hash
|
||
|
// to locate the method
|
||
|
if (method == -1) {
|
||
|
Method meth = (Method)methods.get(new Long (hash));
|
||
|
//System.out.println("class = " + myself.getClass() + ", meth = " + meth);
|
||
|
if (meth == null) {
|
||
|
throw new NoSuchMethodException();
|
||
|
}
|
||
|
|
||
|
ObjectInputStream in = conn.getObjectInputStream();
|
||
|
int nrargs = meth.getParameterTypes().length;
|
||
|
Object[] args = new Object[nrargs];
|
||
|
for (int i = 0; i < nrargs; i++) {
|
||
|
/**
|
||
|
* For debugging purposes - we don't handle CodeBases
|
||
|
* quite right so we don't always find the stubs. This
|
||
|
* lets us know that.
|
||
|
*/
|
||
|
try {
|
||
|
// need to handle primitive types
|
||
|
args[i] = ((RMIObjectInputStream)in).readValue(meth.getParameterTypes()[i]);
|
||
|
|
||
|
}
|
||
|
catch (Exception t) {
|
||
|
t.printStackTrace();
|
||
|
throw t;
|
||
|
}
|
||
|
}
|
||
|
//We must reinterpret the exception thrown by meth.invoke()
|
||
|
//return (meth.invoke(myself, args));
|
||
|
Object ret = null;
|
||
|
try{
|
||
|
ret = meth.invoke(myself, args);
|
||
|
}catch(InvocationTargetException e){
|
||
|
Throwable cause = e.getTargetException();
|
||
|
if (cause instanceof Exception) {
|
||
|
throw (Exception)cause;
|
||
|
}
|
||
|
else if (cause instanceof Error) {
|
||
|
throw (Error)cause;
|
||
|
}
|
||
|
else {
|
||
|
throw new Error("The remote method threw a java.lang.Throwable that is neither java.lang.Exception nor java.lang.Error.", e);
|
||
|
}
|
||
|
}
|
||
|
return ret;
|
||
|
}
|
||
|
// Otherwise this is JDK 1.1 style RMI - we find the skeleton
|
||
|
// and invoke it using the method number. We wrap up our
|
||
|
// connection system in a UnicastRemoteCall so it appears in a
|
||
|
// way the Skeleton can handle.
|
||
|
else {
|
||
|
if (skel == null) {
|
||
|
throw new NoSuchMethodException();
|
||
|
}
|
||
|
UnicastRemoteCall call = new UnicastRemoteCall(conn);
|
||
|
skel.dispatch(myself, call, method, hash);
|
||
|
if (!call.isReturnValue())
|
||
|
return RMIVoidValue.INSTANCE;
|
||
|
else
|
||
|
return (call.returnValue());
|
||
|
}
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
|