FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Activatable.java, [...]: RMI implementation from Kaffe.

Browse source 
* java/rmi/activation/Activatable.java,
	java/rmi/activation/ActivateFailedException.java,
	java/rmi/activation/ActivationDesc.java,
	java/rmi/activation/ActivationException.java,
	java/rmi/activation/ActivationGroup.java,
	java/rmi/activation/ActivationGroupDesc.java,
	java/rmi/activation/ActivationGroupID.java,
	java/rmi/activation/ActivationID.java,
	java/rmi/activation/ActivationInstantiator.java,
	java/rmi/activation/ActivationMonitor.java,
	java/rmi/activation/ActivationSystem.java,
	java/rmi/activation/Activator.java,
	java/rmi/activation/UnknownGroupException.java,
	java/rmi/activation/UnknownObjectException.java,
	java/rmi/AccessException.java,
	java/rmi/AlreadyBoundException.java,
	java/rmi/ConnectException.java, java/rmi/ConnectIOException.java,
	java/rmi/MarshalException.java, java/rmi/MarshalledObject.java,
	java/rmi/Naming.java, java/rmi/NoSuchObjectException.java,
	java/rmi/NotBoundException.java,
	java/rmi/RMISecurityException.java,
	java/rmi/RMISecurityManager.java, java/rmi/Remote.java,
	java/rmi/RemoteException.java, java/rmi/ServerError.java,
	java/rmi/ServerException.java,
	java/rmi/ServerRuntimeException.java,
	java/rmi/StubNotFoundException.java,
	java/rmi/UnexpectedException.java,
	java/rmi/UnknownHostException.java,
	java/rmi/UnmarshalException.java, java/rmi/dgc/DGC.java,
	java/rmi/dgc/Lease.java, java/rmi/dgc/VMID.java,
	java/rmi/registry/LocateRegistry.java,
	java/rmi/registry/Registry.java,
	java/rmi/registry/RegistryHandler.java,
	java/rmi/server/ExportException.java,
	java/rmi/server/LoaderHandler.java,
	java/rmi/server/LogStream.java, java/rmi/server/ObjID.java,
	java/rmi/server/Operation.java,
	java/rmi/server/RMIClassLoader.java,
	java/rmi/server/RMIClientSocketFactory.java,
	java/rmi/server/RMIFailureHandler.java,
	java/rmi/server/RMIServerSocketFactory.java,
	java/rmi/server/RMISocketFactory.java,
	java/rmi/server/RemoteCall.java,
	java/rmi/server/RemoteObject.java, java/rmi/server/RemoteRef.java,
	java/rmi/server/RemoteServer.java,
	java/rmi/server/RemoteStub.java,
	java/rmi/server/ServerCloneException.java,
	java/rmi/server/ServerNotActiveException.java,
	java/rmi/server/ServerRef.java, java/rmi/server/Skeleton.java,
	java/rmi/server/SkeletonMismatchException.java,
	java/rmi/server/SkeletonNotFoundException.java,
	java/rmi/server/SocketSecurityException.java,
	java/rmi/server/UID.java,
	java/rmi/server/UnicastRemoteObject.java,
	java/rmi/server/Unreferenced.java, gnu/java/rmi/dgc/DGCImpl.java,
	gnu/java/rmi/dgc/DGCImpl_Skel.java,
	gnu/java/rmi/dgc/DGCImpl_Stub.java,
	gnu/java/rmi/registry/RegistryImpl.java,
	gnu/java/rmi/registry/RegistryImpl_Skel.java,
	gnu/java/rmi/registry/RegistryImpl_Stub.java,
	gnu/java/rmi/rmic/RMIC.java, gnu/java/rmi/rmic/TabbedWriter.java,
	gnu/java/rmi/server/ProtocolConstants.java,
	gnu/java/rmi/server/RMIDefaultSocketFactory.java,
	gnu/java/rmi/server/RMIHashes.java,
	gnu/java/rmi/server/RMIObjectInputStream.java,
	gnu/java/rmi/server/RMIObjectOutputStream.java,
	gnu/java/rmi/server/UnicastConnection.java,
	gnu/java/rmi/server/UnicastConnectionManager.java,
	gnu/java/rmi/server/UnicastRef.java,
	gnu/java/rmi/server/UnicastRemoteCall.java,
	gnu/java/rmi/server/UnicastRemoteStub.java,
	gnu/java/rmi/server/UnicastServer.java,
	gnu/java/rmi/server/UnicastServerRef.java: RMI implementation from
	Kaffe.  Relabelled classes to fit into Classpath tree.
	* Makefile.in: Rebuilt.
	* Makefile.am (rmi_java_source_files): New macro.
	(ordinary_java_source_files): Reference it.
	(bin_PROGRAMS): Added rmic and rmiregistry.
	(rmic_SOURCES): New macro.
	(EXTRA_rmic_SOURCES): Likewise.
	(rmic_LDFLAGS): Likewise.
	(rmic_LINK): Likewise.
	(rmic_LDADD): Likewise.
	(rmic_DEPENDENCIES): Likewise.
	(rmiregistry_SOURCES): New macro.
	(EXTRA_rmiregistry_SOURCES): Likewise.
	(rmiregistry_LDFLAGS): Likewise.
	(rmiregistry_LINK): Likewise.
	(rmiregistry_LDADD): Likewise.
	(rmiregistry_DEPENDENCIES): Likewise.

From-SVN: r45218
This commit is contained in:
Tom Tromey 2001-08-28 00:03:35 +00:00 • committed by Tom Tromey
parent c5bb59c118
commit 83e7315b5f
88 changed files with 8583 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

55
libjava/gnu/java/rmi/dgc/DGCImpl.java Normal file
View file

@ -0,0 +1,55 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.dgc;
import java.rmi.dgc.DGC;
import java.rmi.dgc.Lease;
import java.rmi.dgc.VMID;
import java.rmi.server.ObjID;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.rmi.server.RMISocketFactory;
import gnu.java.rmi.server.UnicastServerRef;
public class DGCImpl
extends UnicastRemoteObject implements DGC {
public DGCImpl() throws RemoteException {
super(new UnicastServerRef(new ObjID(ObjID.DGC_ID), 0, RMISocketFactory.getSocketFactory()));
}
public Lease dirty(ObjID[] ids, long sequenceNum, Lease lease) throws RemoteException {
System.out.println("DGCImpl.dirty - not implemented");
return (lease);
}
public void clean(ObjID[] ids, long sequenceNum, VMID vmid, boolean strong) throws RemoteException {
System.out.println("DGCImpl.clean - not implemented");
}
}

106
libjava/gnu/java/rmi/dgc/DGCImpl_Skel.java Normal file
View file

@ -0,0 +1,106 @@
// Skel class generated by rmic - DO NOT EDIT!
package gnu.java.rmi.dgc;
public final class DGCImpl_Skel
implements java.rmi.server.Skeleton
{
private static final long interfaceHash = -669196253586618813L;
private static final java.rmi.server.Operation[] operations = {
new java.rmi.server.Operation("void clean(java.rmi.server.ObjID[], long, java.rmi.dgc.VMID, boolean"),
new java.rmi.server.Operation("java.rmi.dgc.Lease dirty(java.rmi.server.ObjID[], long, java.rmi.dgc.Lease")
};
public java.rmi.server.Operation[] getOperations() {
return ((java.rmi.server.Operation[]) operations.clone());
}
public void dispatch(java.rmi.Remote obj, java.rmi.server.RemoteCall call, int opnum, long hash) throws java.lang.Exception {
if (opnum < 0) {
if (hash == -5803803475088455571L) {
opnum = 0;
}
else if (hash == -8139341527526761862L) {
opnum = 1;
}
else {
throw new java.rmi.server.SkeletonMismatchException("interface hash mismatch");
}
}
else if (hash != interfaceHash) {
throw new java.rmi.server.SkeletonMismatchException("interface hash mismatch");
}
gnu.java.rmi.dgc.DGCImpl server = (gnu.java.rmi.dgc.DGCImpl)obj;
switch (opnum) {
case 0:
{
java.rmi.server.ObjID[] $param_0;
long $param_1;
java.rmi.dgc.VMID $param_2;
boolean $param_3;
try {
java.io.ObjectInput in = call.getInputStream();
$param_0 = (java.rmi.server.ObjID[])in.readObject();
$param_1 = (long)in.readLong();
$param_2 = (java.rmi.dgc.VMID)in.readObject();
$param_3 = (boolean)in.readBoolean();
}
catch (java.io.IOException e) {
throw new java.rmi.UnmarshalException("error unmarshalling arguments", e);
}
catch (java.lang.ClassCastException e) {
throw new java.rmi.UnmarshalException("error unmarshalling arguments", e);
}
finally {
call.releaseInputStream();
}
server.clean($param_0, $param_1, $param_2, $param_3);
try {
java.io.ObjectOutput out = call.getResultStream(true);
}
catch (java.io.IOException e) {
throw new java.rmi.MarshalException("error marshalling return", e);
}
break;
}
case 1:
{
java.rmi.server.ObjID[] $param_0;
long $param_1;
java.rmi.dgc.Lease $param_2;
try {
java.io.ObjectInput in = call.getInputStream();
$param_0 = (java.rmi.server.ObjID[])in.readObject();
$param_1 = (long)in.readLong();
$param_2 = (java.rmi.dgc.Lease)in.readObject();
}
catch (java.io.IOException e) {
throw new java.rmi.UnmarshalException("error unmarshalling arguments", e);
}
catch (java.lang.ClassCastException e) {
throw new java.rmi.UnmarshalException("error unmarshalling arguments", e);
}
finally {
call.releaseInputStream();
}
java.rmi.dgc.Lease $result = server.dirty($param_0, $param_1, $param_2);
try {
java.io.ObjectOutput out = call.getResultStream(true);
out.writeObject($result);
}
catch (java.io.IOException e) {
throw new java.rmi.MarshalException("error marshalling return", e);
}
break;
}
default:
throw new java.rmi.UnmarshalException("invalid method number");
}
}
}

120
libjava/gnu/java/rmi/dgc/DGCImpl_Stub.java Normal file
View file

@ -0,0 +1,120 @@
// Stub class generated by rmic - DO NOT EDIT!
package gnu.java.rmi.dgc;
public final class DGCImpl_Stub
extends java.rmi.server.RemoteStub
implements java.rmi.dgc.DGC
{
private static final long serialVersionUID = 2L;
private static final long interfaceHash = -669196253586618813L;
private static boolean useNewInvoke;
private static final java.rmi.server.Operation[] operations = {
new java.rmi.server.Operation("void clean(java.rmi.server.ObjID[], long, java.rmi.dgc.VMID, boolean)"),
new java.rmi.server.Operation("java.rmi.dgc.Lease dirty(java.rmi.server.ObjID[], long, java.rmi.dgc.Lease)")
};
private static java.lang.reflect.Method $method_clean_0;
private static java.lang.reflect.Method $method_dirty_1;
static {
try {
java.rmi.server.RemoteRef.class.getMethod("invoke", new java.lang.Class[] { java.rmi.Remote.class, java.lang.reflect.Method.class, java.lang.Object[].class, long.class });
useNewInvoke = true;
$method_clean_0 = gnu.java.rmi.dgc.DGCImpl.class.getMethod("clean", new java.lang.Class[] {java.rmi.server.ObjID[].class, long.class, java.rmi.dgc.VMID.class, boolean.class});
$method_dirty_1 = gnu.java.rmi.dgc.DGCImpl.class.getMethod("dirty", new java.lang.Class[] {java.rmi.server.ObjID[].class, long.class, java.rmi.dgc.Lease.class});
}
catch (java.lang.NoSuchMethodException e) {
useNewInvoke = false;
}
}
public DGCImpl_Stub() {
super();
}
public DGCImpl_Stub(java.rmi.server.RemoteRef ref) {
super(ref);
}
public void clean(java.rmi.server.ObjID[] $param_0, long $param_1, java.rmi.dgc.VMID $param_2, boolean $param_3) throws java.rmi.RemoteException {
try {
if (useNewInvoke) {
ref.invoke(this, $method_clean_0, new java.lang.Object[] {$param_0, new java.lang.Long($param_1), $param_2, new java.lang.Boolean($param_3)}, -5803803475088455571L);
}
else {
java.rmi.server.RemoteCall call = ref.newCall((java.rmi.server.RemoteObject)this, operations, 0, interfaceHash);
try {
java.io.ObjectOutput out = call.getOutputStream();
out.writeObject($param_0);
out.writeLong($param_1);
out.writeObject($param_2);
out.writeBoolean($param_3);
}
catch (java.io.IOException e) {
throw new java.rmi.MarshalException("error marshalling arguments", e);
}
ref.invoke(call);
try {
java.io.ObjectInput in = call.getInputStream();
}
catch (java.io.IOException e) {
throw new java.rmi.UnmarshalException("error unmarshalling return", e);
}
finally {
ref.done(call);
}
}
}
catch (java.rmi.RemoteException e) {
throw e;
}
catch (java.lang.Exception e) {
throw new java.rmi.UnexpectedException("undeclared checked exception", e);
}
}
public java.rmi.dgc.Lease dirty(java.rmi.server.ObjID[] $param_0, long $param_1, java.rmi.dgc.Lease $param_2) throws java.rmi.RemoteException {
try {
if (useNewInvoke) {
java.lang.Object $result = ref.invoke(this, $method_dirty_1, new java.lang.Object[] {$param_0, new java.lang.Long($param_1), $param_2}, -8139341527526761862L);
return ((java.rmi.dgc.Lease)$result);
}
else {
java.rmi.server.RemoteCall call = ref.newCall((java.rmi.server.RemoteObject)this, operations, 1, interfaceHash);
try {
java.io.ObjectOutput out = call.getOutputStream();
out.writeObject($param_0);
out.writeLong($param_1);
out.writeObject($param_2);
}
catch (java.io.IOException e) {
throw new java.rmi.MarshalException("error marshalling arguments", e);
}
ref.invoke(call);
java.rmi.dgc.Lease $result;
try {
java.io.ObjectInput in = call.getInputStream();
$result = (java.rmi.dgc.Lease)in.readObject();
return ($result);
}
catch (java.io.IOException e) {
throw new java.rmi.UnmarshalException("error unmarshalling return", e);
}
finally {
ref.done(call);
}
}
}
catch (java.rmi.RemoteException e) {
throw e;
}
catch (java.lang.Exception e) {
throw new java.rmi.UnexpectedException("undeclared checked exception", e);
}
}
}

115
libjava/gnu/java/rmi/registry/RegistryImpl.java Normal file
View file

@ -0,0 +1,115 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.registry;
import java.rmi.registry.Registry;
import java.rmi.registry.LocateRegistry;
import java.rmi.RemoteException;
import java.rmi.NotBoundException;
import java.rmi.AccessException;
import java.rmi.AlreadyBoundException;
import java.rmi.Remote;
import java.rmi.server.UnicastRemoteObject;
import java.rmi.server.ObjID;
import java.util.Hashtable;
import java.util.Enumeration;
import java.rmi.server.RMISocketFactory;
import java.rmi.server.RMIClientSocketFactory;
import java.rmi.server.RMIServerSocketFactory;
import gnu.java.rmi.server.UnicastServerRef;
public class RegistryImpl
extends UnicastRemoteObject implements Registry {
private Hashtable bindings = new Hashtable();
public RegistryImpl(int port) throws RemoteException {
this(port, RMISocketFactory.getSocketFactory(), RMISocketFactory.getSocketFactory());
}
public RegistryImpl(int port, RMIClientSocketFactory cf, RMIServerSocketFactory sf) throws RemoteException {
super(new UnicastServerRef(new ObjID(ObjID.REGISTRY_ID), port, sf));
((UnicastServerRef)getRef()).exportObject(this);
}
public Remote lookup(String name) throws RemoteException, NotBoundException, AccessException {
Object obj = bindings.get(name);
if (obj == null) {
throw new NotBoundException(name);
}
return ((Remote)obj);
}
public void bind(String name, Remote obj) throws RemoteException, AlreadyBoundException, AccessException {
if (bindings.containsKey(name)) {
throw new AlreadyBoundException(name);
}
bindings.put(name, obj);
}
public void unbind(String name) throws RemoteException, NotBoundException, AccessException {
Object obj = bindings.remove(name);
if (obj == null) {
throw new NotBoundException(name);
}
}
public void rebind(String name, Remote obj) throws RemoteException, AccessException {
bindings.put(name, obj);
}
public String[] list() throws RemoteException, AccessException {
int size = bindings.size();
String[] strings = new String[size];
Enumeration e = bindings.keys();
for (int i = 0; i < size; i++) {
strings[i] = (String)e.nextElement();
}
return (strings);
}
public static void main(String[] args) {
int port = Registry.REGISTRY_PORT;
if (args.length > 0) {
try {
port = Integer.parseInt(args[0]);
}
catch (NumberFormatException _) {
System.err.println("Bad port number - using default");
}
}
try {
Registry impl = LocateRegistry.createRegistry(port);
}
catch (RemoteException _) {
System.err.println("Registry failed");
}
}
}

189
libjava/gnu/java/rmi/registry/RegistryImpl_Skel.java Normal file
View file

@ -0,0 +1,189 @@
// Skel class generated by rmic - DO NOT EDIT!
package gnu.java.rmi.registry;
public final class RegistryImpl_Skel
implements java.rmi.server.Skeleton
{
private static final long interfaceHash = 4905912898345647071L;
private static final java.rmi.server.Operation[] operations = {
new java.rmi.server.Operation("void bind(java.lang.String, java.rmi.Remote"),
new java.rmi.server.Operation("java.lang.String[] list("),
new java.rmi.server.Operation("java.rmi.Remote lookup(java.lang.String"),
new java.rmi.server.Operation("void rebind(java.lang.String, java.rmi.Remote"),
new java.rmi.server.Operation("void unbind(java.lang.String")
};
public java.rmi.server.Operation[] getOperations() {
return ((java.rmi.server.Operation[]) operations.clone());
}
public void dispatch(java.rmi.Remote obj, java.rmi.server.RemoteCall call, int opnum, long hash) throws java.lang.Exception {
if (opnum < 0) {
if (hash == 7583982177005850366L) {
opnum = 0;
}
else if (hash == 2571371476350237748L) {
opnum = 1;
}
else if (hash == -7538657168040752697L) {
opnum = 2;
}
else if (hash == -8381844669958460146L) {
opnum = 3;
}
else if (hash == 7305022919901907578L) {
opnum = 4;
}
else {
throw new java.rmi.server.SkeletonMismatchException("interface hash mismatch");
}
}
else if (hash != interfaceHash) {
throw new java.rmi.server.SkeletonMismatchException("interface hash mismatch");
}
gnu.java.rmi.registry.RegistryImpl server = (gnu.java.rmi.registry.RegistryImpl)obj;
switch (opnum) {
case 0:
{
java.lang.String $param_0;
java.rmi.Remote $param_1;
try {
java.io.ObjectInput in = call.getInputStream();
$param_0 = (java.lang.String)in.readObject();
$param_1 = (java.rmi.Remote)in.readObject();
}
catch (java.io.IOException e) {
throw new java.rmi.UnmarshalException("error unmarshalling arguments", e);
}
catch (java.lang.ClassCastException e) {
throw new java.rmi.UnmarshalException("error unmarshalling arguments", e);
}
finally {
call.releaseInputStream();
}
server.bind($param_0, $param_1);
try {
java.io.ObjectOutput out = call.getResultStream(true);
}
catch (java.io.IOException e) {
throw new java.rmi.MarshalException("error marshalling return", e);
}
break;
}
case 1:
{
try {
java.io.ObjectInput in = call.getInputStream();
}
catch (java.io.IOException e) {
throw new java.rmi.UnmarshalException("error unmarshalling arguments", e);
}
finally {
call.releaseInputStream();
}
java.lang.String[] $result = server.list();
try {
java.io.ObjectOutput out = call.getResultStream(true);
out.writeObject($result);
}
catch (java.io.IOException e) {
throw new java.rmi.MarshalException("error marshalling return", e);
}
break;
}
case 2:
{
java.lang.String $param_0;
try {
java.io.ObjectInput in = call.getInputStream();
$param_0 = (java.lang.String)in.readObject();
}
catch (java.io.IOException e) {
throw new java.rmi.UnmarshalException("error unmarshalling arguments", e);
}
catch (java.lang.ClassCastException e) {
throw new java.rmi.UnmarshalException("error unmarshalling arguments", e);
}
finally {
call.releaseInputStream();
}
java.rmi.Remote $result = server.lookup($param_0);
try {
java.io.ObjectOutput out = call.getResultStream(true);
out.writeObject($result);
}
catch (java.io.IOException e) {
throw new java.rmi.MarshalException("error marshalling return", e);
}
break;
}
case 3:
{
java.lang.String $param_0;
java.rmi.Remote $param_1;
try {
java.io.ObjectInput in = call.getInputStream();
$param_0 = (java.lang.String)in.readObject();
$param_1 = (java.rmi.Remote)in.readObject();
}
catch (java.io.IOException e) {
throw new java.rmi.UnmarshalException("error unmarshalling arguments", e);
}
catch (java.lang.ClassCastException e) {
throw new java.rmi.UnmarshalException("error unmarshalling arguments", e);
}
finally {
call.releaseInputStream();
}
server.rebind($param_0, $param_1);
try {
java.io.ObjectOutput out = call.getResultStream(true);
}
catch (java.io.IOException e) {
throw new java.rmi.MarshalException("error marshalling return", e);
}
break;
}
case 4:
{
java.lang.String $param_0;
try {
java.io.ObjectInput in = call.getInputStream();
$param_0 = (java.lang.String)in.readObject();
}
catch (java.io.IOException e) {
throw new java.rmi.UnmarshalException("error unmarshalling arguments", e);
}
catch (java.lang.ClassCastException e) {
throw new java.rmi.UnmarshalException("error unmarshalling arguments", e);
}
finally {
call.releaseInputStream();
}
server.unbind($param_0);
try {
java.io.ObjectOutput out = call.getResultStream(true);
}
catch (java.io.IOException e) {
throw new java.rmi.MarshalException("error marshalling return", e);
}
break;
}
default:
throw new java.rmi.UnmarshalException("invalid method number");
}
}
}

255
libjava/gnu/java/rmi/registry/RegistryImpl_Stub.java Normal file
View file

@ -0,0 +1,255 @@
// Stub class generated by rmic - DO NOT EDIT!
package gnu.java.rmi.registry;
public final class RegistryImpl_Stub
extends java.rmi.server.RemoteStub
implements java.rmi.registry.Registry
{
private static final long serialVersionUID = 2L;
private static final long interfaceHash = 4905912898345647071L;
private static boolean useNewInvoke;
private static final java.rmi.server.Operation[] operations = {
new java.rmi.server.Operation("void bind(java.lang.String, java.rmi.Remote)"),
new java.rmi.server.Operation("java.lang.String[] list()"),
new java.rmi.server.Operation("java.rmi.Remote lookup(java.lang.String)"),
new java.rmi.server.Operation("void rebind(java.lang.String, java.rmi.Remote)"),
new java.rmi.server.Operation("void unbind(java.lang.String)")
};
private static java.lang.reflect.Method $method_bind_0;
private static java.lang.reflect.Method $method_list_1;
private static java.lang.reflect.Method $method_lookup_2;
private static java.lang.reflect.Method $method_rebind_3;
private static java.lang.reflect.Method $method_unbind_4;
static {
try {
java.rmi.server.RemoteRef.class.getMethod("invoke", new java.lang.Class[] { java.rmi.Remote.class, java.lang.reflect.Method.class, java.lang.Object[].class, long.class });
useNewInvoke = true;
$method_bind_0 = gnu.java.rmi.registry.RegistryImpl.class.getMethod("bind", new java.lang.Class[] {java.lang.String.class, java.rmi.Remote.class});
$method_list_1 = gnu.java.rmi.registry.RegistryImpl.class.getMethod("list", new java.lang.Class[] {});
$method_lookup_2 = gnu.java.rmi.registry.RegistryImpl.class.getMethod("lookup", new java.lang.Class[] {java.lang.String.class});
$method_rebind_3 = gnu.java.rmi.registry.RegistryImpl.class.getMethod("rebind", new java.lang.Class[] {java.lang.String.class, java.rmi.Remote.class});
$method_unbind_4 = gnu.java.rmi.registry.RegistryImpl.class.getMethod("unbind", new java.lang.Class[] {java.lang.String.class});
}
catch (java.lang.NoSuchMethodException e) {
useNewInvoke = false;
}
}
public RegistryImpl_Stub() {
super();
}
public RegistryImpl_Stub(java.rmi.server.RemoteRef ref) {
super(ref);
}
public void bind(java.lang.String $param_0, java.rmi.Remote $param_1) throws java.rmi.AccessException, java.rmi.AlreadyBoundException, java.rmi.RemoteException {
try {
if (useNewInvoke) {
ref.invoke(this, $method_bind_0, new java.lang.Object[] {$param_0, $param_1}, 7583982177005850366L);
}
else {
java.rmi.server.RemoteCall call = ref.newCall((java.rmi.server.RemoteObject)this, operations, 0, interfaceHash);
try {
java.io.ObjectOutput out = call.getOutputStream();
out.writeObject($param_0);
out.writeObject($param_1);
}
catch (java.io.IOException e) {
throw new java.rmi.MarshalException("error marshalling arguments", e);
}
ref.invoke(call);
try {
java.io.ObjectInput in = call.getInputStream();
}
catch (java.io.IOException e) {
throw new java.rmi.UnmarshalException("error unmarshalling return", e);
}
finally {
ref.done(call);
}
}
}
catch (java.rmi.AccessException e) {
throw e;
}
catch (java.rmi.AlreadyBoundException e) {
throw e;
}
catch (java.rmi.RemoteException e) {
throw e;
}
catch (java.lang.Exception e) {
throw new java.rmi.UnexpectedException("undeclared checked exception", e);
}
}
public java.lang.String[] list() throws java.rmi.AccessException, java.rmi.RemoteException {
try {
if (useNewInvoke) {
java.lang.Object $result = ref.invoke(this, $method_list_1, null, 2571371476350237748L);
return ((java.lang.String[])$result);
}
else {
java.rmi.server.RemoteCall call = ref.newCall((java.rmi.server.RemoteObject)this, operations, 1, interfaceHash);
try {
java.io.ObjectOutput out = call.getOutputStream();
}
catch (java.io.IOException e) {
throw new java.rmi.MarshalException("error marshalling arguments", e);
}
ref.invoke(call);
java.lang.String[] $result;
try {
java.io.ObjectInput in = call.getInputStream();
$result = (java.lang.String[])in.readObject();
return ($result);
}
catch (java.io.IOException e) {
throw new java.rmi.UnmarshalException("error unmarshalling return", e);
}
finally {
ref.done(call);
}
}
}
catch (java.rmi.AccessException e) {
throw e;
}
catch (java.rmi.RemoteException e) {
throw e;
}
catch (java.lang.Exception e) {
throw new java.rmi.UnexpectedException("undeclared checked exception", e);
}
}
public java.rmi.Remote lookup(java.lang.String $param_0) throws java.rmi.AccessException, java.rmi.NotBoundException, java.rmi.RemoteException {
try {
if (useNewInvoke) {
java.lang.Object $result = ref.invoke(this, $method_lookup_2, new java.lang.Object[] {$param_0}, -7538657168040752697L);
return ((java.rmi.Remote)$result);
}
else {
java.rmi.server.RemoteCall call = ref.newCall((java.rmi.server.RemoteObject)this, operations, 2, interfaceHash);
try {
java.io.ObjectOutput out = call.getOutputStream();
out.writeObject($param_0);
}
catch (java.io.IOException e) {
throw new java.rmi.MarshalException("error marshalling arguments", e);
}
ref.invoke(call);
java.rmi.Remote $result;
try {
java.io.ObjectInput in = call.getInputStream();
$result = (java.rmi.Remote)in.readObject();
return ($result);
}
catch (java.io.IOException e) {
throw new java.rmi.UnmarshalException("error unmarshalling return", e);
}
finally {
ref.done(call);
}
}
}
catch (java.rmi.AccessException e) {
throw e;
}
catch (java.rmi.NotBoundException e) {
throw e;
}
catch (java.rmi.RemoteException e) {
throw e;
}
catch (java.lang.Exception e) {
throw new java.rmi.UnexpectedException("undeclared checked exception", e);
}
}
public void rebind(java.lang.String $param_0, java.rmi.Remote $param_1) throws java.rmi.AccessException, java.rmi.RemoteException {
try {
if (useNewInvoke) {
ref.invoke(this, $method_rebind_3, new java.lang.Object[] {$param_0, $param_1}, -8381844669958460146L);
}
else {
java.rmi.server.RemoteCall call = ref.newCall((java.rmi.server.RemoteObject)this, operations, 3, interfaceHash);
try {
java.io.ObjectOutput out = call.getOutputStream();
out.writeObject($param_0);
out.writeObject($param_1);
}
catch (java.io.IOException e) {
throw new java.rmi.MarshalException("error marshalling arguments", e);
}
ref.invoke(call);
try {
java.io.ObjectInput in = call.getInputStream();
}
catch (java.io.IOException e) {
throw new java.rmi.UnmarshalException("error unmarshalling return", e);
}
finally {
ref.done(call);
}
}
}
catch (java.rmi.AccessException e) {
throw e;
}
catch (java.rmi.RemoteException e) {
throw e;
}
catch (java.lang.Exception e) {
throw new java.rmi.UnexpectedException("undeclared checked exception", e);
}
}
public void unbind(java.lang.String $param_0) throws java.rmi.AccessException, java.rmi.NotBoundException, java.rmi.RemoteException {
try {
if (useNewInvoke) {
ref.invoke(this, $method_unbind_4, new java.lang.Object[] {$param_0}, 7305022919901907578L);
}
else {
java.rmi.server.RemoteCall call = ref.newCall((java.rmi.server.RemoteObject)this, operations, 4, interfaceHash);
try {
java.io.ObjectOutput out = call.getOutputStream();
out.writeObject($param_0);
}
catch (java.io.IOException e) {
throw new java.rmi.MarshalException("error marshalling arguments", e);
}
ref.invoke(call);
try {
java.io.ObjectInput in = call.getInputStream();
}
catch (java.io.IOException e) {
throw new java.rmi.UnmarshalException("error unmarshalling return", e);
}
finally {
ref.done(call);
}
}
}
catch (java.rmi.AccessException e) {
throw e;
}
catch (java.rmi.NotBoundException e) {
throw e;
}
catch (java.rmi.RemoteException e) {
throw e;
}
catch (java.lang.Exception e) {
throw new java.rmi.UnexpectedException("undeclared checked exception", e);
}
}
}

982
libjava/gnu/java/rmi/rmic/RMIC.java Normal file
View file

@ -0,0 +1,982 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.rmic;
import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Arrays;
import java.lang.Comparable;
import gnu.java.rmi.server.RMIHashes;
// import kaffe.tools.compiler.Compiler;
public class RMIC {
private String[] args;
private int next;
private Exception exception;
private boolean keep = false;
private boolean need11Stubs = true;
private boolean need12Stubs = true;
private boolean compile = true;
private boolean verbose;
private String destination;
private PrintWriter out;
private TabbedWriter ctrl;
private Class clazz;
private String classname;
private String fullclassname;
private MethodRef[] remotemethods;
private String stubname;
private String skelname;
public RMIC(String[] a) {
args = a;
}
public static void main(String args[]) {
RMIC r = new RMIC(args);
if (r.run() == false) {
Exception exception = r.getException();
if (exception != null) {
exception.printStackTrace();
}
else {
usage();
}
}
}
public boolean run() {
parseOptions();
if (next >= args.length) {
return (false);
}
for (int i = next; i < args.length; i++) {
try {
if (verbose) {
System.out.println("[Processing class " + args[i] + ".class]");
}
processClass(args[i]);
}
catch (Exception e) {
exception = e;
return (false);
}
}
return (true);
}
private boolean processClass(String classname) throws Exception {
analyzeClass(classname);
generateStub();
if (need11Stubs) {
generateSkel();
}
if (compile) {
compile(stubname + ".java");
if (need11Stubs) {
compile(skelname + ".java");
}
}
if (!keep) {
(new File(stubname + ".java")).delete();
if (need11Stubs) {
(new File(skelname + ".java")).delete();
}
}
return (true);
}
private void analyzeClass(String cname) throws Exception {
int p = cname.lastIndexOf('.');
if (p != -1) {
classname = cname.substring(p+1);
}
else {
classname = cname;
}
fullclassname = cname;
HashSet rmeths = new HashSet();
findClass();
for (Class cls = clazz; cls != null; cls = cls.getSuperclass()) {
// Keep going down the inheritence tree until we hit the system
if (cls.getName().startsWith("java.")) {
break;
}
Method[] meths = cls.getDeclaredMethods();
for (int i = 0; i < meths.length; i++) {
// Only include public methods
int mods = meths[i].getModifiers();
if (Modifier.isPublic(mods) && !Modifier.isStatic(mods)) {
// Should check exceptions here. - XXX
// Add this one in.
rmeths.add(meths[i]);
}
}
}
// Convert into a MethodRef array and sort them
remotemethods = new MethodRef[rmeths.size()];
int c = 0;
for (Iterator i = rmeths.iterator(); i.hasNext(); ) {
remotemethods[c++] = new MethodRef((Method)i.next());
}
Arrays.sort(remotemethods);
}
public Exception getException() {
return (exception);
}
private void findClass() throws ClassNotFoundException {
clazz = Class.forName(fullclassname);
}
private void generateStub() throws IOException {
stubname = classname + "_Stub";
ctrl = new TabbedWriter(new FileWriter(stubname + ".java"));
out = new PrintWriter(ctrl);
if (verbose) {
System.out.println("[Generating class " + stubname + ".java]");
}
out.println("// Stub class generated by rmic - DO NOT EDIT!");
out.println();
if (fullclassname != classname) {
String pname = fullclassname.substring(0, fullclassname.lastIndexOf('.'));
out.println("package " + pname + ";");
out.println();
}
out.print("public final class " + stubname);
ctrl.indent();
out.println("extends java.rmi.server.RemoteStub");
// Output interfaces we implement
out.print("implements ");
Class[] ifaces = clazz.getInterfaces();
for (int i = 0; i < ifaces.length; i++) {
out.print(ifaces[i].getName());
if (i+1 < ifaces.length) {
out.print(", ");
}
}
ctrl.unindent();
out.print("{");
ctrl.indent();
// UID
if (need12Stubs) {
out.println("private static final long serialVersionUID = 2L;");
out.println();
}
// InterfaceHash - don't know how to calculate this - XXX
if (need11Stubs) {
out.println("private static final long interfaceHash = " + RMIHashes.getInterfaceHash(clazz) + "L;");
out.println();
if (need12Stubs) {
out.println("private static boolean useNewInvoke;");
out.println();
}
// Operation table
out.print("private static final java.rmi.server.Operation[] operations = {");
ctrl.indent();
for (int i = 0; i < remotemethods.length; i++) {
Method m = remotemethods[i].meth;
out.print("new java.rmi.server.Operation(\"");
out.print(getPrettyName(m.getReturnType()) + " ");
out.print(m.getName() + "(");
// Output signature
Class[] sig = m.getParameterTypes();
for (int j = 0; j < sig.length; j++) {
out.print(getPrettyName(sig[j]));
if (j+1 < sig.length) {
out.print(", ");
}
}
out.print(")\")");
if (i + 1 < remotemethods.length) {
out.println(",");
}
}
ctrl.unindent();
out.println("};");
out.println();
}
// Set of method references.
if (need12Stubs) {
for (int i = 0; i < remotemethods.length; i++) {
Method m = remotemethods[i].meth;
out.println("private static java.lang.reflect.Method $method_" + m.getName() + "_" + i + ";");
}
// Initialize the methods references.
out.println();
out.print("static {");
ctrl.indent();
out.print("try {");
ctrl.indent();
if (need11Stubs) {
out.println("java.rmi.server.RemoteRef.class.getMethod(\"invoke\", new java.lang.Class[] { java.rmi.Remote.class, java.lang.reflect.Method.class, java.lang.Object[].class, long.class });");
out.println("useNewInvoke = true;");
}
for (int i = 0; i < remotemethods.length; i++) {
Method m = remotemethods[i].meth;
out.print("$method_" + m.getName() + "_" + i + " = ");
out.print(fullclassname + ".class.getMethod(\"" + m.getName() + "\"");
out.print(", new java.lang.Class[] {");
// Output signature
Class[] sig = m.getParameterTypes();
for (int j = 0; j < sig.length; j++) {
out.print(getPrettyName(sig[j]) + ".class");
if (j+1 < sig.length) {
out.print(", ");
}
}
out.println("});");
}
ctrl.unindent();
out.println("}");
out.print("catch (java.lang.NoSuchMethodException e) {");
ctrl.indent();
if (need11Stubs) {
out.print("useNewInvoke = false;");
}
else {
out.print("throw new java.lang.NoSuchMethodError(\"stub class initialization failed\");");
}
ctrl.unindent();
out.print("}");
ctrl.unindent();
out.println("}");
out.println();
}
// Constructors
if (need11Stubs) {
out.print("public " + stubname + "() {");
ctrl.indent();
out.print("super();");
ctrl.unindent();
out.println("}");
}
if (need12Stubs) {
out.print("public " + stubname + "(java.rmi.server.RemoteRef ref) {");
ctrl.indent();
out.print("super(ref);");
ctrl.unindent();
out.println("}");
}
// Method implementations
for (int i = 0; i < remotemethods.length; i++) {
Method m = remotemethods[i].meth;
Class[] sig = m.getParameterTypes();
Class returntype = m.getReturnType();
Class[] except = sortExceptions(m.getExceptionTypes());
out.println();
out.print("public " + getPrettyName(returntype) + " " + m.getName() + "(");
for (int j = 0; j < sig.length; j++) {
out.print(getPrettyName(sig[j]));
out.print(" $param_" + j);
if (j+1 < sig.length) {
out.print(", ");
}
}
out.print(") ");
out.print("throws ");
for (int j = 0; j < except.length; j++) {
out.print(getPrettyName(except[j]));
if (j+1 < except.length) {
out.print(", ");
}
}
out.print(" {");
ctrl.indent();
out.print("try {");
ctrl.indent();
if (need12Stubs) {
if (need11Stubs) {
out.print("if (useNewInvoke) {");
ctrl.indent();
}
if (returntype != Void.TYPE) {
out.print("java.lang.Object $result = ");
}
out.print("ref.invoke(this, $method_" + m.getName() + "_" + i + ", ");
if (sig.length == 0) {
out.print("null, ");
}
else {
out.print("new java.lang.Object[] {");
for (int j = 0; j < sig.length; j++) {
if (sig[j] == Boolean.TYPE) {
out.print("new java.lang.Boolean($param_" + j + ")");
}
else if (sig[j] == Byte.TYPE) {
out.print("new java.lang.Byte($param_" + j + ")");
}
else if (sig[j] == Character.TYPE) {
out.print("new java.lang.Character($param_" + j + ")");
}
else if (sig[j] == Short.TYPE) {
out.print("new java.lang.Short($param_" + j + ")");
}
else if (sig[j] == Integer.TYPE) {
out.print("new java.lang.Integer($param_" + j + ")");
}
else if (sig[j] == Long.TYPE) {
out.print("new java.lang.Long($param_" + j + ")");
}
else if (sig[j] == Float.TYPE) {
out.print("new java.lang.Float($param_" + j + ")");
}
else if (sig[j] == Double.TYPE) {
out.print("new java.lang.Double($param_" + j + ")");
}
else {
out.print("$param_" + j);
}
if (j+1 < sig.length) {
out.print(", ");
}
}
out.print("}, ");
}
out.print(Long.toString(remotemethods[i].hash) + "L");
out.print(");");
if (returntype != Void.TYPE) {
out.println();
out.print("return (");
if (returntype == Boolean.TYPE) {
out.print("((java.lang.Boolean)$result).booleanValue()");
}
else if (returntype == Byte.TYPE) {
out.print("((java.lang.Byte)$result).byteValue()");
}
else if (returntype == Character.TYPE) {
out.print("((java.lang.Character)$result).charValue()");
}
else if (returntype == Short.TYPE) {
out.print("((java.lang.Short)$result).shortValue()");
}
else if (returntype == Integer.TYPE) {
out.print("((java.lang.Integer)$result).intValue()");
}
else if (returntype == Long.TYPE) {
out.print("((java.lang.Long)$result).longValue()");
}
else if (returntype == Float.TYPE) {
out.print("((java.lang.Float)$result).floatValue()");
}
else if (returntype == Double.TYPE) {
out.print("((java.lang.Double)$result).doubleValue()");
}
else {
out.print("(" + getPrettyName(returntype) + ")$result");
}
out.print(");");
}
if (need11Stubs) {
ctrl.unindent();
out.println("}");
out.print("else {");
ctrl.indent();
}
}
if (need11Stubs) {
out.println("java.rmi.server.RemoteCall call = ref.newCall((java.rmi.server.RemoteObject)this, operations, " + i + ", interfaceHash);");
out.print("try {");
ctrl.indent();
out.print("java.io.ObjectOutput out = call.getOutputStream();");
for (int j = 0; j < sig.length; j++) {
out.println();
if (sig[j] == Boolean.TYPE) {
out.print("out.writeBoolean(");
}
else if (sig[j] == Byte.TYPE) {
out.print("out.writeByte(");
}
else if (sig[j] == Character.TYPE) {
out.print("out.writeChar(");
}
else if (sig[j] == Short.TYPE) {
out.print("out.writeShort(");
}
else if (sig[j] == Integer.TYPE) {
out.print("out.writeInt(");
}
else if (sig[j] == Long.TYPE) {
out.print("out.writeLong(");
}
else if (sig[j] == Float.TYPE) {
out.print("out.writeFloat(");
}
else if (sig[j] == Double.TYPE) {
out.print("out.writeDouble(");
}
else {
out.print("out.writeObject(");
}
out.print("$param_" + j + ");");
}
ctrl.unindent();
out.println("}");
out.print("catch (java.io.IOException e) {");
ctrl.indent();
out.print("throw new java.rmi.MarshalException(\"error marshalling arguments\", e);");
ctrl.unindent();
out.println("}");
out.println("ref.invoke(call);");
if (returntype != Void.TYPE) {
out.println(getPrettyName(returntype) + " $result;");
}
out.print("try {");
ctrl.indent();
out.print("java.io.ObjectInput in = call.getInputStream();");
boolean needcastcheck = false;
if (returntype != Void.TYPE) {
out.println();
out.print("$result = ");
if (returntype == Boolean.TYPE) {
out.print("in.readBoolean();");
}
else if (returntype == Byte.TYPE) {
out.print("in.readByte();");
}
else if (returntype == Character.TYPE) {
out.print("in.readChar();");
}
else if (returntype == Short.TYPE) {
out.print("in.readShort();");
}
else if (returntype == Integer.TYPE) {
out.print("in.readInt();");
}
else if (returntype == Long.TYPE) {
out.print("in.readLong();");
}
else if (returntype == Float.TYPE) {
out.print("in.readFloat();");
}
else if (returntype == Double.TYPE) {
out.print("in.readDouble();");
}
else {
if (returntype != Object.class) {
out.print("(" + getPrettyName(returntype) + ")");
}
else {
needcastcheck = true;
}
out.print("in.readObject();");
}
out.println();
out.print("return ($result);");
}
ctrl.unindent();
out.println("}");
out.print("catch (java.io.IOException e) {");
ctrl.indent();
out.print("throw new java.rmi.UnmarshalException(\"error unmarshalling return\", e);");
ctrl.unindent();
out.println("}");
if (needcastcheck) {
out.print("catch (java.lang.ClassNotFoundException e) {");
ctrl.indent();
out.print("throw new java.rmi.UnmarshalException(\"error unmarshalling return\", e);");
ctrl.unindent();
out.println("}");
}
out.print("finally {");
ctrl.indent();
out.print("ref.done(call);");
ctrl.unindent();
out.print("}");
if (need12Stubs && need11Stubs) {
ctrl.unindent();
out.print("}");
}
}
ctrl.unindent();
out.print("}");
boolean needgeneral = true;
for (int j = 0; j < except.length; j++) {
out.println();
out.print("catch (" + getPrettyName(except[j]) + " e) {");
ctrl.indent();
out.print("throw e;");
ctrl.unindent();
out.print("}");
if (except[j] == Exception.class) {
needgeneral = false;
}
}
if (needgeneral) {
out.println();
out.print("catch (java.lang.Exception e) {");
ctrl.indent();
out.print("throw new java.rmi.UnexpectedException(\"undeclared checked exception\", e);");
ctrl.unindent();
out.print("}");
}
ctrl.unindent();
out.print("}");
out.println();
}
ctrl.unindent();
out.println("}");
out.close();
}
private void generateSkel() throws IOException {
skelname = classname + "_Skel";
ctrl = new TabbedWriter(new FileWriter(skelname + ".java"));
out = new PrintWriter(ctrl);
if (verbose) {
System.out.println("[Generating class " + skelname + ".java]");
}
out.println("// Skel class generated by rmic - DO NOT EDIT!");
out.println();
if (fullclassname != classname) {
String pname = fullclassname.substring(0, fullclassname.lastIndexOf('.'));
out.println("package " + pname + ";");
out.println();
}
out.print("public final class " + skelname);
ctrl.indent();
// Output interfaces we implement
out.print("implements java.rmi.server.Skeleton");
ctrl.unindent();
out.print("{");
ctrl.indent();
// Interface hash - don't know how to calculate this - XXX
out.println("private static final long interfaceHash = " + RMIHashes.getInterfaceHash(clazz) + "L;");
out.println();
// Operation table
out.print("private static final java.rmi.server.Operation[] operations = {");
ctrl.indent();
for (int i = 0; i < remotemethods.length; i++) {
Method m = remotemethods[i].meth;
out.print("new java.rmi.server.Operation(\"");
out.print(getPrettyName(m.getReturnType()) + " ");
out.print(m.getName() + "(");
// Output signature
Class[] sig = m.getParameterTypes();
for (int j = 0; j < sig.length; j++) {
out.print(getPrettyName(sig[j]));
if (j+1 < sig.length) {
out.print(", ");
}
}
out.print("\")");
if (i + 1 < remotemethods.length) {
out.println(",");
}
}
ctrl.unindent();
out.println("};");
out.println();
// getOpertions method
out.print("public java.rmi.server.Operation[] getOperations() {");
ctrl.indent();
out.print("return ((java.rmi.server.Operation[]) operations.clone());");
ctrl.unindent();
out.println("}");
out.println();
// Dispatch method
out.print("public void dispatch(java.rmi.Remote obj, java.rmi.server.RemoteCall call, int opnum, long hash) throws java.lang.Exception {");
ctrl.indent();
out.print("if (opnum < 0) {");
ctrl.indent();
for (int i = 0; i < remotemethods.length; i++) {
out.print("if (hash == " + Long.toString(remotemethods[i].hash) + "L) {");
ctrl.indent();
out.print("opnum = " + i + ";");
ctrl.unindent();
out.println("}");
out.print("else ");
}
out.print("{");
ctrl.indent();
out.print("throw new java.rmi.server.SkeletonMismatchException(\"interface hash mismatch\");");
ctrl.unindent();
out.print("}");
ctrl.unindent();
out.println("}");
out.print("else if (hash != interfaceHash) {");
ctrl.indent();
out.print("throw new java.rmi.server.SkeletonMismatchException(\"interface hash mismatch\");");
ctrl.unindent();
out.println("}");
out.println();
out.println(fullclassname + " server = (" + fullclassname + ")obj;");
out.println("switch (opnum) {");
// Method dispatch
for (int i = 0; i < remotemethods.length; i++) {
Method m = remotemethods[i].meth;
out.println("case " + i + ":");
out.print("{");
ctrl.indent();
Class[] sig = m.getParameterTypes();
for (int j = 0; j < sig.length; j++) {
out.print(getPrettyName(sig[j]));
out.println(" $param_" + j + ";");
}
out.print("try {");
boolean needcastcheck = false;
ctrl.indent();
out.println("java.io.ObjectInput in = call.getInputStream();");
for (int j = 0; j < sig.length; j++) {
out.print("$param_" + j + " = ");
if (sig[j] == Boolean.TYPE) {
out.print("in.readBoolean();");
}
else if (sig[j] == Byte.TYPE) {
out.print("in.readByte();");
}
else if (sig[j] == Character.TYPE) {
out.print("in.readChar();");
}
else if (sig[j] == Short.TYPE) {
out.print("in.readShort();");
}
else if (sig[j] == Integer.TYPE) {
out.print("in.readInt();");
}
else if (sig[j] == Long.TYPE) {
out.print("in.readLong();");
}
else if (sig[j] == Float.TYPE) {
out.print("in.readFloat();");
}
else if (sig[j] == Double.TYPE) {
out.print("in.readDouble();");
}
else {
if (sig[j] != Object.class) {
out.print("(" + getPrettyName(sig[j]) + ")");
needcastcheck = true;
}
out.print("in.readObject();");
}
out.println();
}
ctrl.unindent();
out.println("}");
out.print("catch (java.io.IOException e) {");
ctrl.indent();
out.print("throw new java.rmi.UnmarshalException(\"error unmarshalling arguments\", e);");
ctrl.unindent();
out.println("}");
if (needcastcheck) {
out.print("catch (java.lang.ClassCastException e) {");
ctrl.indent();
out.print("throw new java.rmi.UnmarshalException(\"error unmarshalling arguments\", e);");
ctrl.unindent();
out.println("}");
}
out.print("finally {");
ctrl.indent();
out.print("call.releaseInputStream();");
ctrl.unindent();
out.println("}");
Class returntype = m.getReturnType();
if (returntype != Void.TYPE) {
out.print(getPrettyName(returntype) + " $result = ");
}
out.print("server." + m.getName() + "(");
for (int j = 0; j < sig.length; j++) {
out.print("$param_" + j);
if (j + 1 < sig.length) {
out.print(", ");
}
}
out.println(");");
out.print("try {");
ctrl.indent();
out.print("java.io.ObjectOutput out = call.getResultStream(true);");
if (returntype != Void.TYPE) {
out.println();
if (returntype == Boolean.TYPE) {
out.print("out.writeBoolean($result);");
}
else if (returntype == Byte.TYPE) {
out.print("out.writeByte($result);");
}
else if (returntype == Character.TYPE) {
out.print("out.writeChar($result);");
}
else if (returntype == Short.TYPE) {
out.print("out.writeShort($result);");
}
else if (returntype == Integer.TYPE) {
out.print("out.writeInt($result);");
}
else if (returntype == Long.TYPE) {
out.print("out.writeLong($result);");
}
else if (returntype == Float.TYPE) {
out.print("out.writeFloat($result);");
}
else if (returntype == Double.TYPE) {
out.print("out.writeDouble($result);");
}
else {
out.print("out.writeObject($result);");
}
}
ctrl.unindent();
out.println("}");
out.print("catch (java.io.IOException e) {");
ctrl.indent();
out.print("throw new java.rmi.MarshalException(\"error marshalling return\", e);");
ctrl.unindent();
out.println("}");
out.print("break;");
ctrl.unindent();
out.println("}");
out.println();
}
out.print("default:");
ctrl.indent();
out.print("throw new java.rmi.UnmarshalException(\"invalid method number\");");
ctrl.unindent();
out.print("}");
ctrl.unindent();
out.print("}");
ctrl.unindent();
out.println("}");
out.close();
}
private void compile(String name) throws Exception {
throw new Error ("Not implemented");
// Compiler comp = Compiler.getInstance();
// if (verbose) {
// System.out.println("[Compiling class " + name + "]");
// }
// comp.setDestination(destination);
// boolean result = comp.compile(name);
// if (result == false) {
// throw comp.getException();
// }
}
private static String getPrettyName(Class cls) {
StringBuffer str = new StringBuffer();
for (int count = 0;; count++) {
if (!cls.isArray()) {
str.append(cls.getName());
for (; count > 0; count--) {
str.append("[]");
}
return (str.toString());
}
cls = cls.getComponentType();
}
}
/**
* Sort exceptions so the most general go last.
*/
private Class[] sortExceptions(Class[] except) {
for (int i = 0; i < except.length; i++) {
for (int j = i+1; j < except.length; j++) {
if (except[i].isAssignableFrom(except[j])) {
Class tmp = except[i];
except[i] = except[j];
except[j] = tmp;
}
}
}
return (except);
}
/**
* Process the options until we find the first argument.
*/
private void parseOptions() {
for (;;) {
if (next >= args.length || args[next].charAt(0) != '-') {
break;
}
String arg = args[next];
next++;
if (arg.equals("-keep")) {
keep = true;
}
else if (arg.equals("-keepgenerated")) {
keep = true;
}
else if (arg.equals("-v1.1")) {
need11Stubs = true;
need12Stubs = false;
}
else if (arg.equals("-vcompat")) {
need11Stubs = true;
need12Stubs = true;
}
else if (arg.equals("-v1.2")) {
need11Stubs = false;
need12Stubs = true;
}
else if (arg.equals("-g")) {
}
else if (arg.equals("-depend")) {
}
else if (arg.equals("-nowarn")) {
}
else if (arg.equals("-verbose")) {
verbose = true;
}
else if (arg.equals("-nocompile")) {
compile = false;
}
else if (arg.equals("-classpath")) {
next++;
}
else if (arg.equals("-d")) {
destination = args[next];
next++;
}
else if (arg.charAt(1) == 'J') {
}
else {
System.err.println("Unknown option: " + arg);
}
}
}
private static void usage() {
System.out.println(
"usage: rmic [-options] classes\n" +
"Options are:\n" +
" -keep Don't delete any intermediate files\n" +
" -keepgenerated Same as -keep\n" +
" -v1.1 Java 1.1 style stubs only\n" +
" -vcompat Java 1.1 & Java 1.2 stubs\n" +
" -v1.2 Java 1.2 style stubs only\n" +
" -g * Generated debugging information\n" +
" -depend * Recompile out-of-date files\n" +
" -nowarn * Suppress warning messages\n" +
" -nocompile Don't compile the generated files\n" +
" -verbose Output what's going on\n" +
" -classpath <path> * Use given path as classpath\n" +
" -d <directory> Specify where to place generated classes\n" +
" -J<flag> * Pass flag to Java\n" +
" * Option currently ignored"
);
}
static class MethodRef
implements Comparable {
Method meth;
String sig;
long hash;
MethodRef(Method m) {
meth = m;
// We match on the name - but what about overloading? - XXX
sig = m.getName();
hash = RMIHashes.getMethodHash(m);
}
public int compareTo(Object obj) {
MethodRef that = (MethodRef)obj;
return (this.sig.compareTo(that.sig));
}
}
}

90
libjava/gnu/java/rmi/rmic/TabbedWriter.java Normal file
View file

@ -0,0 +1,90 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.rmic;
import java.io.FilterWriter;
import java.io.Writer;
import java.io.IOException;
public class TabbedWriter
extends FilterWriter {
private static final String defaultTabstring = " ";
private char[] tabstring;
private int tabs;
public TabbedWriter(Writer o) {
this(o, defaultTabstring);
}
public TabbedWriter(Writer o, String str) {
super(o);
tabs = 0;
tabstring = str.toCharArray();
}
public void write(int c) throws IOException {
out.write(c);
if (c == '\n') {
for (int i = 0; i < tabs; i++) {
out.write(tabstring, 0, tabstring.length);
}
}
}
public void write(char cbuf[], int off, int len) throws IOException {
for (int i = 0; i < len; i++) {
write((int)cbuf[i+off]);
}
}
public void write(String str, int off, int len) throws IOException {
write(str.toCharArray(), off, len);
}
public void unindent() throws IOException {
unindent(1);
}
public void unindent(int nr) throws IOException {
indent(-nr);
}
public void indent() throws IOException {
indent(1);
}
public void indent(int nr) throws IOException {
tabs += nr;
if (tabs < 0) {
tabs = 0;
}
write((int)'\n');
}
}

53
libjava/gnu/java/rmi/server/ProtocolConstants.java Normal file
View file

@ -0,0 +1,53 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.server;
public interface ProtocolConstants {
final public static int PROTOCOL_HEADER = 0x4a524d49; // JRMI
final public static int PROTOCOL_VERSION = 2;
final public static int STREAM_PROTOCOL = 0x4b;
final public static int SINGLE_OP_PROTOCOL = 0x4c;
final public static int MULTIPLEX_PROTOCOL = 0x4d;
final public static int PROTOCOL_ACK = 0x4e;
final public static int PROTOCOL_NACK = 0x4f;
final public static int MESSAGE_CALL = 0x50;
final public static int MESSAGE_CALL_ACK = 0x51;
final public static int MESSAGE_PING = 0x52;
final public static int MESSAGE_PING_ACK = 0x53;
final public static int MESSAGE_DGCACK = 0x54;
final public static int RETURN_ACK = 0x01;
final public static int RETURN_NACK = 0x02;
final public static int DEFAULT_PROTOCOL = STREAM_PROTOCOL;
};

49
libjava/gnu/java/rmi/server/RMIDefaultSocketFactory.java Normal file
View file

@ -0,0 +1,49 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.server;
import java.rmi.server.RMISocketFactory;
import java.io.IOException;
import java.net.Socket;
import java.net.ServerSocket;
public class RMIDefaultSocketFactory
extends RMISocketFactory {
public RMIDefaultSocketFactory() {
}
public Socket createSocket(String host, int port) throws IOException {
return (new Socket(host, port));
}
public ServerSocket createServerSocket(int port) throws IOException {
return (new ServerSocket(port));
}
}

45
libjava/gnu/java/rmi/server/RMIHashes.java Normal file
View file

@ -0,0 +1,45 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.server;
import java.lang.reflect.Method;
import java.lang.Class;
import gnu.java.security.provider.SHA;
public class RMIHashes
{
public static long getMethodHash(Method meth)
{
return meth.hashCode ();
}
public static long getInterfaceHash(Class clazz)
{
return clazz.hashCode ();
}
}

65
libjava/gnu/java/rmi/server/RMIObjectInputStream.java Normal file
View file

@ -0,0 +1,65 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.server;
import java.io.ObjectStreamClass;
import java.io.ObjectInputStream;
import java.io.InputStream;
import java.io.IOException;
import java.net.URL;
import java.net.MalformedURLException;
import java.rmi.server.RMIClassLoader;
public class RMIObjectInputStream
extends ObjectInputStream {
UnicastConnectionManager manager;
public RMIObjectInputStream(InputStream strm, UnicastConnectionManager man) throws IOException {
super(strm);
manager = man;
enableResolveObject(true);
}
protected Class resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
//System.out.println("Resolving class: " + desc.getName());
String annotation = (String)readObject();
if (annotation == null) {
return (super.resolveClass(desc));
}
else {
try {
return (RMIClassLoader.loadClass(new URL(annotation), desc.getName()));
}
catch (MalformedURLException _) {
throw new ClassNotFoundException(desc.getName());
}
}
}
}

47
libjava/gnu/java/rmi/server/RMIObjectOutputStream.java Normal file
View file

@ -0,0 +1,47 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.server;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.rmi.server.RMIClassLoader;
public class RMIObjectOutputStream
extends ObjectOutputStream {
public RMIObjectOutputStream(OutputStream strm) throws IOException {
super(strm);
}
protected void annotateClass(Class cls) throws IOException {
//System.out.println("Annotating class: " + cls);
writeObject(RMIClassLoader.getClassAnnotation(cls));
}
}

162
libjava/gnu/java/rmi/server/UnicastConnection.java Normal file
View file

@ -0,0 +1,162 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.server;
import java.lang.Runnable;
import java.net.Socket;
import java.net.ServerSocket;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectOutput;
import java.io.ObjectInput;
import java.io.IOException;
import java.rmi.RemoteException;
public class UnicastConnection
implements Runnable, ProtocolConstants {
UnicastConnectionManager manager;
Socket sock;
DataInputStream din;
DataOutputStream dout;
ObjectInputStream oin;
ObjectOutputStream oout;
UnicastConnection(UnicastConnectionManager man, Socket sock) {
this.manager = man;
this.sock = sock;
}
void acceptConnection() throws IOException {
//System.out.println("Accepting connection on " + lport);
din = new DataInputStream(sock.getInputStream());
dout = new DataOutputStream(sock.getOutputStream());
int sig = din.readInt();
if (sig != PROTOCOL_HEADER) {
throw new IOException("bad protocol header");
}
short ver = din.readShort();
if (ver != PROTOCOL_VERSION) {
throw new IOException("bad protocol version");
}
int protocol = din.readUnsignedByte();
if (protocol != SINGLE_OP_PROTOCOL) {
// Send an ACK
dout.writeByte(PROTOCOL_ACK);
// Send my hostname and port
dout.writeUTF(manager.serverName);
dout.writeInt(manager.serverPort);
// Read their hostname and port
String rhost = din.readUTF();
int rport = din.readInt();
}
// Okay, ready to roll ...
}
void makeConnection(int protocol) throws IOException {
dout = new DataOutputStream(sock.getOutputStream());
din = new DataInputStream(sock.getInputStream());
// Send header
dout.writeInt(PROTOCOL_HEADER);
dout.writeShort(PROTOCOL_VERSION);
dout.writeByte(protocol);
dout.flush();
if (protocol != SINGLE_OP_PROTOCOL) {
// Get back ack.
int ack = din.readUnsignedByte();
if (ack != PROTOCOL_ACK) {
throw new RemoteException("Unsupported protocol");
}
// Read in host and port
String dicard_rhost = din.readUTF();
int discard_rport = din.readInt();
// Send them my endpoint
dout.writeUTF(manager.serverName);
dout.writeInt(manager.serverPort);
}
// Okay, ready to roll ...
}
DataInputStream getDataInputStream() throws IOException {
return (din);
}
DataOutputStream getDataOutputStream() throws IOException {
return (dout);
}
ObjectInputStream getObjectInputStream() throws IOException {
if (oin == null) {
oin = new RMIObjectInputStream(din, manager);
}
return (oin);
}
ObjectOutputStream getObjectOutputStream() throws IOException {
if (oout == null) {
oout = new RMIObjectOutputStream(dout);
}
return (oout);
}
void disconnect() {
oin = null;
oout = null;
try {
sock.close();
}
catch (IOException _) {
}
din = null;
dout = null;
sock = null;
}
/**
* We run connects on the server. Dispatch it then discard it.
*/
public void run() {
try {
UnicastServer.dispatch(this);
manager.discardConnection(this);
}
catch (Exception e) {
e.printStackTrace();
}
}
}

262
libjava/gnu/java/rmi/server/UnicastConnectionManager.java Normal file
View file

@ -0,0 +1,262 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.server;
import java.rmi.server.RMISocketFactory;
import java.rmi.server.RMIServerSocketFactory;
import java.rmi.server.RMIClientSocketFactory;
import java.rmi.RemoteException;
import gnu.java.rmi.server.UnicastConnection;
import java.util.Hashtable;
import java.net.Socket;
import java.net.ServerSocket;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectInput;
import java.lang.Thread;
import java.lang.Runnable;
import java.net.InetAddress;
import java.net.UnknownHostException;
public class UnicastConnectionManager
implements Runnable, ProtocolConstants {
private static String localhost;
private static Hashtable servers = new Hashtable();
private Thread serverThread;
private ServerSocket ssock;
String serverName;
int serverPort;
private RMIServerSocketFactory serverFactory;
private RMIClientSocketFactory clientFactory;
static {
try {
localhost = InetAddress.getLocalHost().getHostName();
}
catch (UnknownHostException _) {
localhost = "localhost";
}
}
private UnicastConnectionManager(String host, int port, RMIClientSocketFactory csf) {
ssock = null;
serverName = host;
serverPort = port;
serverFactory = null;
clientFactory = csf;
}
private UnicastConnectionManager(int port, RMIServerSocketFactory ssf) {
try {
ssock = ssf.createServerSocket(port);
serverPort = ssock.getLocalPort();
}
catch (IOException _) {
try {
ssock = ssf.createServerSocket(0);
serverPort = ssock.getLocalPort();
}
catch (IOException __) {
ssock = null;
serverPort = 0;
}
}
serverName = localhost;
serverFactory = ssf;
clientFactory = null;
}
/**
* Return a client connection manager which will connect to the given
* host/port.
*/
public static synchronized UnicastConnectionManager getInstance(String host, int port, RMIClientSocketFactory csf) {
//System.out.println("getInstance: " + host + "," + port + "," + csf);
if (csf == null) {
csf = RMISocketFactory.getSocketFactory();
}
TripleKey key = new TripleKey(host, port, csf);
UnicastConnectionManager man = (UnicastConnectionManager)servers.get(key);
if (man == null) {
man = new UnicastConnectionManager(host, port, csf);
servers.put(key, man);
}
return (man);
}
/**
* Return a server connection manager which will accept connection on the
* given port.
*/
public static synchronized UnicastConnectionManager getInstance(int port, RMIServerSocketFactory ssf) {
//System.out.println("getInstance: " + port + "," + ssf);
if (ssf == null) {
ssf = RMISocketFactory.getSocketFactory();
}
TripleKey key = new TripleKey(localhost, port, ssf);
UnicastConnectionManager man = (UnicastConnectionManager)servers.get(key);
if (man == null) {
man = new UnicastConnectionManager(port, ssf);
// The provided port might not be the set port.
key.port = man.serverPort;
servers.put(key, man);
}
return (man);
}
/**
* Get a connection from this manager.
*/
public UnicastConnection getConnection() throws IOException {
if (ssock == null) {
return (getClientConnection());
}
else {
return (getServerConnection());
}
}
/**
* Accept a connection to this server.
*/
private UnicastConnection getServerConnection() throws IOException {
Socket sock = ssock.accept();
UnicastConnection conn = new UnicastConnection(this, sock);
conn.acceptConnection();
//System.out.println("Server connection " + conn);
return (conn);
}
/**
* Make a conection from this client to the server.
*/
private UnicastConnection getClientConnection() throws IOException {
Socket sock = clientFactory.createSocket(serverName, serverPort);
UnicastConnection conn = new UnicastConnection(this, sock);
conn.makeConnection(DEFAULT_PROTOCOL);
//System.out.println("Client connection " + conn);
return (conn);
}
/**
* Discard a connection when we're done with it - maybe it can be
* recycled.
*/
public void discardConnection(UnicastConnection conn) {
//System.out.println("Discarding connection " + conn);
conn.disconnect();
}
/**
* Start a server on this manager if it's a server socket and we've not
* already got one running.
*/
public void startServer() {
synchronized(this) {
if (ssock == null || serverThread != null) {
return;
}
serverThread = new Thread(this);
}
serverThread.start();
}
/**
* Server thread for connection manager.
*/
public void run() {
for (;;) {
try {
//System.out.println("Waiting for connection on " + serverPort);
UnicastConnection conn = getServerConnection();
(new Thread(conn)).start();
}
catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* Serialization routine.
*/
void write(ObjectOutput out) throws IOException {
out.writeUTF(serverName);
out.writeInt(serverPort);
}
/**
* Serialization routine.
*/
static UnicastConnectionManager read(ObjectInput in) throws IOException {
String host = in.readUTF();
int port = in.readInt();
RMIClientSocketFactory csf = ((RMIObjectInputStream)in).manager.clientFactory;
return (getInstance(host, port, csf));
}
}
/**
* This is use as the hashkey for the client/server connections.
*/
class TripleKey {
String host;
int port;
Object other;
TripleKey(String host, int port, Object other) {
this.host = host;
this.port = port;
this.other = other;
}
/**
* Hash code just include the host and other - we ignore the port since
* this has unusual matching behaviour.
*/
public int hashCode() {
return (host.hashCode() ^ other.hashCode());
}
public boolean equals(Object obj) {
if (obj instanceof TripleKey) {
TripleKey other = (TripleKey)obj;
if (this.host.equals(other.host) &&
this.other == other.other &&
(this.port == other.port || this.port == 0 || other.port == 0)) {
return (true);
}
}
return (false);
}
}

219
libjava/gnu/java/rmi/server/UnicastRef.java Normal file
View file

@ -0,0 +1,219 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.server;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.RemoteRef;
import java.rmi.server.RMISocketFactory;
import java.rmi.server.RMIClientSocketFactory;
import java.rmi.server.RMIServerSocketFactory;
import java.rmi.server.RemoteObject;
import java.rmi.server.RemoteCall;
import java.rmi.server.UnicastRemoteObject;
import java.rmi.server.Operation;
import java.rmi.server.ObjID;
import java.rmi.server.UID;
import java.lang.reflect.Method;
import java.io.ObjectOutput;
import java.io.ObjectInput;
import java.io.IOException;
import java.net.Socket;
import java.net.InetAddress;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
public class UnicastRef
implements RemoteRef, ProtocolConstants {
public ObjID objid;
UnicastConnectionManager manager;
/**
* Used by serialization.
*/
private UnicastRef() {
}
public UnicastRef(ObjID objid, String host, int port, RMIClientSocketFactory csf) {
this(objid);
manager = UnicastConnectionManager.getInstance(host, port, csf);
}
public UnicastRef(ObjID objid) {
this.objid = objid;
}
public Object invoke(Remote obj, Method method, Object[] params, long opnum) throws Exception {
return (invokeCommon(obj, method, params, -1, opnum));
}
private Object invokeCommon(Remote obj, Method method, Object[] params, int opnum, long hash) throws Exception {
UnicastConnection conn;
try {
conn = manager.getConnection();
}
catch (IOException e1) {
throw new RemoteException("connection failed to host: " + manager.serverName, e1);
}
ObjectOutputStream out;
DataOutputStream dout;
try {
dout = conn.getDataOutputStream();
dout.writeByte(MESSAGE_CALL);
out = conn.getObjectOutputStream();
objid.write(out);
out.writeInt(opnum);
out.writeLong(hash);
if (params != null) {
for (int i = 0; i < params.length; i++) {
if (params[i] instanceof UnicastRemoteObject) {
out.writeObject(UnicastRemoteObject.exportObject((UnicastRemoteObject)params[i]));
}
else {
out.writeObject(params[i]);
}
}
}
out.flush();
}
catch (IOException e2) {
throw new RemoteException("call failed: ", e2);
}
int returncode;
Object returnval;
DataInputStream din;
ObjectInputStream in;
UID ack;
try {
din = conn.getDataInputStream();
if (din.readUnsignedByte() != MESSAGE_CALL_ACK) {
throw new RemoteException("Call not acked");
}
in = conn.getObjectInputStream();
returncode = in.readUnsignedByte();
ack = UID.read(in);
returnval = in.readObject();
}
catch (IOException e3) {
throw new RemoteException("call return failed: ", e3);
}
manager.discardConnection(conn);
if (returncode != RETURN_ACK) {
throw (Exception)returnval;
}
return (returnval);
}
/**
* @deprecated
*/
public RemoteCall newCall(RemoteObject obj, Operation[] op, int opnum, long hash) throws RemoteException {
return (new UnicastRemoteCall(obj, opnum, hash));
}
/**
* @deprecated
*/
public void invoke(RemoteCall call) throws Exception {
UnicastRemoteCall c = (UnicastRemoteCall)call;
Object ret = invokeCommon((Remote)c.getObject(), (Method)null, c.getArguments(), c.getOpnum(), c.getHash());
c.setReturnValue(ret);
}
/**
* @deprecated
*/
public void done(RemoteCall call) throws RemoteException {
/* Does nothing */
}
public void writeExternal(ObjectOutput out) throws IOException {
if (manager == null) {
throw new IOException("no connection");
}
manager.write(out);
objid.write(out);
out.writeByte(RETURN_ACK);
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
manager = UnicastConnectionManager.read(in);
objid = ObjID.read(in);
if (in.readByte() != RETURN_ACK) {
throw new IOException("no ack found");
}
}
public boolean remoteEquals(RemoteRef ref) {
throw new Error("Not implemented");
}
public int remoteHashCode() {
throw new Error("Not implemented");
}
public String getRefClass(ObjectOutput out) {
return ("UnicastRef");
}
public String remoteToString() {
throw new Error("Not implemented");
}
public void dump(UnicastConnection conn) {
try {
DataInputStream din = conn.getDataInputStream();
for (;;) {
int b = din.readUnsignedByte();
System.out.print(Integer.toHexString(b));
if (b >= 32 && b < 128) {
System.out.print(": " + (char)b);
}
System.out.println();
}
}
catch (IOException _) {
}
}
}

301
libjava/gnu/java/rmi/server/UnicastRemoteCall.java Normal file
View file

@ -0,0 +1,301 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.server;
import java.lang.Exception;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectInput;
import java.io.StreamCorruptedException;
import java.rmi.server.RemoteCall;
import java.util.Vector;
public class UnicastRemoteCall
implements RemoteCall {
private UnicastConnection conn;
private Object result;
private Object object;
private int opnum;
private long hash;
private Vector vec;
private int ptr;
/**
* Incoming call.
*/
UnicastRemoteCall(UnicastConnection conn) {
this.conn = conn;
}
/**
* Outgoing call.
*/
UnicastRemoteCall(Object obj, int opnum, long hash) {
this.object = obj;
this.opnum = opnum;
this.hash = hash;
}
public ObjectOutput getOutputStream() throws IOException {
vec = new Vector();
return (new DummyObjectOutputStream());
}
public void releaseOutputStream() throws IOException {
// Does nothing.
}
public ObjectInput getInputStream() throws IOException {
if (conn != null) {
return (conn.getObjectInputStream());
}
else {
ptr = 0;
return (new DummyObjectInputStream());
}
}
public void releaseInputStream() throws IOException {
// Does nothing.
}
public ObjectOutput getResultStream(boolean success) throws IOException, StreamCorruptedException {
vec = new Vector();
return (new DummyObjectOutputStream());
}
public void executeCall() throws Exception {
throw new Error("Not implemented");
}
public void done() throws IOException {
/* Does nothing */
}
Object returnValue() {
return (vec.elementAt(0));
}
Object[] getArguments() {
return (vec.toArray());
}
Object getObject() {
return (object);
}
int getOpnum() {
return (opnum);
}
long getHash() {
return (hash);
}
void setReturnValue(Object obj) {
vec.removeAllElements();
vec.addElement(obj);
}
/**
* Dummy object output class.
*/
private class DummyObjectOutputStream implements ObjectOutput {
public void writeBoolean(boolean v) throws IOException {
vec.addElement(new Boolean(v));
}
public void writeByte(int v) throws IOException {
vec.addElement(new Byte((byte)v));
}
public void writeChar(int v) throws IOException {
vec.addElement(new Character((char)v));
}
public void writeDouble(double v) throws IOException {
vec.addElement(new Double(v));
}
public void writeFloat(float v) throws IOException {
vec.addElement(new Float(v));
}
public void writeInt(int v) throws IOException {
vec.addElement(new Integer(v));
}
public void writeLong(long v) throws IOException {
vec.addElement(new Long(v));
}
public void writeShort(int v) throws IOException {
vec.addElement(new Short((short)v));
}
public void writeObject(Object obj) throws IOException {
vec.addElement(obj);
}
public void write(byte b[]) throws IOException {
throw new IOException("not required");
}
public void write(byte b[], int off, int len) throws IOException {
throw new IOException("not required");
}
public void write(int b) throws IOException {
throw new IOException("not required");
}
public void writeBytes(String s) throws IOException {
throw new IOException("not required");
}
public void writeChars(String s) throws IOException {
throw new IOException("not required");
}
public void writeUTF(String str) throws IOException {
throw new IOException("not required");
}
public void flush() throws IOException {
}
public void close() throws IOException {
}
}
/**
* Dummy object input class.
*/
private class DummyObjectInputStream implements ObjectInput {
public boolean readBoolean() throws IOException {
Object obj = vec.elementAt(ptr++);
return (((Boolean)obj).booleanValue());
}
public byte readByte() throws IOException {
Object obj = vec.elementAt(ptr++);
return (((Byte)obj).byteValue());
}
public char readChar() throws IOException {
Object obj = vec.elementAt(ptr++);
return (((Character)obj).charValue());
}
public double readDouble() throws IOException {
Object obj = vec.elementAt(ptr++);
return (((Double)obj).doubleValue());
}
public float readFloat() throws IOException {
Object obj = vec.elementAt(ptr++);
return (((Float)obj).floatValue());
}
public int readInt() throws IOException {
Object obj = vec.elementAt(ptr++);
return (((Integer)obj).intValue());
}
public long readLong() throws IOException {
Object obj = vec.elementAt(ptr++);
return (((Long)obj).longValue());
}
public short readShort() throws IOException {
Object obj = vec.elementAt(ptr++);
return (((Short)obj).shortValue());
}
public Object readObject() throws IOException {
return (vec.elementAt(ptr++));
}
public int read(byte b[]) throws IOException {
throw new IOException("not required");
}
public int read(byte b[], int off, int len) throws IOException {
throw new IOException("not required");
}
public int read() throws IOException {
throw new IOException("not required");
}
public long skip(long n) throws IOException {
throw new IOException("not required");
}
public int available() throws IOException {
throw new IOException("not required");
}
public void readFully(byte b[]) throws IOException {
throw new IOException("not required");
}
public void readFully(byte b[], int off, int len) throws IOException {
throw new IOException("not required");
}
public String readLine() throws IOException {
throw new IOException("not required");
}
public String readUTF() throws IOException {
throw new IOException("not required");
}
public int readUnsignedByte() throws IOException {
throw new IOException("not required");
}
public int readUnsignedShort() throws IOException {
throw new IOException("not required");
}
public int skipBytes(int n) throws IOException {
throw new IOException("not required");
}
public void close() throws IOException {
}
}
}

40
libjava/gnu/java/rmi/server/UnicastRemoteStub.java Normal file
View file

@ -0,0 +1,40 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.server;
import java.rmi.server.RemoteStub;
import java.rmi.server.RemoteRef;
public class UnicastRemoteStub
extends RemoteStub {
public static void setStubRef(RemoteStub stub, RemoteRef ref) {
setRef(stub, ref);
}
}

119
libjava/gnu/java/rmi/server/UnicastServer.java Normal file
View file

@ -0,0 +1,119 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.server;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.util.Hashtable;
import java.net.UnknownHostException;
import java.rmi.server.ObjID;
import java.rmi.server.UnicastRemoteObject;
import java.rmi.server.UID;
import java.rmi.server.RemoteRef;
import java.rmi.RemoteException;
import java.rmi.NoSuchObjectException;
import gnu.java.rmi.dgc.DGCImpl;
public class UnicastServer
implements ProtocolConstants {
static private Hashtable objects = new Hashtable();
static private DGCImpl dgc;
public static void exportObject(UnicastServerRef obj) {
startDGC();
objects.put(obj.objid, obj);
obj.manager.startServer();
}
private static synchronized void startDGC() {
if (dgc == null) {
try {
dgc = new DGCImpl();
((UnicastServerRef)dgc.getRef()).exportObject(dgc);
}
catch (RemoteException e) {
e.printStackTrace();
}
}
}
public static void dispatch(UnicastConnection conn) throws Exception {
switch (conn.getDataInputStream().readUnsignedByte()) {
case MESSAGE_CALL:
incomingMessageCall(conn);
break;
default:
throw new Exception("bad method type");
}
}
private static void incomingMessageCall(UnicastConnection conn) throws IOException {
ObjectInputStream in = conn.getObjectInputStream();
ObjID objid = ObjID.read(in);
int method = in.readInt();
long hash = in.readLong();
//System.out.println("ObjID: " + objid + ", method: " + method + ", hash: " + hash);
// Use the objid to locate the relevant UnicastServerRef
UnicastServerRef uref = (UnicastServerRef)objects.get(objid);
Object returnval;
int returncode = RETURN_ACK;
if (uref != null) {
try {
// Dispatch the call to it.
returnval = uref.incomingMessageCall(conn, method, hash);
}
catch (Exception e) {
returnval = e;
returncode = RETURN_NACK;
}
}
else {
returnval = new NoSuchObjectException("");
returncode = RETURN_NACK;
}
conn.getDataOutputStream().writeByte(MESSAGE_CALL_ACK);
ObjectOutputStream out = conn.getObjectOutputStream();
out.writeByte(returncode);
(new UID()).write(out);
out.writeObject(returnval);
out.flush();
}
}

198
libjava/gnu/java/rmi/server/UnicastServerRef.java Normal file
View file

@ -0,0 +1,198 @@
/*
Copyright (c) 1996, 1997, 1998, 1999 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License.
*/
package gnu.java.rmi.server;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.RemoteStub;
import java.rmi.server.ObjID;
import java.rmi.server.ServerRef;
import java.rmi.server.RemoteRef;
import java.rmi.server.ServerNotActiveException;
import java.rmi.server.RMIClientSocketFactory;
import java.rmi.server.RMIServerSocketFactory;
import java.rmi.server.UID;
import java.rmi.server.Skeleton;
import java.rmi.server.RemoteCall;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
import java.lang.Thread;
import java.lang.Exception;
import java.io.IOException;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Hashtable;
public class UnicastServerRef
extends UnicastRef {
final static private Class[] stubprototype = new Class[] { RemoteRef.class };
Remote myself;
private Skeleton skel;
private RemoteStub stub;
private Hashtable methods;
public UnicastServerRef(ObjID id, int port, RMIServerSocketFactory ssf) {
super(id);
manager = UnicastConnectionManager.getInstance(port, ssf);
}
public RemoteStub exportObject(Remote obj) throws RemoteException {
if (myself == null) {
myself = obj;
// Find and install the stub
Class cls = obj.getClass();
stub = (RemoteStub)getHelperClass(cls, "_Stub");
if (stub == null) {
throw new RemoteException("failed to export: " + cls);
}
// Find and install the skeleton (if there is one)
skel = (Skeleton)getHelperClass(cls, "_Skel");
// Build hash of methods which may be called.
buildMethodHash(obj.getClass());
// Export it.
UnicastServer.exportObject(this);
}
return (stub);
}
private Object getHelperClass(Class cls, String type) {
try {
String classname = cls.getName();
Class scls = Class.forName(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 {
throw new Error("Not implemented");
}
private void buildMethodHash(Class cls) {
methods = new Hashtable();
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]);
methods.put(new Long (hash), meths[i]);
//System.out.println("meth = " + meths[i] + ", hash = " + hash);
}
}
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 {
args[i] = in.readObject();
}
catch (Exception t) {
t.printStackTrace();
throw t;
}
}
return (meth.invoke(myself, args));
}
// 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);
return (call.returnValue());
}
}
}