idljavaserializationinputstream.java

来自「JAVA 所有包」· Java 代码 · 共 1,066 行 · 第 1/2 页

/*
 * @(#)IDLJavaSerializationInputStream.java	1.5 05/11/17
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package com.sun.corba.se.impl.encoding;

import java.io.Serializable;
import java.io.ObjectInputStream;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.math.BigDecimal;
import java.util.LinkedList;

import com.sun.corba.se.spi.orb.ORB;
import com.sun.corba.se.spi.ior.IOR;
import com.sun.corba.se.spi.ior.IORFactories;
import com.sun.corba.se.spi.ior.iiop.GIOPVersion;
import com.sun.corba.se.spi.logging.CORBALogDomains;
import com.sun.corba.se.spi.presentation.rmi.StubAdapter;
import com.sun.corba.se.spi.presentation.rmi.PresentationManager;
import com.sun.corba.se.spi.presentation.rmi.PresentationDefaults;

import com.sun.corba.se.impl.util.Utility;
import com.sun.corba.se.impl.orbutil.ORBUtility;
import com.sun.corba.se.impl.corba.TypeCodeImpl;
import com.sun.corba.se.impl.util.RepositoryId;
import com.sun.corba.se.impl.orbutil.ORBConstants;
import com.sun.corba.se.impl.logging.ORBUtilSystemException;
import com.sun.corba.se.impl.protocol.giopmsgheaders.Message;

import org.omg.CORBA.Any;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.Principal;
import org.omg.CORBA.portable.IDLEntity;

/**
 * Implementation class that uses Java serialization for input streams.
 * This assumes a GIOP version 1.2 message format.
 *
 * This class uses a ByteArrayInputStream as the underlying buffer. The
 * first 16 bytes are directly read out of the underlying buffer. This allows
 * [GIOPHeader (12 bytes) + requestID (4 bytes)] to be read as bytes.
 * Subsequent write operations on this output stream object uses 
 * ObjectInputStream class to read into the buffer. This allows unmarshaling
 * complex types and graphs using the ObjectInputStream implementation.
 *
 * Note, this class assumes a GIOP 1.2 style header. Further, the first
 * 12 bytes, that is, the GIOPHeader is read directly from the received
 * message, before this stream object is called. So, this class effectively
 * reads only the requestID (4 bytes) directly, and uses the
 * ObjectInputStream for further unmarshaling.
 *
 * @author Ram Jeyaraman
 */
public class IDLJavaSerializationInputStream extends CDRInputStreamBase {

    private ORB orb;
    private int bufSize;
    private ByteBuffer buffer;
    private byte encodingVersion;
    private ObjectInputStream is;
    private _ByteArrayInputStream bis;
    private BufferManagerRead bufferManager;

    // [GIOPHeader(12) + requestID(4)] bytes
    private final int directReadLength = Message.GIOPMessageHeaderLength + 4;

    // Used for mark / reset operations.
    private boolean markOn;
    private int peekIndex, peekCount;
    private LinkedList markedItemQ = new LinkedList();

    protected ORBUtilSystemException wrapper;

    class _ByteArrayInputStream extends ByteArrayInputStream {

	_ByteArrayInputStream(byte[] buf) {
	    super(buf);
	}
	
	int getPosition() {
	    return this.pos;
	}

	void setPosition(int value) {
	    if (value < 0 || value > count) {
		throw new IndexOutOfBoundsException();
	    }
	    this.pos = value;
	}
    }

    class MarshalObjectInputStream extends ObjectInputStream {

	ORB orb;
	
	MarshalObjectInputStream(java.io.InputStream out, ORB orb)
	        throws IOException {

	    super(out);
	    this.orb = orb;

	    java.security.AccessController.doPrivileged(
	        new java.security.PrivilegedAction() {
		    public Object run() {
			// needs SerializablePermission("enableSubstitution")
			enableResolveObject(true);
			return null;
		    }
	        }
	    );
	}

	/**
	 * Connect the Stub to the ORB.
	 */
	protected final Object resolveObject(Object obj) throws IOException {
	    try {
		if (StubAdapter.isStub(obj)) {
		    StubAdapter.connect(obj, orb);
		}
	    } catch (java.rmi.RemoteException re) {
		IOException ie = new IOException("resolveObject failed");
		ie.initCause(re);
		throw ie;
	    }
	    return obj;
	}
    }

    public IDLJavaSerializationInputStream(byte encodingVersion) { 
	super();
	this.encodingVersion = encodingVersion;
    }

    public void init(org.omg.CORBA.ORB orb, 
                     ByteBuffer byteBuffer, 
                     int bufSize, 
                     boolean littleEndian,
                     BufferManagerRead bufferManager) {
	this.orb = (ORB) orb;
	this.bufSize = bufSize;
	this.bufferManager = bufferManager;
	buffer = byteBuffer;
	wrapper = 
	    ORBUtilSystemException.get((ORB)orb, CORBALogDomains.RPC_ENCODING);

	byte[] buf;
	if (buffer.hasArray()) {
	    buf = buffer.array();
	} else {
	    buf = new byte[bufSize];
	    buffer.get(buf);
	}
	// Note: at this point, the buffer position is zero. The setIndex()
	// method call can be used to set a desired read index.
	bis = new _ByteArrayInputStream(buf);
    }

    // Called from read_octet or read_long or read_ulong method.
    private void initObjectInputStream() {
	//System.out.print(" is ");
	if (is != null) {
	    throw wrapper.javaStreamInitFailed();
	}
	try {
	    is = new MarshalObjectInputStream(bis, orb);
	} catch (Exception e) {
	    throw wrapper.javaStreamInitFailed(e);
	}
    }

    // org.omg.CORBA.portable.InputStream

    // Primitive types.

    public boolean read_boolean() {
	if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
	    return ((Boolean)markedItemQ.removeFirst()).booleanValue();
	}
	if (markOn && !(markedItemQ.isEmpty()) &&
	        (peekIndex < peekCount)) { // peek
	    return ((Boolean)markedItemQ.get(peekIndex++)).booleanValue();
	}
	try {
	    boolean value = is.readBoolean();
	    if (markOn) { // enqueue
		markedItemQ.addLast(Boolean.valueOf(value));
	    }
	    return value;
	} catch (Exception e) {
	    throw wrapper.javaSerializationException(e, "read_boolean");
	}
    }

    public char read_char() {
	if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
	    return ((Character)markedItemQ.removeFirst()).charValue();
	}
	if (markOn && !(markedItemQ.isEmpty()) &&
	        (peekIndex < peekCount)) { // peek
	    return ((Character)markedItemQ.get(peekIndex++)).charValue();
	}
	try {
	    char value = is.readChar();
	    if (markOn) { // enqueue
		markedItemQ.addLast(new Character(value));
	    }
	    return value;
	} catch (Exception e) {
	    throw wrapper.javaSerializationException(e, "read_char");
	}
    }

    public char read_wchar() {
	return this.read_char();
    }

    public byte read_octet() {

	// check if size < [ GIOPHeader(12) + requestID(4)] bytes
	if (bis.getPosition() < directReadLength) {
            byte b = (byte) bis.read();
	    if (bis.getPosition() == directReadLength) {
		initObjectInputStream();
	    }
	    return b;
	}

	if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
	    return ((Byte)markedItemQ.removeFirst()).byteValue();
	}

	if (markOn && !(markedItemQ.isEmpty()) &&
	        (peekIndex < peekCount)) { // peek
	    return ((Byte)markedItemQ.get(peekIndex++)).byteValue();
	}

	try {
	    byte value = is.readByte();
	    if (markOn) { // enqueue
		//markedItemQ.addLast(Byte.valueOf(value)); // only in JDK 1.5
		markedItemQ.addLast(new Byte(value));
	    }
	    return value;
	} catch (Exception e) {
	    throw wrapper.javaSerializationException(e, "read_octet");
	}
    }

    public short read_short() {
	if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
	    return ((Short)markedItemQ.removeFirst()).shortValue();
	}
	if (markOn && !(markedItemQ.isEmpty()) &&
	        (peekIndex < peekCount)) { // peek
	    return ((Short)markedItemQ.get(peekIndex++)).shortValue();
	}

	try {
	    short value = is.readShort();
	    if (markOn) { // enqueue
		markedItemQ.addLast(new Short(value));
	    }
	    return value;
	} catch (Exception e) {
	    throw wrapper.javaSerializationException(e, "read_short");
	}
    }

    public short read_ushort() {
	return this.read_short();
    }

    public int read_long() {

	// check if size < [ GIOPHeader(12) + requestID(4)] bytes
	if (bis.getPosition() < directReadLength) {

	    // Use big endian (network byte order). This is fixed.
	    // Both the writer and reader use the same byte order.
            int b1 = (bis.read() << 24) & 0xFF000000;
            int b2 = (bis.read() << 16) & 0x00FF0000;
            int b3 = (bis.read() << 8)  & 0x0000FF00;
            int b4 = (bis.read() << 0)  & 0x000000FF;

	    if (bis.getPosition() == directReadLength) {
		initObjectInputStream();
	    } else if (bis.getPosition() > directReadLength) {
		// Cannot happen. All direct reads are contained
		// within the first 16 bytes.
		wrapper.javaSerializationException("read_long");
	    }

	    return (b1 | b2 | b3 | b4);
	}

	if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
	    return ((Integer)markedItemQ.removeFirst()).intValue();
	}

	if (markOn && !(markedItemQ.isEmpty()) &&
	        (peekIndex < peekCount)) { // peek
	    return ((Integer)markedItemQ.get(peekIndex++)).intValue();
	}

	try {
	    int value = is.readInt();
	    if (markOn) { // enqueue
		markedItemQ.addLast(new Integer(value));
	    }
	    return value;
	} catch (Exception e) {
	    throw wrapper.javaSerializationException(e, "read_long");
	}
    }

    public int read_ulong() {
	return this.read_long();
    }

    public long read_longlong() {
	if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
	    return ((Long)markedItemQ.removeFirst()).longValue();
	}
	if (markOn && !(markedItemQ.isEmpty()) &&
	        (peekIndex < peekCount)) { // peek
	    return ((Long)markedItemQ.get(peekIndex++)).longValue();
	}

	try {
	    long value = is.readLong();
	    if (markOn) { // enqueue
		markedItemQ.addLast(new Long(value));
	    }
	    return value;
	} catch (Exception e) {
	    throw wrapper.javaSerializationException(e, "read_longlong");
	}
    }

    public long read_ulonglong() {
	return read_longlong();
    }

    public float read_float() {
	if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
	    return ((Float)markedItemQ.removeFirst()).floatValue();
	}
	if (markOn && !(markedItemQ.isEmpty()) &&
	        (peekIndex < peekCount)) { // peek
	    return ((Float)markedItemQ.get(peekIndex++)).floatValue();
	}

	try {
	    float value = is.readFloat();
	    if (markOn) { // enqueue
		markedItemQ.addLast(new Float(value));
	    }
	    return value;
	} catch (Exception e) {
	    throw wrapper.javaSerializationException(e, "read_float");
	}
    }

    public double read_double() {
	if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
	    return ((Double)markedItemQ.removeFirst()).doubleValue();
	}
	if (markOn && !(markedItemQ.isEmpty()) &&
	        (peekIndex < peekCount)) { // peek
	    return ((Double)markedItemQ.get(peekIndex++)).doubleValue();
	}

	try {
	    double value = is.readDouble();
	    if (markOn) { // enqueue
		markedItemQ.addLast(new Double(value));
	    }
	    return value;
	} catch (Exception e) {
	    throw wrapper.javaSerializationException(e, "read_double");
	}
    }

    // String types.

    public String read_string() {
	if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
	    return (String) markedItemQ.removeFirst();
	}
	if (markOn && !(markedItemQ.isEmpty()) &&
	    (peekIndex < peekCount)) { // peek
	    return (String) markedItemQ.get(peekIndex++);
	}
	try {
	    String value = is.readUTF();
	    if (markOn) { // enqueue
		markedItemQ.addLast(value);
	    }
	    return value;
	} catch (Exception e) {
	    throw wrapper.javaSerializationException(e, "read_string");
	}
    }

    public String read_wstring() {
	if (!markOn && !(markedItemQ.isEmpty())) { // dequeue
	    return (String) markedItemQ.removeFirst();
	}
	if (markOn && !(markedItemQ.isEmpty()) &&
	        (peekIndex < peekCount)) { // peek
	    return (String) markedItemQ.get(peekIndex++);
	}
	try {
	    String value = (String) is.readObject();
	    if (markOn) { // enqueue
		markedItemQ.addLast(value);
	    }
	    return value;
	} catch (Exception e) {
	    throw wrapper.javaSerializationException(e, "read_wstring");
	}
    }

    // Array types.

    public void read_boolean_array(boolean[] value, int offset, int length){
	for(int i = 0; i < length; i++) {
    	    value[i+offset] = read_boolean();
    	}
    }

    public void read_char_array(char[] value, int offset, int length) {
    	for(int i=0; i < length; i++) {
    	    value[i+offset] = read_char();
    	}	
    }

    public void read_wchar_array(char[] value, int offset, int length) {
	read_char_array(value, offset, length);
    }

    public void read_octet_array(byte[] value, int offset, int length) {
    	for(int i=0; i < length; i++) {
    	    value[i+offset] = read_octet();
    	}	
	/* // Cannot use this efficient read due to mark/reset support.
	try {
	    while (length > 0) {
		int n = is.read(value, offset, length);
		offset += n;
		length -= n;
	    }
	} catch (Exception e) {
	    throw wrapper.javaSerializationException(e, "read_octet_array");
	}
	*/
    }

    public void read_short_array(short[] value, int offset, int length) {
    	for(int i=0; i < length; i++) {
    	    value[i+offset] = read_short();
    	}	
    }

    public void read_ushort_array(short[] value, int offset, int length) {
	read_short_array(value, offset, length);
    }

    public void read_long_array(int[] value, int offset, int length) {
    	for(int i=0; i < length; i++) {
    	    value[i+offset] = read_long();
    	}	
    }

    public void read_ulong_array(int[] value, int offset, int length) {
	read_long_array(value, offset, length);
    }

    public void read_longlong_array(long[] value, int offset, int length) {
    	for(int i=0; i < length; i++) {
    	    value[i+offset] = read_longlong();
    	}	
    }

    public void read_ulonglong_array(long[] value, int offset, int length) {
	read_longlong_array(value, offset, length);
    }

    public void read_float_array(float[] value, int offset, int length) {
    	for(int i=0; i < length; i++) {
    	    value[i+offset] = read_float();
    	}
    }

    public void read_double_array(double[] value, int offset, int length) {
    	for(int i=0; i < length; i++) {
    	    value[i+offset] = read_double();
    	}
    }

    // Complex types.

    public org.omg.CORBA.Object read_Object() {
	return read_Object(null);
    }

    public TypeCode read_TypeCode() {
        TypeCodeImpl tc = new TypeCodeImpl(orb);
        tc.read_value(parent);
	return tc;	
    }

    public Any read_any() {

        Any any = orb.create_any();
        TypeCodeImpl tc = new TypeCodeImpl(orb);

        // read off the typecode
	
        // REVISIT We could avoid this try-catch if we could peek the typecode
	// kind off this stream and see if it is a tk_value.
        // Looking at the code we know that for tk_value the Any.read_value()
	// below ignores the tc argument anyway (except for the kind field).
        // But still we would need to make sure that the whole typecode,
	// including encapsulations, is read off.
        try {
            tc.read_value(parent);
        } catch (org.omg.CORBA.MARSHAL ex) {