/*
 * 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());
 }
 }

}