| /* |
| * Copyright (c) 1997, 2016, 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 java.rmi; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.ObjectInputFilter; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| import java.io.ObjectStreamConstants; |
| import java.io.OutputStream; |
| import java.io.Serializable; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| |
| import sun.rmi.server.MarshalInputStream; |
| import sun.rmi.server.MarshalOutputStream; |
| |
| /** |
| * A <code>MarshalledObject</code> contains a byte stream with the serialized |
| * representation of an object given to its constructor. The <code>get</code> |
| * method returns a new copy of the original object, as deserialized from |
| * the contained byte stream. The contained object is serialized and |
| * deserialized with the same serialization semantics used for marshaling |
| * and unmarshaling parameters and return values of RMI calls: When the |
| * serialized form is created: |
| * |
| * <ul> |
| * <li> classes are annotated with a codebase URL from where the class |
| * can be loaded (if available), and |
| * <li> any remote object in the <code>MarshalledObject</code> is |
| * represented by a serialized instance of its stub. |
| * </ul> |
| * |
| * <p>When copy of the object is retrieved (via the <code>get</code> method), |
| * if the class is not available locally, it will be loaded from the |
| * appropriate location (specified the URL annotated with the class descriptor |
| * when the class was serialized. |
| * |
| * <p><code>MarshalledObject</code> facilitates passing objects in RMI calls |
| * that are not automatically deserialized immediately by the remote peer. |
| * |
| * @param <T> the type of the object contained in this |
| * <code>MarshalledObject</code> |
| * |
| * @author Ann Wollrath |
| * @author Peter Jones |
| * @since 1.2 |
| */ |
| public final class MarshalledObject<T> implements Serializable { |
| /** |
| * @serial Bytes of serialized representation. If <code>objBytes</code> is |
| * <code>null</code> then the object marshalled was a <code>null</code> |
| * reference. |
| */ |
| private byte[] objBytes = null; |
| |
| /** |
| * @serial Bytes of location annotations, which are ignored by |
| * <code>equals</code>. If <code>locBytes</code> is null, there were no |
| * non-<code>null</code> annotations during marshalling. |
| */ |
| private byte[] locBytes = null; |
| |
| /** |
| * @serial Stored hash code of contained object. |
| * |
| * @see #hashCode |
| */ |
| private int hash; |
| |
| /** Filter used when creating the instance from a stream; may be null. */ |
| private transient ObjectInputFilter objectInputFilter = null; |
| |
| /** Indicate compatibility with 1.2 version of class. */ |
| private static final long serialVersionUID = 8988374069173025854L; |
| |
| /** |
| * Creates a new <code>MarshalledObject</code> that contains the |
| * serialized representation of the current state of the supplied object. |
| * The object is serialized with the semantics used for marshaling |
| * parameters for RMI calls. |
| * |
| * @param obj the object to be serialized (must be serializable) |
| * @exception IOException if an <code>IOException</code> occurs; an |
| * <code>IOException</code> may occur if <code>obj</code> is not |
| * serializable. |
| * @since 1.2 |
| */ |
| public MarshalledObject(T obj) throws IOException { |
| if (obj == null) { |
| hash = 13; |
| return; |
| } |
| |
| ByteArrayOutputStream bout = new ByteArrayOutputStream(); |
| ByteArrayOutputStream lout = new ByteArrayOutputStream(); |
| MarshalledObjectOutputStream out = |
| new MarshalledObjectOutputStream(bout, lout); |
| 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. |
| */ |
| int h = 0; |
| for (int i = 0; i < objBytes.length; i++) { |
| h = 31 * h + objBytes[i]; |
| } |
| hash = h; |
| } |
| |
| /** |
| * Reads in the state of the object and saves the stream's |
| * serialization filter to be used when the object is deserialized. |
| * |
| * @param stream the stream |
| * @throws IOException if an I/O error occurs |
| * @throws ClassNotFoundException if a class cannot be found |
| */ |
| private void readObject(ObjectInputStream stream) |
| throws IOException, ClassNotFoundException { |
| stream.defaultReadObject(); // read in all fields |
| objectInputFilter = stream.getObjectInputFilter(); |
| } |
| |
| /** |
| * Returns a new copy of the contained marshalledobject. The internal |
| * representation is deserialized with the semantics used for |
| * unmarshaling parameters for RMI calls. |
| * If the MarshalledObject was read from an ObjectInputStream, |
| * the filter from that stream is used to deserialize the object. |
| * |
| * @return a copy of the contained object |
| * @exception IOException if an <code>IOException</code> occurs while |
| * deserializing the object from its internal representation. |
| * @exception ClassNotFoundException if a |
| * <code>ClassNotFoundException</code> occurs while deserializing the |
| * object from its internal representation. |
| * could not be found |
| * @since 1.2 |
| */ |
| public T get() throws IOException, ClassNotFoundException { |
| if (objBytes == null) // must have been a null object |
| return null; |
| |
| ByteArrayInputStream bin = new ByteArrayInputStream(objBytes); |
| // locBytes is null if no annotations |
| ByteArrayInputStream lin = |
| (locBytes == null ? null : new ByteArrayInputStream(locBytes)); |
| MarshalledObjectInputStream in = |
| new MarshalledObjectInputStream(bin, lin, objectInputFilter); |
| @SuppressWarnings("unchecked") |
| T obj = (T) in.readObject(); |
| in.close(); |
| return obj; |
| } |
| |
| /** |
| * Return a hash code for this <code>MarshalledObject</code>. |
| * |
| * @return a hash code |
| */ |
| public int hashCode() { |
| return hash; |
| } |
| |
| /** |
| * Compares this <code>MarshalledObject</code> to another object. |
| * Returns true if and only if the argument refers to a |
| * <code>MarshalledObject</code> that contains exactly the same |
| * serialized representation of an object as this one does. The |
| * comparison ignores any class codebase annotation, meaning that |
| * two objects are equivalent if they have the same serialized |
| * representation <i>except</i> for the codebase of each class |
| * in the serialized representation. |
| * |
| * @param obj the object to compare with this <code>MarshalledObject</code> |
| * @return <code>true</code> if the argument contains an equivalent |
| * serialized object; <code>false</code> otherwise |
| * @since 1.2 |
| */ |
| public boolean equals(Object obj) { |
| if (obj == this) |
| return true; |
| |
| if (obj != null && obj instanceof MarshalledObject) { |
| MarshalledObject<?> other = (MarshalledObject<?>) obj; |
| |
| // if either is a ref to null, both must be |
| if (objBytes == null || other.objBytes == null) |
| return objBytes == other.objBytes; |
| |
| // quick, easy test |
| if (objBytes.length != other.objBytes.length) |
| return false; |
| |
| //!! There is talk about adding an array comparision method |
| //!! at 1.2 -- if so, this should be rewritten. -arnold |
| for (int i = 0; i < objBytes.length; ++i) { |
| if (objBytes[i] != other.objBytes[i]) |
| return false; |
| } |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * This class is used to marshal objects for |
| * <code>MarshalledObject</code>. It places the location annotations |
| * to one side so that two <code>MarshalledObject</code>s can be |
| * compared for equality if they differ only in location |
| * annotations. Objects written using this stream should be read back |
| * from a <code>MarshalledObjectInputStream</code>. |
| * |
| * @see java.rmi.MarshalledObject |
| * @see MarshalledObjectInputStream |
| */ |
| private static class MarshalledObjectOutputStream |
| extends MarshalOutputStream |
| { |
| /** The stream on which location objects are written. */ |
| private ObjectOutputStream locOut; |
| |
| /** <code>true</code> if non-<code>null</code> annotations are |
| * written. |
| */ |
| private boolean hadAnnotations; |
| |
| /** |
| * Creates a new <code>MarshalledObjectOutputStream</code> whose |
| * non-location bytes will be written to <code>objOut</code> and whose |
| * location annotations (if any) will be written to |
| * <code>locOut</code>. |
| */ |
| MarshalledObjectOutputStream(OutputStream objOut, OutputStream locOut) |
| throws IOException |
| { |
| super(objOut); |
| this.useProtocolVersion(ObjectStreamConstants.PROTOCOL_VERSION_2); |
| this.locOut = new ObjectOutputStream(locOut); |
| hadAnnotations = false; |
| } |
| |
| /** |
| * Returns <code>true</code> if any non-<code>null</code> location |
| * annotations have been written to this stream. |
| */ |
| boolean hadAnnotations() { |
| return hadAnnotations; |
| } |
| |
| /** |
| * Overrides MarshalOutputStream.writeLocation implementation to write |
| * annotations to the location stream. |
| */ |
| protected void writeLocation(String loc) throws IOException { |
| hadAnnotations |= (loc != null); |
| locOut.writeObject(loc); |
| } |
| |
| |
| public void flush() throws IOException { |
| super.flush(); |
| locOut.flush(); |
| } |
| } |
| |
| /** |
| * The counterpart to <code>MarshalledObjectOutputStream</code>. |
| * |
| * @see MarshalledObjectOutputStream |
| */ |
| private static class MarshalledObjectInputStream |
| extends MarshalInputStream |
| { |
| /** |
| * The stream from which annotations will be read. If this is |
| * <code>null</code>, then all annotations were <code>null</code>. |
| */ |
| private ObjectInputStream locIn; |
| |
| /** |
| * Creates a new <code>MarshalledObjectInputStream</code> that |
| * reads its objects from <code>objIn</code> and annotations |
| * from <code>locIn</code>. If <code>locIn</code> is |
| * <code>null</code>, then all annotations will be |
| * <code>null</code>. |
| */ |
| MarshalledObjectInputStream(InputStream objIn, InputStream locIn, |
| ObjectInputFilter filter) |
| throws IOException |
| { |
| super(objIn); |
| this.locIn = (locIn == null ? null : new ObjectInputStream(locIn)); |
| if (filter != null) { |
| AccessController.doPrivileged((PrivilegedAction<Void>) () -> { |
| MarshalledObjectInputStream.this.setObjectInputFilter(filter); |
| if (MarshalledObjectInputStream.this.locIn != null) { |
| MarshalledObjectInputStream.this.locIn.setObjectInputFilter(filter); |
| } |
| return null; |
| }); |
| } |
| } |
| |
| /** |
| * Overrides MarshalInputStream.readLocation to return locations from |
| * the stream we were given, or <code>null</code> if we were given a |
| * <code>null</code> location stream. |
| */ |
| protected Object readLocation() |
| throws IOException, ClassNotFoundException |
| { |
| return (locIn == null ? null : locIn.readObject()); |
| } |
| } |
| |
| } |