MarshalledInstance contains an object in serialized
* form. The contained object can be deserialized on demand when
* explicitly requested. This allows an object to be sent from one VM
* to another in a way that allows the receiver to control when and if
* the object is deserialized.
*
* The contained object is specified at construction time and can
* either be provided in unserialized or serialized form. If provided
* in unserialized form it will be serialized during construction
* with the serialization semantics defined by
* MarshalOutputStream. In particular, classes are annotated
* with a codebase URL from which the class can be loaded (if available).
*
* If the MarshalledInstance needs to deserialize the
* contained object then the contained object will be deserialized with the
* deserialization semantics defined by MarshalInputStream.
* In particular, the codebase annotations associated with the contained
* object may be used to load classes referenced by the contained object.
*
* MarshalledInstance provides functionality similar to
* java.rmi.MarshalledObject, but additionally provides
* for the verification of codebase integrity. Unlike
* java.rmi.MarshalledObject, it does not perform remote
* object-to-stub replacement.
*
* @author Sun Microsystems, Inc.
* @since 2.0
*/
public class MarshalledInstance implements Serializable {
/**
* @serial Bytes of serialized representation. If objBytes is
* null then the object marshalled was a null
* reference.
*/
private byte[] objBytes = null;
/**
* @serial Bytes of location annotations, which are ignored by
* equals. If locBytes is null, there were no
* non-null annotations during marshalling.
*/
private byte[] locBytes = null;
/**
* @serial Stored hash code of contained object.
*
* @see #hashCode
*/
private int hash;
static final long serialVersionUID = -5187033771082433496L;
/**
* Creates a new MarshalledInstance that contains the
* marshalled representation of the current state of the supplied
* object. The object is serialized with the semantics defined by
* MarshalOutputStream. The output stream used to marshal the
* object implements {@link ObjectStreamContext} and returns an empty
* collection from its {@link ObjectStreamContext#getObjectStreamContext
* getObjectStreamContext} method.
*
* @param obj The Object to be contained in the new
* MarshalledInstance
* @throws IOException if the object cannot be serialized
*/
public MarshalledInstance(Object obj) throws IOException {
this(obj, Collections.EMPTY_SET);
}
/**
* Creates a new MarshalledInstance that contains the
* marshalled representation of the current state of the supplied
* object. The object is serialized with the semantics defined by
* MarshalOutputStream. The output stream used to marshal the
* object implements {@link ObjectStreamContext} and returns the given
* collection from its {@link ObjectStreamContext#getObjectStreamContext
* getObjectStreamContext} method.
*
* @param obj The Object to be contained in the new
* MarshalledInstance
* @param context the collection of context information objects
* @throws IOException if the object cannot be serialized
* @throws NullPointerException if context is null
*/
public MarshalledInstance(Object obj, Collection context)
throws IOException
{
if (context == null)
throw new NullPointerException();
if (obj == null) {
hash = 13; // null hash for java.rmi.MarshalledObject
return;
}
ByteArrayOutputStream bout = new ByteArrayOutputStream();
ByteArrayOutputStream lout = new ByteArrayOutputStream();
MarshalledInstanceOutputStream out =
new MarshalledInstanceOutputStream(bout, lout, context);
out.writeObject(obj);
out.flush();
objBytes = bout.toByteArray();
// locBytes is null if no annotations
locBytes = (out.hadAnnotations() ? lout.toByteArray() : null);
// Calculate hash from the marshalled representation of object
// so the hashcode will be comparable when sent between VMs.
//
// Note: This calculation must match the calculation in
// java.rmi.MarshalledObject since we use this hash
// in the converted MarshalledObject. The reverse is
// also true in that we use the MarshalledObject's
// hash for our hash. (see the MarshalledInstance(
// MarshalledObject) constructor)
//
int h = 0;
for (int i = 0; i < objBytes.length; i++) {
h = 31 * h + objBytes[i];
}
hash = h;
}
/**
* Creates a new MarshalledInstance from an
* existing MarshalledObject. An object equivalent
* to the object contained in the passed MarshalledObject
* will be contained in the new MarshalledInstance.
*
* The object contained in the passed MarshalledObject
* will not be unmarshalled as part of this call.
*
* @param mo The MarshalledObject that contains
* the object the new MarshalledInstance should
* contain
* @throws NullPointerException if mo is null
*/
public MarshalledInstance(java.rmi.MarshalledObject mo) {
if (mo == null)
throw new NullPointerException();
// To extract the java.rmi.MarshalledObject's fields we
// convert the mo into a net.jini.io.MarshalledObject.
// (See resolveClass() in FromMOInputStream) The private
// version of MarshalledObject allows access to the needed
// fields.
//
net.jini.io.MarshalledObject privateMO = null;
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(mo);
oos.flush();
byte[] bytes = baos.toByteArray();
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new FromMOInputStream(bais);
privateMO =
(net.jini.io.MarshalledObject)ois.readObject();
} catch (IOException ioe) {
throw new AssertionError(ioe);
} catch (ClassNotFoundException cnfe) {
throw new AssertionError(cnfe);
}
objBytes = privateMO.objBytes;
locBytes = privateMO.locBytes;
hash = privateMO.hash;
}
/**
* Creates a new MarshalledObject that will
* contain an object equivalent to the object contained
* in this MarshalledInstance object.
*
* The object contained in this MarshalledInstance
* object will not be unmarshalled as part of this call.
* @return A new MarshalledObject which
* contains an object equivalent to the object
* contained in this MarshalledInstance
*/
public java.rmi.MarshalledObject convertToMarshalledObject() {
// To create a java.rmi.MarshalledObject with previously
// serialized data we first create a private
// net.jini.io.MarshalledObject with the
// data and then convert it to the final object by changing
// the class during readObject(). (See resolveClass() in
// ToMOInputStream)
//
net.jini.io.MarshalledObject privateMO =
new net.jini.io.MarshalledObject();
privateMO.objBytes = objBytes;
privateMO.locBytes = locBytes;
privateMO.hash = hash;
java.rmi.MarshalledObject mo = null;
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(privateMO);
oos.flush();
byte[] bytes = baos.toByteArray();
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ToMOInputStream(bais);
mo = (java.rmi.MarshalledObject)ois.readObject();
} catch (IOException ioe) {
throw new AssertionError(ioe);
} catch (ClassNotFoundException cnfe) {
throw new AssertionError(cnfe);
}
return mo;
}
/**
* Returns a new copy of the contained object. Deserialization is
* performed with the semantics defined by MarshalInputStream.
* The input stream used to unmarshal the object implements {@link
* ObjectStreamContext} and returns a collection from its {@link
* ObjectStreamContext#getObjectStreamContext getObjectStreamContext}
* method which contains a single element of type {@link
* IntegrityEnforcement}; the {@link IntegrityEnforcement#integrityEnforced
* integrityEnforced} method of this element returns the specified
* verifyCodebaseIntegrity value.
*
MarshalledInstance implements this method by calling
* {@link #get(ClassLoader, boolean, ClassLoader, Collection)
* get}(null, verifyCodebaseIntegrity, null, null).
*
* @param verifyCodebaseIntegrity if true then
* codebase integrity is verified, otherwise code base
* integrity is not verified
* @return a new copy of the contained object
* @throws IOException if an
* IOException occurs while deserializing the
* object from its internal representation
* @throws ClassNotFoundException if any classes necessary
* for reconstructing the contained object can not
* be found or if verifyCodebaseIntegrity
* is true and the integrity of the
* contained object's codebase cannot be confirmed
*/
public Object get(final boolean verifyCodebaseIntegrity)
throws IOException, ClassNotFoundException
{
return get(null, verifyCodebaseIntegrity, null, null);
}
/**
* Returns a new copy of the contained object. Deserialization is
* performed with the semantics defined by MarshalInputStream.
* If context is not null
* the input stream used to unmarshal the object implements {@link
* ObjectStreamContext} and returns the given collection from its {@link
* ObjectStreamContext#getObjectStreamContext getObjectStreamContext}
* method.
*
If context is null
* the input stream used to unmarshal the object implements {@link
* ObjectStreamContext} and returns a collection from its {@link
* ObjectStreamContext#getObjectStreamContext getObjectStreamContext}
* method which contains a single element of type {@link
* IntegrityEnforcement}; the {@link IntegrityEnforcement#integrityEnforced
* integrityEnforced} method of this element returns the specified
* verifyCodebaseIntegrity value.
*
* @param defaultLoader the class loader value (possibly
* null) to pass as the defaultLoader
* argument to RMIClassLoader methods
* @param verifyCodebaseIntegrity if true then
* codebase integrity is verified, otherwise code base
* integrity is not verified
* @param verifierLoader the class loader value (possibly
* null) to pass to {@link
* net.jini.security.Security#verifyCodebaseIntegrity
* Security.verifyCodebaseIntegrity}, if
* verifyCodebaseIntegrity is true
* @param context the collection of context information objects or
* null
* @return a new copy of the contained object
* @throws IOException if an
* IOException occurs while deserializing the
* object from its internal representation
* @throws ClassNotFoundException if any classes necessary
* for reconstructing the contained object can not
* be found or if verifyCodebaseIntegrity
* is true and the integrity of the
* contained object's codebase cannot be confirmed
*/
public Object get(ClassLoader defaultLoader,
final boolean verifyCodebaseIntegrity,
ClassLoader verifierLoader,
Collection context)
throws IOException, ClassNotFoundException
{
if (objBytes == null) // must have been a null object
return null;
if (context == null) {
context = Collections.singleton(
new IntegrityEnforcement() {
public boolean integrityEnforced() {
return verifyCodebaseIntegrity;
}
} );
}
ByteArrayInputStream bin = new ByteArrayInputStream(objBytes);
// locBytes is null if no annotations
ByteArrayInputStream lin =
(locBytes == null ? null : new ByteArrayInputStream(locBytes));
MarshalledInstanceInputStream in =
new MarshalledInstanceInputStream(bin, lin,
defaultLoader,
verifyCodebaseIntegrity,
verifierLoader,
context);
in.useCodebaseAnnotations();
Object obj = in.readObject();
in.close();
return obj;
}
/**
* Compares this MarshalledInstance to another
* object. Returns true if and only if the argument refers to an instance
* of MarshalledInstance that contains exactly the same
* serialized form for its contained object as this object does and
* has the same class codebase annotations.
*
* @param obj the object to compare with this
* MarshalledInstance
* @return true if the argument contains an object
* with an equivalent serialized form and codebase;
* otherwise returns false
*/
public boolean fullyEquals(Object obj) {
if (equals(obj)) {
MarshalledInstance other = (MarshalledInstance)obj;
return Arrays.equals(locBytes, other.locBytes);
}
return false;
}
/**
* Compares this MarshalledInstance to another
* object. Returns true if and only if the argument refers to an instance
* of MarshalledInstance that contains exactly the same
* serialized form for its contained object as this object does. The
* comparison ignores any class codebase annotations, so that
* two objects can be equivalent if they have the same serialized
* representation, except for the codebase of each class in the
* serialized representation.
* @param obj the object to compare with this
* MarshalledInstance
* @return true if the argument contains an object
* with an equivalent serialized form; otherwise returns
* false
*/
public boolean equals(Object obj) {
if (obj == this)
return true;
if (obj instanceof MarshalledInstance) {
MarshalledInstance other = (MarshalledInstance)obj;
if (hash != other.hash)
return false;
return Arrays.equals(objBytes, other.objBytes);
}
return false;
}
/**
* Returns the hash code for this MarshalledInstance.
* The hash code is calculated only from the serialized form
* of the contained object.
* @return The hash code for this object
*/
public int hashCode() {
return hash;
}
/**
* Verify the case of null contained object.
*/
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException
{
in.defaultReadObject();
// If contained object is null, then hash and locBytes must be
// proper
//
if ((objBytes == null) && ((hash != 13) || (locBytes != null)))
throw new InvalidObjectException("Bad hash or annotation");
}
/**
* Protect against missing superclass.
*/
private void readObjectNoData() throws ObjectStreamException {
throw new InvalidObjectException("Bad class hierarchy");
}
/**
* This class is used to marshal objects for
* MarshalledInstance. It places the location annotations
* to one side so that two MarshalledInstances can be
* compared for equality if they differ only in location
* annotations. Objects written using this stream should be read back
* from a MarshalledInstanceInputStream.
*
* @see MarshalledInstanceInputStream
*/
private static class MarshalledInstanceOutputStream
extends MarshalOutputStream
{
/** The stream on which location objects are written. */
private ObjectOutputStream locOut;
/** true if non-null annotations are
* written.
*/
private boolean hadAnnotations;
/**
* Creates a new MarshalledObjectOutputStream whose
* non-location bytes will be written to objOut and whose
* location annotations (if any) will be written to
* locOut.
*/
public MarshalledInstanceOutputStream(OutputStream objOut,
OutputStream locOut,
Collection context)
throws IOException
{
super(objOut, context);
this.locOut = new ObjectOutputStream(locOut);
hadAnnotations = false;
}
/**
* Returns true if any non-null location
* annotations have been written to this stream.
*/
public boolean hadAnnotations() {
return hadAnnotations;
}
/**
* Overrides MarshalOutputStream.writeAnnotation
* implementation to write annotations to the location stream.
*/
protected void writeAnnotation(String loc) throws IOException {
hadAnnotations |= (loc != null);
locOut.writeObject(loc);
}
public void flush() throws IOException {
super.flush();
locOut.flush();
}
}
/**
* The counterpart to MarshalledInstanceOutputStream.
*
* @see MarshalledInstanceOutputStream
*/
private static class MarshalledInstanceInputStream
extends MarshalInputStream
{
/**
* The stream from which annotations will be read. If this is
* null, then all annotations were null.
*/
private ObjectInputStream locIn;
/**
* Creates a new MarshalledObjectInputStream that
* reads its objects from objIn and annotations
* from locIn. If locIn is
* null, then all annotations will be
* null.
*/
MarshalledInstanceInputStream(InputStream objIn,
InputStream locIn,
ClassLoader defaultLoader,
boolean verifyCodebaseIntegrity,
ClassLoader verifierLoader,
Collection context)
throws IOException
{
super(objIn,
defaultLoader,
verifyCodebaseIntegrity,
verifierLoader,
context);
this.locIn = (locIn == null ? null : new ObjectInputStream(locIn));
}
/**
* Overrides MarshalInputStream.readAnnotation to
* return locations from the stream we were given, or null
* if we were given a null location stream.
*/
protected String readAnnotation()
throws IOException, ClassNotFoundException
{
return (locIn == null ? null : (String)locIn.readObject());
}
}
/**
* Input stream to convert java.rmi.MarshalledObject
* into net.jini.io.MarshalledObject.
*/
private static class FromMOInputStream extends ObjectInputStream {
public FromMOInputStream(InputStream in) throws IOException {
super(in);
}
/**
* Overrides ObjectInputStream.resolveClass to change
* an occurence of class java.rmi.MarshalledObject to
* class net.jini.io.MarshalledObject.
*/
protected Class resolveClass(ObjectStreamClass desc)
throws IOException, ClassNotFoundException
{
if (desc.getName().equals("java.rmi.MarshalledObject")) {
return net.jini.io.MarshalledObject.class;
}
return super.resolveClass(desc);
}
}
/**
* Input stream to convert
* net.jini.io.MarshalledObject into
* java.rmi.MarshalledObject.
*/
private static class ToMOInputStream extends ObjectInputStream {
public ToMOInputStream(InputStream in) throws IOException {
super(in);
}
/**
* Overrides ObjectInputStream.resolveClass
* to change an occurence of class
* net.jini.io.MarshalledObject
* to class java.rmi.MarshalledObject.
*/
protected Class resolveClass(ObjectStreamClass desc)
throws IOException, ClassNotFoundException
{
if (desc.getName().equals("net.jini.io.MarshalledObject")) {
return java.rmi.MarshalledObject.class;
}
return super.resolveClass(desc);
}
}
}