/*
* Copyright (c) 1996, 2005, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package sun.rmi.transport;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.ObjID;
import java.rmi.server.RMIClientSocketFactory;
import java.rmi.server.RMIServerSocketFactory;
import java.util.Arrays;
import sun.rmi.transport.tcp.TCPEndpoint;
/**
* NOTE: There is a JDK-internal dependency on the existence of this
* class and its getClientSocketFactory method in the implementation
* of javax.management.remote.rmi.RMIConnector.
**/
public class LiveRef implements Cloneable {
/** wire representation for the object*/
private final Endpoint ep;
private final ObjID id;
/** cached connection service for the object */
private transient Channel ch;
/** flag to indicate whether this ref specifies a local server or
* is a ref for a remote object (surrogate)
*/
private final boolean isLocal;
/**
* Construct a "well-known" live reference to a remote object
* @param isLocalServer If true, indicates this ref specifies a local
* server in this address space; if false, the ref is for a remote
* object (hence a surrogate or proxy) in another address space.
*/
public LiveRef(ObjID objID, Endpoint endpoint, boolean isLocal) {
ep = endpoint;
id = objID;
this.isLocal = isLocal;
}
/**
* Construct a new live reference for a server object in the local
* address space.
*/
public LiveRef(int port) {
this((new ObjID()), port);
}
/**
* Construct a new live reference for a server object in the local
* address space, to use sockets of the specified type.
*/
public LiveRef(int port,
RMIClientSocketFactory csf,
RMIServerSocketFactory ssf)
{
this((new ObjID()), port, csf, ssf);
}
/**
* Construct a new live reference for a "well-known" server object
* in the local address space.
*/
public LiveRef(ObjID objID, int port) {
this(objID, TCPEndpoint.getLocalEndpoint(port), true);
}
/**
* Construct a new live reference for a "well-known" server object
* in the local address space, to use sockets of the specified type.
*/
public LiveRef(ObjID objID, int port, RMIClientSocketFactory csf,
RMIServerSocketFactory ssf)
{
this(objID, TCPEndpoint.getLocalEndpoint(port, csf, ssf), true);
}
/**
* Return a shallow copy of this ref.
*/
public Object clone() {
try {
LiveRef newRef = (LiveRef) super.clone();
return newRef;
} catch (CloneNotSupportedException e) {
throw new InternalError(e.toString());
}
}
/**
* Return the port number associated with this ref.
*/
public int getPort() {
return ((TCPEndpoint) ep).getPort();
}
/**
* Return the client socket factory associated with this ref.
*
* NOTE: There is a JDK-internal dependency on the existence of
* this method in the implementation of
* javax.management.remote.rmi.RMIConnector.
**/
public RMIClientSocketFactory getClientSocketFactory() {
return ((TCPEndpoint) ep).getClientSocketFactory();
}
/**
* Return the server socket factory associated with this ref.
*/
public RMIServerSocketFactory getServerSocketFactory() {
return ((TCPEndpoint) ep).getServerSocketFactory();
}
/**
* Export the object to accept incoming calls.
*/
public void exportObject(Target target) throws RemoteException {
ep.exportObject(target);
}
public Channel getChannel() throws RemoteException {
if (ch == null) {
ch = ep.getChannel();
}
return ch;
}
public ObjID getObjID() {
return id;
}
Endpoint getEndpoint() {
return ep;
}
public String toString() {
String type;
if (isLocal)
type = "local";
else
type = "remote";
return "[endpoint:" + ep + "(" + type + ")," +
"objID:" + id + "]";
}
public int hashCode() {
return id.hashCode();
}
public boolean equals(Object obj) {
if (obj != null && obj instanceof LiveRef) {
LiveRef ref = (LiveRef) obj;
return (ep.equals(ref.ep) && id.equals(ref.id) &&
isLocal == ref.isLocal);
} else {
return false;
}
}
public boolean remoteEquals(Object obj) {
if (obj != null && obj instanceof LiveRef) {
LiveRef ref = (LiveRef) obj;
TCPEndpoint thisEp = ((TCPEndpoint) ep);
TCPEndpoint refEp = ((TCPEndpoint) ref.ep);
RMIClientSocketFactory thisClientFactory =
thisEp.getClientSocketFactory();
RMIClientSocketFactory refClientFactory =
refEp.getClientSocketFactory();
/**
* Fix for 4254103: LiveRef.remoteEquals should not fail
* if one of the objects in the comparison has a null
* server socket. Comparison should only consider the
* following criteria:
*
* hosts, ports, client socket factories and object IDs.
*/
if (thisEp.getPort() != refEp.getPort() ||
!thisEp.getHost().equals(refEp.getHost()))
{
return false;
}
if ((thisClientFactory == null) ^ (refClientFactory == null)) {
return false;
}
if ((thisClientFactory != null) &&
!((thisClientFactory.getClass() ==
refClientFactory.getClass()) &&
(thisClientFactory.equals(refClientFactory))))
{
return false;
}
return (id.equals(ref.id));
} else {
return false;
}
}
public void write(ObjectOutput out, boolean useNewFormat)
throws IOException
{
boolean isResultStream = false;
if (out instanceof ConnectionOutputStream) {
ConnectionOutputStream stream = (ConnectionOutputStream) out;
isResultStream = stream.isResultStream();
/*
* Ensure that referential integrity is not broken while
* this LiveRef is in transit. If it is being marshalled
* as part of a result, it may not otherwise be strongly
* reachable after the remote call has completed; even if
* it is being marshalled as part of an argument, the VM
* may determine that the reference on the stack is no
* longer reachable after marshalling (see 6181943)--
* therefore, tell the stream to save a reference until a
* timeout expires or, for results, a DGCAck message has
* been received from the caller, or for arguments, the
* remote call has completed. For a "local" LiveRef, save
* a reference to the impl directly, because the impl is
* not reachable from the LiveRef (see 4114579);
* otherwise, save a reference to the LiveRef, for the
* client-side DGC to watch over. (Also see 4017232.)
*/
if (isLocal) {
ObjectEndpoint oe =
new ObjectEndpoint(id, ep.getInboundTransport());
Target target = ObjectTable.getTarget(oe);
if (target != null) {
Remote impl = target.getImpl();
if (impl != null) {
stream.saveObject(impl);
}
}
} else {
stream.saveObject(this);
}
}
// All together now write out the endpoint, id, and flag
// (need to choose whether or not to use old JDK1.1 endpoint format)
if (useNewFormat) {
((TCPEndpoint) ep).write(out);
} else {
((TCPEndpoint) ep).writeHostPortFormat(out);
}
id.write(out);
out.writeBoolean(isResultStream);
}
public static LiveRef read(ObjectInput in, boolean useNewFormat)
throws IOException, ClassNotFoundException
{
Endpoint ep;
ObjID id;
// Now read in the endpoint, id, and result flag
// (need to choose whether or not to read old JDK1.1 endpoint format)
if (useNewFormat) {
ep = TCPEndpoint.read(in);
} else {
ep = TCPEndpoint.readHostPortFormat(in);
}
id = ObjID.read(in);
boolean isResultStream = in.readBoolean();
LiveRef ref = new LiveRef(id, ep, false);
if (in instanceof ConnectionInputStream) {
ConnectionInputStream stream = (ConnectionInputStream)in;
// save ref to send "dirty" call after all args/returns
// have been unmarshaled.
stream.saveRef(ref);
if (isResultStream) {
// set flag in stream indicating that remote objects were
// unmarshaled. A DGC ack should be sent by the transport.
stream.setAckNeeded();
}
} else {
DGCClient.registerRefs(ep, Arrays.asList(new LiveRef[] { ref }));
}
return ref;
}
}