/*
* Copyright (c) 1997, 2012, 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.
*/
/*
* Licensed Materials - Property of IBM
* RMI-IIOP v1.0
* Copyright IBM Corp. 1998 1999 All Rights Reserved
*
*/
package com.sun.corba.se.impl.encoding;
import java.io.IOException;
import java.io.Serializable;
import java.io.ByteArrayInputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
import java.io.StreamCorruptedException;
import java.io.OptionalDataException;
import java.io.IOException;
import java.util.Stack;
import java.net.URL;
import java.net.MalformedURLException;
import java.nio.ByteBuffer;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.rmi.Remote;
import java.rmi.StubNotFoundException;
import java.security.AccessController;
import java.security.PrivilegedExceptionAction;
import java.security.PrivilegedActionException;
import org.omg.CORBA.SystemException;
import org.omg.CORBA.Object;
import org.omg.CORBA.Principal;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.Any;
import org.omg.CORBA.portable.Delegate;
import org.omg.CORBA.portable.ValueBase;
import org.omg.CORBA.portable.IndirectionException;
import org.omg.CORBA.CompletionStatus;
import org.omg.CORBA.TCKind;
import org.omg.CORBA.TypeCodePackage.BadKind;
import org.omg.CORBA.CustomMarshal;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.Principal;
import org.omg.CORBA.Any;
import org.omg.CORBA.portable.BoxedValueHelper;
import org.omg.CORBA.portable.ValueFactory;
import org.omg.CORBA.portable.CustomValue;
import org.omg.CORBA.portable.StreamableValue;
import org.omg.CORBA.MARSHAL;
import org.omg.CORBA.portable.IDLEntity;
import javax.rmi.PortableRemoteObject;
import javax.rmi.CORBA.Tie;
import javax.rmi.CORBA.Util;
import javax.rmi.CORBA.ValueHandler;
import com.sun.corba.se.pept.protocol.MessageMediator;
import com.sun.corba.se.pept.transport.ByteBufferPool;
import com.sun.corba.se.spi.protocol.RequestDispatcherRegistry;
import com.sun.corba.se.spi.protocol.CorbaClientDelegate;
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.orb.ORB;
import com.sun.corba.se.spi.orb.ORBVersionFactory;
import com.sun.corba.se.spi.orb.ORBVersion;
import com.sun.corba.se.spi.protocol.CorbaMessageMediator;
import com.sun.corba.se.spi.logging.CORBALogDomains;
import com.sun.corba.se.spi.presentation.rmi.PresentationManager;
import com.sun.corba.se.spi.presentation.rmi.StubAdapter;
import com.sun.corba.se.spi.presentation.rmi.PresentationDefaults;
import com.sun.corba.se.impl.logging.ORBUtilSystemException;
import com.sun.corba.se.impl.logging.OMGSystemException;
import com.sun.corba.se.impl.corba.PrincipalImpl;
import com.sun.corba.se.impl.corba.TypeCodeImpl;
import com.sun.corba.se.impl.corba.CORBAObjectImpl;
import com.sun.corba.se.impl.encoding.CDROutputObject;
import com.sun.corba.se.impl.encoding.CodeSetConversion;
import com.sun.corba.se.impl.util.Utility;
import com.sun.corba.se.impl.util.RepositoryId;
import com.sun.corba.se.impl.orbutil.RepositoryIdStrings;
import com.sun.corba.se.impl.orbutil.RepositoryIdInterface;
import com.sun.corba.se.impl.orbutil.RepositoryIdUtility;
import com.sun.corba.se.impl.orbutil.RepositoryIdFactory;
import com.sun.corba.se.impl.orbutil.ORBUtility;
import com.sun.corba.se.impl.orbutil.CacheTable;
import com.sun.org.omg.CORBA.portable.ValueHelper;
import com.sun.org.omg.SendingContext.CodeBase;
public class CDRInputStream_1_0 extends CDRInputStreamBase
implements RestorableInputStream
{
private static final String kReadMethod = "read";
private static final int maxBlockLength = 0x7fffff00;
protected BufferManagerRead bufferManagerRead;
protected ByteBufferWithInfo bbwi;
// Set to the ORB's transportDebugFlag value. This value is
// used if the ORB is null.
private boolean debug = false;
protected boolean littleEndian;
protected ORB orb;
protected ORBUtilSystemException wrapper ;
protected OMGSystemException omgWrapper ;
protected ValueHandler valueHandler = null;
// Value cache
private CacheTable valueCache = null;
// Repository ID cache
private CacheTable repositoryIdCache = null;
// codebase cache
private CacheTable codebaseCache = null;
// Current Class Stack (repository Ids of current class being read)
// private Stack currentStack = null;
// Length of current chunk, or a large positive number if not in a chunk
protected int blockLength = maxBlockLength;
// Read end flag (value nesting depth)
protected int end_flag = 0;
// Beginning with the resolution to interop issue 3526 (4328?),
// only enclosing chunked valuetypes are taken into account
// when computing the nesting level. However, we still need
// the old computation around for interoperability with our
// older ORBs.
private int chunkedValueNestingLevel = 0;
// Flag used to determine whether blocksize was zero
// private int checkForNullBlock = -1;
// In block flag
// private boolean inBlock = false;
// Indicates whether we are inside a value
// private boolean outerValueDone = true;
// Int used by read_value(Serializable) that is set by this class
// before calling ValueFactory.read_value
protected int valueIndirection = 0;
// Int set by readStringOrIndirection to communicate the actual
// offset of the string length field back to the caller
protected int stringIndirection = 0;
// Flag indicating whether we are unmarshalling a chunked value
protected boolean isChunked = false;
// Repository ID handlers
private RepositoryIdUtility repIdUtil;
private RepositoryIdStrings repIdStrs;
// Code set converters (created when first needed)
private CodeSetConversion.BTCConverter charConverter;
private CodeSetConversion.BTCConverter wcharConverter;
// RMI-IIOP stream format version 2 case in which we know
// that there is no more optional data available. If the
// Serializable's readObject method tries to read anything,
// we must throw a MARSHAL with the special minor code
// so that the ValueHandler can give the correct exception
// to readObject. The state is cleared when the ValueHandler
// calls end_value after the readObject method exits.
private boolean specialNoOptionalDataState = false;
// Template method
public CDRInputStreamBase dup()
{
CDRInputStreamBase result = null ;
try {
result = (CDRInputStreamBase)this.getClass().newInstance();
} catch (Exception e) {
throw wrapper.couldNotDuplicateCdrInputStream( e ) ;
}
result.init(this.orb,
this.bbwi.byteBuffer,
this.bbwi.buflen,
this.littleEndian,
this.bufferManagerRead);
((CDRInputStream_1_0)result).bbwi.position(this.bbwi.position());
// To ensure we keep bbwi.byteBuffer.limit in sync with bbwi.buflen.
((CDRInputStream_1_0)result).bbwi.byteBuffer.limit(this.bbwi.buflen);
return result;
}
/**
* NOTE: size passed to init means buffer size
*/
public void init(org.omg.CORBA.ORB orb,
ByteBuffer byteBuffer,
int size,
boolean littleEndian,
BufferManagerRead bufferManager)
{
this.orb = (ORB)orb;
this.wrapper = ORBUtilSystemException.get( (ORB)orb,
CORBALogDomains.RPC_ENCODING ) ;
this.omgWrapper = OMGSystemException.get( (ORB)orb,
CORBALogDomains.RPC_ENCODING ) ;
this.littleEndian = littleEndian;
this.bufferManagerRead = bufferManager;
this.bbwi = new ByteBufferWithInfo(orb,byteBuffer,0);
this.bbwi.buflen = size;
this.bbwi.byteBuffer.limit(bbwi.buflen);
this.markAndResetHandler = bufferManagerRead.getMarkAndResetHandler();
debug = ((ORB)orb).transportDebugFlag;
}
// See description in CDRInputStream
void performORBVersionSpecificInit() {
createRepositoryIdHandlers();
}
private final void createRepositoryIdHandlers()
{
repIdUtil = RepositoryIdFactory.getRepIdUtility();
repIdStrs = RepositoryIdFactory.getRepIdStringsFactory();
}
public GIOPVersion getGIOPVersion() {
return GIOPVersion.V1_0;
}
// Called by Request and Reply message. Valid for GIOP versions >= 1.2 only.
// Illegal for GIOP versions < 1.2.
void setHeaderPadding(boolean headerPadding) {
throw wrapper.giopVersionError();
}
protected final int computeAlignment(int index, int align) {
if (align > 1) {
int incr = index & (align - 1);
if (incr != 0)
return align - incr;
}
return 0;
}
public int getSize()
{
return bbwi.position();
}
protected void checkBlockLength(int align, int dataSize) {
// Since chunks can end at arbitrary points (though not within
// primitive CDR types, arrays of primitives, strings, wstrings,
// or indirections),
// we must check here for termination of the current chunk.
if (!isChunked)
return;
// RMI-IIOP stream format version 2 case in which we know
// that there is no more optional data available. If the
// Serializable's readObject method tries to read anything,
// we must throw a MARSHAL exception with the special minor code
// so that the ValueHandler can give the correct exception
// to readObject. The state is cleared when the ValueHandler
// calls end_value after the readObject method exits.
if (specialNoOptionalDataState) {
throw omgWrapper.rmiiiopOptionalDataIncompatible1() ;
}
boolean checkForEndTag = false;
// Are we at the end of the current chunk? If so,
// try to interpret the next long as a chunk length.
// (It has to be either a chunk length, end tag,
// or valuetag.)
//
// If it isn't a chunk length, blockLength will
// remain set to maxBlockLength.
if (blockLength == get_offset()) {
blockLength = maxBlockLength;
start_block();
// What's next is either a valuetag or
// an end tag. If it's a valuetag, we're
// probably being called as part of the process
// to read the valuetag. If it's an end tag,
// then there isn't enough data left in
// this valuetype to read!
if (blockLength == maxBlockLength)
checkForEndTag = true;
} else
if (blockLength < get_offset()) {
// Are we already past the end of the current chunk?
// This is always an error.
throw wrapper.chunkOverflow() ;
}
// If what's next on the wire isn't a chunk length or
// what we want to read (which can't be split across chunks)
// won't fit in the current chunk, throw this exception.
// This probably means that we're in an RMI-IIOP
// Serializable's readObject method or a custom marshaled
// IDL type is reading too much/in an incorrect order
int requiredNumBytes =
computeAlignment(bbwi.position(), align) + dataSize;
if (blockLength != maxBlockLength &&
blockLength < get_offset() + requiredNumBytes) {
throw omgWrapper.rmiiiopOptionalDataIncompatible2() ;
}
// REVISIT - We should look at using the built in advancement
// of using ByteBuffer.get() rather than explicitly
// advancing the ByteBuffer's position.
// This is true for anywhere we are incrementing
// the ByteBuffer's position.
if (checkForEndTag) {
int nextLong = read_long();
bbwi.position(bbwi.position() - 4);
// It was an end tag, so there wasn't enough data
// left in the valuetype's encoding on the wire
// to read what we wanted
if (nextLong < 0)
throw omgWrapper.rmiiiopOptionalDataIncompatible3() ;
}
}
protected void alignAndCheck(int align, int n) {
checkBlockLength(align, n);
// WARNING: Must compute real alignment after calling
// checkBlockLength since it may move the position
int alignResult = computeAlignment(bbwi.position(), align);
bbwi.position(bbwi.position() + alignResult);
if (bbwi.position() + n > bbwi.buflen)
grow(align, n);
}
//
// This can be overridden....
//
protected void grow(int align, int n) {
bbwi.needed = n;
bbwi = bufferManagerRead.underflow(bbwi);
}
//
// Marshal primitives.
//
public final void consumeEndian() {
littleEndian = read_boolean();
}
// No such type in java
public final double read_longdouble() {
throw wrapper.longDoubleNotImplemented( CompletionStatus.COMPLETED_MAYBE);
}
public final boolean read_boolean() {
return (read_octet() != 0);
}
public final char read_char() {
alignAndCheck(1, 1);
return getConvertedChars(1, getCharConverter())[0];
}
public char read_wchar() {
// Don't allow transmission of wchar/wstring data with
// foreign ORBs since it's against the spec.
if (ORBUtility.isForeignORB((ORB)orb)) {
throw wrapper.wcharDataInGiop10( CompletionStatus.COMPLETED_MAYBE);
}
// If we're talking to one of our legacy ORBs, do what
// they did:
int b1, b2;
alignAndCheck(2, 2);
if (littleEndian) {
b2 = bbwi.byteBuffer.get(bbwi.position()) & 0x00FF;
bbwi.position(bbwi.position() + 1);
b1 = bbwi.byteBuffer.get(bbwi.position()) & 0x00FF;
bbwi.position(bbwi.position() + 1);
} else {
b1 = bbwi.byteBuffer.get(bbwi.position()) & 0x00FF;
bbwi.position(bbwi.position() + 1);
b2 = bbwi.byteBuffer.get(bbwi.position()) & 0x00FF;
bbwi.position(bbwi.position() + 1);
}
return (char)((b1 << 8) + (b2 << 0));
}
public final byte read_octet() {
alignAndCheck(1, 1);
byte b = bbwi.byteBuffer.get(bbwi.position());
bbwi.position(bbwi.position() + 1);
return b;
}
public final short read_short() {
int b1, b2;
alignAndCheck(2, 2);
if (littleEndian) {
b2 = (bbwi.byteBuffer.get(bbwi.position()) << 0) & 0x000000FF;
bbwi.position(bbwi.position() + 1);
b1 = (bbwi.byteBuffer.get(bbwi.position()) << 8) & 0x0000FF00;
bbwi.position(bbwi.position() + 1);
} else {
b1 = (bbwi.byteBuffer.get(bbwi.position()) << 8) & 0x0000FF00;
bbwi.position(bbwi.position() + 1);
b2 = (bbwi.byteBuffer.get(bbwi.position()) << 0) & 0x000000FF;
bbwi.position(bbwi.position() + 1);
}
return (short)(b1 | b2);
}
public final short read_ushort() {
return read_short();
}
public final int read_long() {
int b1, b2, b3, b4;
alignAndCheck(4, 4);
int bufPos = bbwi.position();
if (littleEndian) {
b4 = bbwi.byteBuffer.get(bufPos++) & 0xFF;
b3 = bbwi.byteBuffer.get(bufPos++) & 0xFF;
b2 = bbwi.byteBuffer.get(bufPos++) & 0xFF;
b1 = bbwi.byteBuffer.get(bufPos++) & 0xFF;
} else {
b1 = bbwi.byteBuffer.get(bufPos++) & 0xFF;
b2 = bbwi.byteBuffer.get(bufPos++) & 0xFF;
b3 = bbwi.byteBuffer.get(bufPos++) & 0xFF;
b4 = bbwi.byteBuffer.get(bufPos++) & 0xFF;
}
bbwi.position(bufPos);
return (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
}
public final int read_ulong() {
return read_long();
}
public final long read_longlong() {
long i1, i2;
alignAndCheck(8, 8);
if (littleEndian) {
i2 = read_long() & 0xFFFFFFFFL;
i1 = (long)read_long() << 32;
} else {
i1 = (long)read_long() << 32;
i2 = read_long() & 0xFFFFFFFFL;
}
return (i1 | i2);
}
public final long read_ulonglong() {
return read_longlong();
}
public final float read_float() {
return Float.intBitsToFloat(read_long());
}
public final double read_double() {
return Double.longBitsToDouble(read_longlong());
}
protected final void checkForNegativeLength(int length) {
if (length < 0)
throw wrapper.negativeStringLength( CompletionStatus.COMPLETED_MAYBE,
new Integer(length) ) ;
}
protected final String readStringOrIndirection(boolean allowIndirection) {
int len = read_long();
//
// Check for indirection
//
if (allowIndirection) {
if (len == 0xffffffff)
return null;
else
stringIndirection = get_offset() - 4;
}
checkForNegativeLength(len);
return internalReadString(len);
}
private final String internalReadString(int len) {
// Workaround for ORBs which send string lengths of
// zero to mean empty string.
//
// IMPORTANT: Do not replace 'new String("")' with "", it may result
// in a Serialization bug (See serialization.zerolengthstring) and
// bug id: 4728756 for details
if (len == 0)
return new String("");
char[] result = getConvertedChars(len - 1, getCharConverter());
// Skip over the 1 byte null
read_octet();
return new String(result, 0, getCharConverter().getNumChars());
}
public final String read_string() {
return readStringOrIndirection(false);
}
public String read_wstring() {
// Don't allow transmission of wchar/wstring data with
// foreign ORBs since it's against the spec.
if (ORBUtility.isForeignORB((ORB)orb)) {
throw wrapper.wcharDataInGiop10( CompletionStatus.COMPLETED_MAYBE);
}
int len = read_long();
//
// Workaround for ORBs which send string lengths of
// zero to mean empty string.
//
//
// IMPORTANT: Do not replace 'new String("")' with "", it may result
// in a Serialization bug (See serialization.zerolengthstring) and
// bug id: 4728756 for details
if (len == 0)
return new String("");
checkForNegativeLength(len);
len--;
char[] c = new char[len];
for (int i = 0; i < len; i++)
c[i] = read_wchar();
// skip the two null terminator bytes
read_wchar();
// bbwi.position(bbwi.position() + 2);
return new String(c);
}
public final void read_octet_array(byte[] b, int offset, int length) {
if ( b == null )
throw wrapper.nullParam() ;
// Must call alignAndCheck at least once to ensure
// we aren't at the end of a chunk. Of course, we
// should only call it if we actually need to read
// something, otherwise we might end up with an
// exception at the end of the stream.
if (length == 0)
return;
alignAndCheck(1, 1);
int n = offset;
while (n < length+offset) {
int avail;
int bytes;
int wanted;
avail = bbwi.buflen - bbwi.position();
if (avail <= 0) {
grow(1, 1);
avail = bbwi.buflen - bbwi.position();
}
wanted = (length + offset) - n;
bytes = (wanted < avail) ? wanted : avail;
// Microbenchmarks are showing a loop of ByteBuffer.get(int) being
// faster than ByteBuffer.get(byte[], int, int).
for (int i = 0; i < bytes; i++) {
b[n+i] = bbwi.byteBuffer.get(bbwi.position() + i);
}
bbwi.position(bbwi.position() + bytes);
n += bytes;
}
}
public Principal read_Principal() {
int len = read_long();
byte[] pvalue = new byte[len];
read_octet_array(pvalue,0,len);
Principal p = new PrincipalImpl();
p.name(pvalue);
return p;
}
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 (MARSHAL ex) {
if (tc.kind().value() != TCKind._tk_value)
throw ex;
// We can be sure that the whole typecode encapsulation has been
// read off.
dprintThrowable(ex);
}
// read off the value of the any
any.read_value(parent, tc);
return any;
}
public org.omg.CORBA.Object read_Object() {
return read_Object(null);
}
// ------------ RMI related methods --------------------------
// IDL to Java ptc-00-01-08 1.21.4.1
//
// The clz argument to read_Object can be either a stub
// Class or the "Class object for the RMI/IDL interface type
// that is statically expected."
// This functions as follows:
// 1. If clz==null, just use the repository ID from the stub
// 2. If clz is a stub class, just use it as a static factory.
// clz is a stub class iff StubAdapter.isStubClass( clz ).
// In addition, clz is a IDL stub class iff
// IDLEntity.class.isAssignableFrom( clz ).
// 3. If clz is an interface, use it to create the appropriate
// stub factory.
public org.omg.CORBA.Object read_Object(Class clz)
{
// In any case, we must first read the IOR.
IOR ior = IORFactories.makeIOR(parent) ;
if (ior.isNil())
return null ;
PresentationManager.StubFactoryFactory sff = ORB.getStubFactoryFactory() ;
String codeBase = ior.getProfile().getCodebase() ;
PresentationManager.StubFactory stubFactory = null ;
if (clz == null) {
RepositoryId rid = RepositoryId.cache.getId( ior.getTypeId() ) ;
String className = rid.getClassName() ;
boolean isIDLInterface = rid.isIDLType() ;
if (className == null || className.equals( "" ))
stubFactory = null ;
else
try {
stubFactory = sff.createStubFactory( className,
isIDLInterface, codeBase, (Class)null,
(ClassLoader)null );
} catch (Exception exc) {
// Could not create stubFactory, so use null.
// XXX stubFactory handling is still too complex:
// Can we resolve the stubFactory question once in
// a single place?
stubFactory = null ;
}
} else if (StubAdapter.isStubClass( clz )) {
stubFactory = PresentationDefaults.makeStaticStubFactory(
clz ) ;
} else {
// clz is an interface class
boolean isIDL = IDLEntity.class.isAssignableFrom( clz ) ;
stubFactory = sff.createStubFactory( clz.getName(),
isIDL, codeBase, clz, clz.getClassLoader() ) ;
}
return internalIORToObject( ior, stubFactory, orb ) ;
}
/*
* This is used as a general utility (e.g., the PortableInterceptor
* implementation uses it. If stubFactory is null, the ior's
* IIOPProfile must support getServant.
*/
public static org.omg.CORBA.Object internalIORToObject(
IOR ior, PresentationManager.StubFactory stubFactory, ORB orb)
{
ORBUtilSystemException wrapper = ORBUtilSystemException.get(
(ORB)orb, CORBALogDomains.RPC_ENCODING ) ;
java.lang.Object servant = ior.getProfile().getServant() ;
if (servant != null ) {
if (servant instanceof Tie) {
String codebase = ior.getProfile().getCodebase();
org.omg.CORBA.Object objref = (org.omg.CORBA.Object)
Utility.loadStub( (Tie)servant, stubFactory, codebase,
false);
// If we managed to load a stub, return it, otherwise we
// must fail...
if (objref != null) {
return objref;
} else {
throw wrapper.readObjectException() ;
}
} else if (servant instanceof org.omg.CORBA.Object) {
if (!(servant instanceof
org.omg.CORBA.portable.InvokeHandler)) {
return (org.omg.CORBA.Object) servant;
}
} else
throw wrapper.badServantReadObject() ;
}
CorbaClientDelegate del = ORBUtility.makeClientDelegate( ior ) ;
org.omg.CORBA.Object objref = null ;
try {
objref = stubFactory.makeStub() ;
} catch (Throwable e) {
wrapper.stubCreateError( e ) ;
if (e instanceof ThreadDeath) {
throw (ThreadDeath) e;
}
// Return the "default" stub...
objref = new CORBAObjectImpl() ;
}
StubAdapter.setDelegate( objref, del ) ;
return objref;
}
public java.lang.Object read_abstract_interface()
{
return read_abstract_interface(null);
}
public java.lang.Object read_abstract_interface(java.lang.Class clz)
{
boolean object = read_boolean();
if (object) {
return read_Object(clz);
} else {
return read_value();
}
}
public Serializable read_value()
{
return read_value((Class)null);
}
private Serializable handleIndirection() {
int indirection = read_long() + get_offset() - 4;
if (valueCache != null && valueCache.containsVal(indirection)) {
java.io.Serializable cachedValue
= (java.io.Serializable)valueCache.getKey(indirection);
return cachedValue;
} else {
// In RMI-IIOP the ValueHandler will recognize this
// exception and use the provided indirection value
// to lookup a possible indirection to an object
// currently on the deserialization stack.
throw new IndirectionException(indirection);
}
}
private String readRepositoryIds(int valueTag,
Class expectedType,
String expectedTypeRepId) {
return readRepositoryIds(valueTag, expectedType,
expectedTypeRepId, null);
}
/**
* Examines the valuetag to see how many (if any) repository IDs
* are present on the wire. If no repository ID information
* is on the wire but the expectedType or expectedTypeRepId
* is known, it will return one of those (favoring the
* expectedType's repId). Failing that, it uses the supplied
* BoxedValueHelper to obtain the repository ID, as a last resort.
*/
private String readRepositoryIds(int valueTag,
Class expectedType,
String expectedTypeRepId,
BoxedValueHelper factory) {
switch(repIdUtil.getTypeInfo(valueTag)) {
case RepositoryIdUtility.NO_TYPE_INFO :
// Throw an exception if we have no repository ID info and
// no expectedType to work with. Otherwise, how would we
// know what to unmarshal?
if (expectedType == null) {
if (expectedTypeRepId != null) {
return expectedTypeRepId;
} else if (factory != null) {
return factory.get_id();
} else {
throw wrapper.expectedTypeNullAndNoRepId(
CompletionStatus.COMPLETED_MAYBE);
}
}
return repIdStrs.createForAnyType(expectedType);
case RepositoryIdUtility.SINGLE_REP_TYPE_INFO :
return read_repositoryId();
case RepositoryIdUtility.PARTIAL_LIST_TYPE_INFO :
return read_repositoryIds();
default:
throw wrapper.badValueTag( CompletionStatus.COMPLETED_MAYBE,
Integer.toHexString(valueTag) ) ;
}
}
public Serializable read_value(Class expectedType) {
// Read value tag
int vType = readValueTag();
// Is value null?
if (vType == 0)
return null;
// Is this an indirection to a previously
// read valuetype?
if (vType == 0xffffffff)
return handleIndirection();
// Save where this valuetype started so we
// can put it in the indirection valueCache
// later
int indirection = get_offset() - 4;
// Need to save this special marker variable
// to restore its value during recursion
boolean saveIsChunked = isChunked;
isChunked = repIdUtil.isChunkedEncoding(vType);
java.lang.Object value = null;
String codebase_URL = null;
if (repIdUtil.isCodeBasePresent(vType)) {
codebase_URL = read_codebase_URL();
}
// Read repository id(s)
String repositoryIDString
= readRepositoryIds(vType, expectedType, null);
// If isChunked was determined to be true based
// on the valuetag, this will read a chunk length
start_block();
// Remember that end_flag keeps track of all nested
// valuetypes and is used for older ORBs
end_flag--;
if (isChunked)
chunkedValueNestingLevel--;
if (repositoryIDString.equals(repIdStrs.getWStringValueRepId())) {
value = read_wstring();
} else
if (repositoryIDString.equals(repIdStrs.getClassDescValueRepId())) {
// read in the class whether with the old ClassDesc or the
// new one
value = readClass();
} else {
Class valueClass = expectedType;
// By this point, either the expectedType or repositoryIDString
// is guaranteed to be non-null.
if (expectedType == null ||
!repositoryIDString.equals(repIdStrs.createForAnyType(expectedType))) {
valueClass = getClassFromString(repositoryIDString,
codebase_URL,
expectedType);
}
if (valueClass == null) {
// No point attempting to use value handler below, since the
// class information is not available.
throw wrapper.couldNotFindClass(
CompletionStatus.COMPLETED_MAYBE,
new ClassNotFoundException());
}
if (valueClass != null &&
org.omg.CORBA.portable.IDLEntity.class.isAssignableFrom(valueClass)) {
value = readIDLValue(indirection,
repositoryIDString,
valueClass,
codebase_URL);
} else {
// Must be some form of RMI-IIOP valuetype
try {
if (valueHandler == null)
valueHandler = ORBUtility.createValueHandler();
value = valueHandler.readValue(parent,
indirection,
valueClass,
repositoryIDString,
getCodeBase());
} catch(SystemException sysEx) {
// Just rethrow any CORBA system exceptions
// that come out of the ValueHandler
throw sysEx;
} catch(Exception ex) {
throw wrapper.valuehandlerReadException(
CompletionStatus.COMPLETED_MAYBE, ex ) ;
} catch(Error e) {
throw wrapper.valuehandlerReadError(
CompletionStatus.COMPLETED_MAYBE, e ) ;
}
}
}
// Skip any remaining chunks until we get to
// an end tag or a valuetag. If we see a valuetag,
// that means there was another valuetype in the sender's
// version of this class that we need to skip over.
handleEndOfValue();
// Read and process the end tag if we're chunking.
// Assumes that we're at the position of the end tag
// (handleEndOfValue should assure this)
readEndTag();
// Cache the valuetype that we read
if (valueCache == null)
valueCache = new CacheTable(orb,false);
valueCache.put(value, indirection);
// Allow for possible continuation chunk.
// If we're a nested valuetype inside of a chunked
// valuetype, and that enclosing valuetype has
// more data to write, it will need to have this
// new chunk begin after we wrote our end tag.
isChunked = saveIsChunked;
start_block();
return (java.io.Serializable)value;
}
public Serializable read_value(BoxedValueHelper factory) {
// Read value tag
int vType = readValueTag();
if (vType == 0)
return null; // value is null
else if (vType == 0xffffffff) { // Indirection tag
int indirection = read_long() + get_offset() - 4;
if (valueCache != null && valueCache.containsVal(indirection))
{
java.io.Serializable cachedValue =
(java.io.Serializable)valueCache.getKey(indirection);
return cachedValue;
}
else {
throw new IndirectionException(indirection);
}
}
else {
int indirection = get_offset() - 4;
// end_block();
boolean saveIsChunked = isChunked;
isChunked = repIdUtil.isChunkedEncoding(vType);
java.lang.Object value = null;
String codebase_URL = null;
if (repIdUtil.isCodeBasePresent(vType)){
codebase_URL = read_codebase_URL();
}
// Read repository id
String repositoryIDString
= readRepositoryIds(vType, null, null, factory);
// Compare rep. ids to see if we should use passed helper
if (!repositoryIDString.equals(factory.get_id()))
factory = Utility.getHelper(null, codebase_URL, repositoryIDString);
start_block();
end_flag--;
if (isChunked)
chunkedValueNestingLevel--;
if (factory instanceof ValueHelper) {
value = readIDLValueWithHelper((ValueHelper)factory, indirection);
} else {
valueIndirection = indirection; // for callback
value = factory.read_value(parent);
}
handleEndOfValue();
readEndTag();
// Put into valueCache
if (valueCache == null)
valueCache = new CacheTable(orb,false);
valueCache.put(value, indirection);
// allow for possible continuation chunk
isChunked = saveIsChunked;
start_block();
return (java.io.Serializable)value;
}
}
private boolean isCustomType(ValueHelper helper) {
try{
TypeCode tc = helper.get_type();
int kind = tc.kind().value();
if (kind == TCKind._tk_value) {
return (tc.type_modifier() == org.omg.CORBA.VM_CUSTOM.value);
}
} catch(BadKind ex) {
throw wrapper.badKind(ex) ;
}
return false;
}
// This method is actually called indirectly by
// read_value(String repositoryId).
// Therefore, it is not a truly independent read call that handles
// header information itself.
public java.io.Serializable read_value(java.io.Serializable value) {
// Put into valueCache using valueIndirection
if (valueCache == null)
valueCache = new CacheTable(orb,false);
valueCache.put(value, valueIndirection);
if (value instanceof StreamableValue)
((StreamableValue)value)._read(parent);
else if (value instanceof CustomValue)
((CustomValue)value).unmarshal(parent);
return value;
}
public java.io.Serializable read_value(java.lang.String repositoryId) {
// if (inBlock)
// end_block();
// Read value tag
int vType = readValueTag();
if (vType == 0)
return null; // value is null
else if (vType == 0xffffffff) { // Indirection tag
int indirection = read_long() + get_offset() - 4;
if (valueCache != null && valueCache.containsVal(indirection))
{
java.io.Serializable cachedValue =
(java.io.Serializable)valueCache.getKey(indirection);
return cachedValue;
}
else {
throw new IndirectionException(indirection);
}
}
else {
int indirection = get_offset() - 4;
// end_block();
boolean saveIsChunked = isChunked;
isChunked = repIdUtil.isChunkedEncoding(vType);
java.lang.Object value = null;
String codebase_URL = null;
if (repIdUtil.isCodeBasePresent(vType)){
codebase_URL = read_codebase_URL();
}
// Read repository id
String repositoryIDString
= readRepositoryIds(vType, null, repositoryId);
ValueFactory factory =
Utility.getFactory(null, codebase_URL, orb, repositoryIDString);
start_block();
end_flag--;
if (isChunked)
chunkedValueNestingLevel--;
valueIndirection = indirection; // for callback
value = factory.read_value(parent);
handleEndOfValue();
readEndTag();
// Put into valueCache
if (valueCache == null)
valueCache = new CacheTable(orb,false);
valueCache.put(value, indirection);
// allow for possible continuation chunk
isChunked = saveIsChunked;
start_block();
return (java.io.Serializable)value;
}
}
private Class readClass() {
String codebases = null, classRepId = null;
if (orb == null ||
ORBVersionFactory.getFOREIGN().equals(orb.getORBVersion()) ||
ORBVersionFactory.getNEWER().compareTo(orb.getORBVersion()) <= 0) {
codebases = (String)read_value(java.lang.String.class);
classRepId = (String)read_value(java.lang.String.class);
} else {
// Pre-Merlin/J2EE 1.3 ORBs wrote the repository ID
// and codebase strings in the wrong order.
classRepId = (String)read_value(java.lang.String.class);
codebases = (String)read_value(java.lang.String.class);
}
if (debug) {
dprint("readClass codebases: "
+ codebases
+ " rep Id: "
+ classRepId);
}
Class cl = null;
RepositoryIdInterface repositoryID
= repIdStrs.getFromString(classRepId);
try {
cl = repositoryID.getClassFromType(codebases);
} catch(ClassNotFoundException cnfe) {
throw wrapper.cnfeReadClass( CompletionStatus.COMPLETED_MAYBE,
cnfe, repositoryID.getClassName() ) ;
} catch(MalformedURLException me) {
throw wrapper.malformedUrl( CompletionStatus.COMPLETED_MAYBE,
me, repositoryID.getClassName(), codebases ) ;
}
return cl;
}
private java.lang.Object readIDLValueWithHelper(ValueHelper helper, int indirection)
{
// look for two-argument static read method
Method readMethod;
try {
Class argTypes[] = {org.omg.CORBA.portable.InputStream.class, helper.get_class()};
readMethod = helper.getClass().getDeclaredMethod(kReadMethod, argTypes);
}
catch(NoSuchMethodException nsme) { // must be boxed value helper
java.lang.Object result = helper.read_value(parent);
return result;
}
// found two-argument read method, so must be non-boxed value...
// ...create a blank instance
java.lang.Object val = null;
try {
val = helper.get_class().newInstance();
} catch(java.lang.InstantiationException ie) {
throw wrapper.couldNotInstantiateHelper( ie,
helper.get_class() ) ;
} catch(IllegalAccessException iae){
// Value's constructor is protected or private
//
// So, use the helper to read the value.
//
// NOTE : This means that in this particular case a recursive ref.
// would fail.
return helper.read_value(parent);
}
// add blank instance to cache table
if (valueCache == null)
valueCache = new CacheTable(orb,false);
valueCache.put(val, indirection);
// if custom type, call unmarshal method
if (val instanceof CustomMarshal && isCustomType(helper)) {
((CustomMarshal)val).unmarshal(parent);
return val;
}
// call two-argument read method using reflection
try {
java.lang.Object args[] = {parent, val};
readMethod.invoke(helper, args);
return val;
} catch(IllegalAccessException iae2) {
throw wrapper.couldNotInvokeHelperReadMethod( iae2, helper.get_class() ) ;
} catch(InvocationTargetException ite){
throw wrapper.couldNotInvokeHelperReadMethod( ite, helper.get_class() ) ;
}
}
private java.lang.Object readBoxedIDLEntity(Class clazz, String codebase)
{
Class cls = null ;
try {
ClassLoader clazzLoader = (clazz == null ? null : clazz.getClassLoader());
cls = Utility.loadClassForClass(clazz.getName()+"Helper", codebase,
clazzLoader, clazz, clazzLoader);
final Class helperClass = cls ;
final Class argTypes[] = {org.omg.CORBA.portable.InputStream.class};
// getDeclaredMethod requires RuntimePermission accessDeclaredMembers
// if a different class loader is used (even though the javadoc says otherwise)
Method readMethod = null;
try {
readMethod = (Method)AccessController.doPrivileged(
new PrivilegedExceptionAction() {
public java.lang.Object run() throws NoSuchMethodException {
return helperClass.getDeclaredMethod(kReadMethod, argTypes);
}
}
);
} catch (PrivilegedActionException pae) {
// this gets caught below
throw (NoSuchMethodException)pae.getException();
}
java.lang.Object args[] = {parent};
return readMethod.invoke(null, args);
} catch (ClassNotFoundException cnfe) {
throw wrapper.couldNotInvokeHelperReadMethod( cnfe, cls ) ;
} catch(NoSuchMethodException nsme) {
throw wrapper.couldNotInvokeHelperReadMethod( nsme, cls ) ;
} catch(IllegalAccessException iae) {
throw wrapper.couldNotInvokeHelperReadMethod( iae, cls ) ;
} catch(InvocationTargetException ite) {
throw wrapper.couldNotInvokeHelperReadMethod( ite, cls ) ;
}
}
private java.lang.Object readIDLValue(int indirection, String repId,
Class clazz, String codebase)
{
ValueFactory factory ;
// Always try to find a ValueFactory first, as required by the spec.
// There are some complications here in the IDL 3.0 mapping (see 1.13.8),
// but basically we must always be able to override the DefaultFactory
// or Helper mappings that are also used. This appears to be the case
// even in the boxed value cases. The original code only did the lookup
// in the case of class implementing either StreamableValue or CustomValue,
// but abstract valuetypes only implement ValueBase, and really require
// the use of the repId to find a factory (including the DefaultFactory).
try {
// use new-style OBV support (factory object)
factory = Utility.getFactory(clazz, codebase, orb, repId);
} catch (MARSHAL marshal) {
// XXX log marshal at one of the INFO levels
// Could not get a factory, so try alternatives
if (!StreamableValue.class.isAssignableFrom(clazz) &&
!CustomValue.class.isAssignableFrom(clazz) &&
ValueBase.class.isAssignableFrom(clazz)) {
// use old-style OBV support (helper object)
BoxedValueHelper helper = Utility.getHelper(clazz, codebase, repId);
if (helper instanceof ValueHelper)
return readIDLValueWithHelper((ValueHelper)helper, indirection);
else
return helper.read_value(parent);
} else {
// must be a boxed IDLEntity, so make a reflective call to the
// helper's static read method...
return readBoxedIDLEntity(clazz, codebase);
}
}
// If there was no error in getting the factory, use it.
valueIndirection = indirection; // for callback
return factory.read_value(parent);
}
/**
* End tags are only written for chunked valuetypes.
*
* Before Merlin, our ORBs wrote end tags which took into account
* all enclosing valuetypes. This was changed by an interop resolution
* (see details around chunkedValueNestingLevel) to only include
* enclosing chunked types.
*
* ORB versioning and end tag compaction are handled here.
*/
private void readEndTag() {
if (isChunked) {
// Read the end tag
int anEndTag = read_long();
// End tags should always be negative, and the outermost
// enclosing chunked valuetype should have a -1 end tag.
//
// handleEndOfValue should have assured that we were
// at the end tag position!
if (anEndTag >= 0) {
throw wrapper.positiveEndTag( CompletionStatus.COMPLETED_MAYBE,
new Integer(anEndTag), new Integer( get_offset() - 4 ) ) ;
}
// If the ORB is null, or if we're sure we're talking to
// a foreign ORB, Merlin, or something more recent, we
// use the updated end tag computation, and are more strenuous
// about the values.
if (orb == null ||
ORBVersionFactory.getFOREIGN().equals(orb.getORBVersion()) ||
ORBVersionFactory.getNEWER().compareTo(orb.getORBVersion()) <= 0) {
// If the end tag we read was less than what we were expecting,
// then the sender must think it's sent more enclosing
// chunked valuetypes than we have. Throw an exception.
if (anEndTag < chunkedValueNestingLevel)
throw wrapper.unexpectedEnclosingValuetype(
CompletionStatus.COMPLETED_MAYBE, new Integer( anEndTag ),
new Integer( chunkedValueNestingLevel ) ) ;
// If the end tag is bigger than what we expected, but
// still negative, then the sender has done some end tag
// compaction. We back up the stream 4 bytes so that the
// next time readEndTag is called, it will get down here
// again. Even with fragmentation, we'll always be able
// to do this.
if (anEndTag != chunkedValueNestingLevel) {
bbwi.position(bbwi.position() - 4);
}
} else {
// When talking to Kestrel or Ladybird, we use our old
// end tag rules and are less strict. If the end tag
// isn't what we expected, we back up, assuming
// compaction.
if (anEndTag != end_flag) {
bbwi.position(bbwi.position() - 4);
}
}
// This only keeps track of the enclosing chunked
// valuetypes
chunkedValueNestingLevel++;
}
// This keeps track of all enclosing valuetypes
end_flag++;
}
protected int get_offset() {
return bbwi.position();
}
private void start_block() {
// if (outerValueDone)
if (!isChunked)
return;
// if called from alignAndCheck, need to reset blockLength
// to avoid an infinite recursion loop on read_long() call
blockLength = maxBlockLength;
blockLength = read_long();
// Must remember where we began the chunk to calculate how far
// along we are. See notes above about chunkBeginPos.
if (blockLength > 0 && blockLength < maxBlockLength) {
blockLength += get_offset(); // _REVISIT_ unsafe, should use a Java long
// inBlock = true;
} else {
// System.out.println("start_block snooped a " + Integer.toHexString(blockLength));
// not a chunk length field
blockLength = maxBlockLength;
bbwi.position(bbwi.position() - 4);
}
}
// Makes sure that if we were reading a chunked value, we end up
// at the right place in the stream, no matter how little the
// unmarshalling code read.
//
// After calling this method, if we are chunking, we should be
// in position to read the end tag.
private void handleEndOfValue() {
// If we're not chunking, we don't have to worry about
// skipping remaining chunks or finding end tags
if (!isChunked)
return;
// Skip any remaining chunks
while (blockLength != maxBlockLength) {
end_block();
start_block();
}
// Now look for the end tag
// This is a little wasteful since we're reading
// this long up to 3 times in the worst cases (once
// in start_block, once here, and once in readEndTag
//
// Peek next long
int nextLong = read_long();
bbwi.position(bbwi.position() - 4);
// We did find an end tag, so we're done. readEndTag
// should take care of making sure it's the correct
// end tag, etc. Remember that since end tags,
// chunk lengths, and valuetags have non overlapping
// ranges, we can tell by the value what the longs are.
if (nextLong < 0)
return;
if (nextLong == 0 || nextLong >= maxBlockLength) {
// A custom marshaled valuetype left extra data
// on the wire, and that data had another
// nested value inside of it. We've just
// read the value tag or null of that nested value.
//
// In an attempt to get by it, we'll try to call
// read_value() to get the nested value off of
// the wire. Afterwards, we must call handleEndOfValue
// recursively to read any further chunks that the containing
// valuetype might still have after the nested
// value.
read_value();
handleEndOfValue();
} else {
// This probably means that the code to skip chunks has
// an error, and ended up setting blockLength to something
// other than maxBlockLength even though we weren't
// starting a new chunk.
throw wrapper.couldNotSkipBytes( CompletionStatus.COMPLETED_MAYBE,
new Integer( nextLong ), new Integer( get_offset() ) ) ;
}
}
private void end_block() {
// if in a chunk, check for underflow or overflow
if (blockLength != maxBlockLength) {
if (blockLength == get_offset()) {
// Chunk ended correctly
blockLength = maxBlockLength;
} else {
// Skip over anything left by bad unmarshaling code (ex:
// a buggy custom unmarshaler). See handleEndOfValue.
if (blockLength > get_offset()) {
skipToOffset(blockLength);
} else {
throw wrapper.badChunkLength( new Integer( blockLength ),
new Integer( get_offset() ) ) ;
}
}
}
}
private int readValueTag(){
// outerValueDone = false;
return read_long();
}
public org.omg.CORBA.ORB orb() {
return orb;
}
// ------------ End RMI related methods --------------------------
public final void read_boolean_array(boolean[] value, int offset, int length) {
for(int i=0; i < length; i++) {
value[i+offset] = read_boolean();
}
}
public final void read_char_array(char[] value, int offset, int length) {
for(int i=0; i < length; i++) {
value[i+offset] = read_char();
}
}
public final void read_wchar_array(char[] value, int offset, int length) {
for(int i=0; i < length; i++) {
value[i+offset] = read_wchar();
}
}
public final void read_short_array(short[] value, int offset, int length) {
for(int i=0; i < length; i++) {
value[i+offset] = read_short();
}
}
public final void read_ushort_array(short[] value, int offset, int length) {
read_short_array(value, offset, length);
}
public final void read_long_array(int[] value, int offset, int length) {
for(int i=0; i < length; i++) {
value[i+offset] = read_long();
}
}
public final void read_ulong_array(int[] value, int offset, int length) {
read_long_array(value, offset, length);
}
public final void read_longlong_array(long[] value, int offset, int length) {
for(int i=0; i < length; i++) {
value[i+offset] = read_longlong();
}
}
public final void read_ulonglong_array(long[] value, int offset, int length) {
read_longlong_array(value, offset, length);
}
public final void read_float_array(float[] value, int offset, int length) {
for(int i=0; i < length; i++) {
value[i+offset] = read_float();
}
}
public final void read_double_array(double[] value, int offset, int length) {
for(int i=0; i < length; i++) {
value[i+offset] = read_double();
}
}
public final void read_any_array(org.omg.CORBA.Any[] value, int offset, int length) {
for(int i=0; i < length; i++) {
value[i+offset] = read_any();
}
}
//--------------------------------------------------------------------//
// CDRInputStream state management.
//
/**
* Are we at the end of the input stream?
*/
// public final boolean isAtEnd() {
// return bbwi.position() == bbwi.buflen;
// }
// public int available() throws IOException {
// return bbwi.buflen - bbwi.position();
// }
private String read_repositoryIds() {
// Read # of repository ids
int numRepIds = read_long();
if (numRepIds == 0xffffffff) {
int indirection = read_long() + get_offset() - 4;
if (repositoryIdCache != null && repositoryIdCache.containsOrderedVal(indirection))
return (String)repositoryIdCache.getKey(indirection);
else
throw wrapper.unableToLocateRepIdArray( new Integer( indirection ) ) ;
} else {
// read first array element and store it as an indirection to the whole array
int indirection = get_offset();
String repID = read_repositoryId();
if (repositoryIdCache == null)
repositoryIdCache = new CacheTable(orb,false);
repositoryIdCache.put(repID, indirection);
// read and ignore the subsequent array elements, but put them in the
// indirection table in case there are later indirections back to them
for (int i = 1; i < numRepIds; i++) {
read_repositoryId();
}
return repID;
}
}
private final String read_repositoryId()
{
String result = readStringOrIndirection(true);
if (result == null) { // Indirection
int indirection = read_long() + get_offset() - 4;
if (repositoryIdCache != null && repositoryIdCache.containsOrderedVal(indirection))
return (String)repositoryIdCache.getKey(indirection);
else
throw wrapper.badRepIdIndirection( CompletionStatus.COMPLETED_MAYBE,
new Integer(bbwi.position()) ) ;
} else {
if (repositoryIdCache == null)
repositoryIdCache = new CacheTable(orb,false);
repositoryIdCache.put(result, stringIndirection);
}
return result ;
}
private final String read_codebase_URL()
{
String result = readStringOrIndirection(true);
if (result == null) { // Indirection
int indirection = read_long() + get_offset() - 4;
if (codebaseCache != null && codebaseCache.containsVal(indirection))
return (String)codebaseCache.getKey(indirection);
else
throw wrapper.badCodebaseIndirection(
CompletionStatus.COMPLETED_MAYBE,
new Integer(bbwi.position()) ) ;
} else {
if (codebaseCache == null)
codebaseCache = new CacheTable(orb,false);
codebaseCache.put(result, stringIndirection);
}
return result;
}
/* DataInputStream methods */
public java.lang.Object read_Abstract () {
return read_abstract_interface();
}
public java.io.Serializable read_Value () {
return read_value();
}
public void read_any_array (org.omg.CORBA.AnySeqHolder seq, int offset, int length) {
read_any_array(seq.value, offset, length);
}
public void read_boolean_array (org.omg.CORBA.BooleanSeqHolder seq, int offset, int length) {
read_boolean_array(seq.value, offset, length);
}
public void read_char_array (org.omg.CORBA.CharSeqHolder seq, int offset, int length) {
read_char_array(seq.value, offset, length);
}
public void read_wchar_array (org.omg.CORBA.WCharSeqHolder seq, int offset, int length) {
read_wchar_array(seq.value, offset, length);
}
public void read_octet_array (org.omg.CORBA.OctetSeqHolder seq, int offset, int length) {
read_octet_array(seq.value, offset, length);
}
public void read_short_array (org.omg.CORBA.ShortSeqHolder seq, int offset, int length) {
read_short_array(seq.value, offset, length);
}
public void read_ushort_array (org.omg.CORBA.UShortSeqHolder seq, int offset, int length) {
read_ushort_array(seq.value, offset, length);
}
public void read_long_array (org.omg.CORBA.LongSeqHolder seq, int offset, int length) {
read_long_array(seq.value, offset, length);
}
public void read_ulong_array (org.omg.CORBA.ULongSeqHolder seq, int offset, int length) {
read_ulong_array(seq.value, offset, length);
}
public void read_ulonglong_array (org.omg.CORBA.ULongLongSeqHolder seq, int offset, int length) {
read_ulonglong_array(seq.value, offset, length);
}
public void read_longlong_array (org.omg.CORBA.LongLongSeqHolder seq, int offset, int length) {
read_longlong_array(seq.value, offset, length);
}
public void read_float_array (org.omg.CORBA.FloatSeqHolder seq, int offset, int length) {
read_float_array(seq.value, offset, length);
}
public void read_double_array (org.omg.CORBA.DoubleSeqHolder seq, int offset, int length) {
read_double_array(seq.value, offset, length);
}
public java.math.BigDecimal read_fixed(short digits, short scale) {
// digits isn't really needed here
StringBuffer buffer = read_fixed_buffer();
if (digits != buffer.length())
throw wrapper.badFixed( new Integer(digits),
new Integer(buffer.length()) ) ;
buffer.insert(digits - scale, '.');
return new BigDecimal(buffer.toString());
}
// This method is unable to yield the correct scale.
public java.math.BigDecimal read_fixed() {
return new BigDecimal(read_fixed_buffer().toString());
}
// Each octet contains (up to) two decimal digits.
// If the fixed type has an odd number of decimal digits, then the representation
// begins with the first (most significant) digit.
// Otherwise, this first half-octet is all zero, and the first digit
// is in the second half-octet.
// The sign configuration, in the last half-octet of the representation,
// is 0xD for negative numbers and 0xC for positive and zero values.
private StringBuffer read_fixed_buffer() {
StringBuffer buffer = new StringBuffer(64);
byte doubleDigit;
int firstDigit;
int secondDigit;
boolean wroteFirstDigit = false;
boolean more = true;
while (more) {
doubleDigit = this.read_octet();
firstDigit = (int)((doubleDigit & 0xf0) >> 4);
secondDigit = (int)(doubleDigit & 0x0f);
if (wroteFirstDigit || firstDigit != 0) {
buffer.append(Character.forDigit(firstDigit, 10));
wroteFirstDigit = true;
}
if (secondDigit == 12) {
// positive number or zero
if ( ! wroteFirstDigit) {
// zero
return new StringBuffer("0.0");
} else {
// positive number
// done
}
more = false;
} else if (secondDigit == 13) {
// negative number
buffer.insert(0, '-');
more = false;
} else {
buffer.append(Character.forDigit(secondDigit, 10));
wroteFirstDigit = true;
}
}
return buffer;
}
private final static String _id = "IDL:omg.org/CORBA/DataInputStream:1.0";
private final static String[] _ids = { _id };
public String[] _truncatable_ids() {
if (_ids == null)
return null;
return (String[])_ids.clone();
}
/* for debugging */
public void printBuffer() {
CDRInputStream_1_0.printBuffer(this.bbwi);
}
public static void printBuffer(ByteBufferWithInfo bbwi) {
System.out.println("----- Input Buffer -----");
System.out.println();
System.out.println("Current position: " + bbwi.position());
System.out.println("Total length : " + bbwi.buflen);
System.out.println();
try {
char[] charBuf = new char[16];
for (int i = 0; i < bbwi.buflen; i += 16) {
int j = 0;
// For every 16 bytes, there is one line
// of output. First, the hex output of
// the 16 bytes with each byte separated
// by a space.
while (j < 16 && j + i < bbwi.buflen) {
int k = bbwi.byteBuffer.get(i + j);
if (k < 0)
k = 256 + k;
String hex = Integer.toHexString(k);
if (hex.length() == 1)
hex = "0" + hex;
System.out.print(hex + " ");
j++;
}
// Add any extra spaces to align the
// text column in case we didn't end
// at 16
while (j < 16) {
System.out.print(" ");
j++;
}
// Now output the ASCII equivalents. Non-ASCII
// characters are shown as periods.
int x = 0;
while (x < 16 && x + i < bbwi.buflen) {
if (ORBUtility.isPrintable((char)bbwi.byteBuffer.get(i + x)))
charBuf[x] = (char)bbwi.byteBuffer.get(i + x);
else
charBuf[x] = '.';
x++;
}
System.out.println(new String(charBuf, 0, x));
}
} catch (Throwable t) {
t.printStackTrace();
}
System.out.println("------------------------");
}
public ByteBuffer getByteBuffer() {
ByteBuffer result = null;
if (bbwi != null) {
result = bbwi.byteBuffer;
}
return result;
}
public int getBufferLength() {
return bbwi.buflen;
}
public void setBufferLength(int value) {
bbwi.buflen = value;
bbwi.byteBuffer.limit(bbwi.buflen);
}
public void setByteBufferWithInfo(ByteBufferWithInfo bbwi) {
this.bbwi = bbwi;
}
public void setByteBuffer(ByteBuffer byteBuffer) {
bbwi.byteBuffer = byteBuffer;
}
public int getIndex() {
return bbwi.position();
}
public void setIndex(int value) {
bbwi.position(value);
}
public boolean isLittleEndian() {
return littleEndian;
}
public void orb(org.omg.CORBA.ORB orb) {
this.orb = (ORB)orb;
}
public BufferManagerRead getBufferManager() {
return bufferManagerRead;
}
private void skipToOffset(int offset) {
// Number of bytes to skip
int len = offset - get_offset();
int n = 0;
while (n < len) {
int avail;
int bytes;
int wanted;
avail = bbwi.buflen - bbwi.position();
if (avail <= 0) {
grow(1, 1);
avail = bbwi.buflen - bbwi.position();
}
wanted = len - n;
bytes = (wanted < avail) ? wanted : avail;
bbwi.position(bbwi.position() + bytes);
n += bytes;
}
}
// Mark and reset -------------------------------------------------
protected MarkAndResetHandler markAndResetHandler = null;
protected class StreamMemento
{
// These are the fields that may change after marking
// the stream position, so we need to save them.
private int blockLength_;
private int end_flag_;
private int chunkedValueNestingLevel_;
private int valueIndirection_;
private int stringIndirection_;
private boolean isChunked_;
private javax.rmi.CORBA.ValueHandler valueHandler_;
private ByteBufferWithInfo bbwi_;
private boolean specialNoOptionalDataState_;
public StreamMemento()
{
blockLength_ = blockLength;
end_flag_ = end_flag;
chunkedValueNestingLevel_ = chunkedValueNestingLevel;
valueIndirection_ = valueIndirection;
stringIndirection_ = stringIndirection;
isChunked_ = isChunked;
valueHandler_ = valueHandler;
specialNoOptionalDataState_ = specialNoOptionalDataState;
bbwi_ = new ByteBufferWithInfo(bbwi);
}
}
public java.lang.Object createStreamMemento() {
return new StreamMemento();
}
public void restoreInternalState(java.lang.Object streamMemento) {
StreamMemento mem = (StreamMemento)streamMemento;
blockLength = mem.blockLength_;
end_flag = mem.end_flag_;
chunkedValueNestingLevel = mem.chunkedValueNestingLevel_;
valueIndirection = mem.valueIndirection_;
stringIndirection = mem.stringIndirection_;
isChunked = mem.isChunked_;
valueHandler = mem.valueHandler_;
specialNoOptionalDataState = mem.specialNoOptionalDataState_;
bbwi = mem.bbwi_;
}
public int getPosition() {
return get_offset();
}
public void mark(int readlimit) {
markAndResetHandler.mark(this);
}
public void reset() {
markAndResetHandler.reset();
}
// ---------------------------------- end Mark and Reset
// Provides a hook so subclasses of CDRInputStream can provide
// a CodeBase. This ultimately allows us to grab a Connection
// instance in IIOPInputStream, the only subclass where this
// is actually used.
CodeBase getCodeBase() {
return parent.getCodeBase();
}
/**
* Attempts to find the class described by the given
* repository ID string and expected type. The first
* attempt is to find the class locally, falling back
* on the URL that came with the value. The second
* attempt is to use a URL from the remote CodeBase.
*/
private Class getClassFromString(String repositoryIDString,
String codebaseURL,
Class expectedType)
{
RepositoryIdInterface repositoryID
= repIdStrs.getFromString(repositoryIDString);
try {
try {
// First try to load the class locally, then use
// the provided URL (if it isn't null)
return repositoryID.getClassFromType(expectedType,
codebaseURL);
} catch (ClassNotFoundException cnfeOuter) {
try {
if (getCodeBase() == null) {
return null; // class cannot be loaded remotely.
}
// Get a URL from the remote CodeBase and retry
codebaseURL = getCodeBase().implementation(repositoryIDString);
// Don't bother trying to find it locally again if
// we got a null URL
if (codebaseURL == null)
return null;
return repositoryID.getClassFromType(expectedType,
codebaseURL);
} catch (ClassNotFoundException cnfeInner) {
dprintThrowable(cnfeInner);
// Failed to load the class
return null;
}
}
} catch (MalformedURLException mue) {
// Always report a bad URL
throw wrapper.malformedUrl( CompletionStatus.COMPLETED_MAYBE,
mue, repositoryIDString, codebaseURL ) ;
}
}
/**
* Attempts to find the class described by the given
* repository ID string. At most, three attempts are made:
* Try to find it locally, through the provided URL, and
* finally, via a URL from the remote CodeBase.
*/
private Class getClassFromString(String repositoryIDString,
String codebaseURL)
{
RepositoryIdInterface repositoryID
= repIdStrs.getFromString(repositoryIDString);
for (int i = 0; i < 3; i++) {
try {
switch (i)
{
case 0:
// First try to load the class locally
return repositoryID.getClassFromType();
case 1:
// Try to load the class using the provided
// codebase URL (falls out below)
break;
case 2:
// Try to load the class using a URL from the
// remote CodeBase
codebaseURL = getCodeBase().implementation(repositoryIDString);
break;
}
// Don't bother if the codebaseURL is null
if (codebaseURL == null)
continue;
return repositoryID.getClassFromType(codebaseURL);
} catch(ClassNotFoundException cnfe) {
// Will ultimately return null if all three
// attempts fail, but don't do anything here.
} catch (MalformedURLException mue) {
throw wrapper.malformedUrl( CompletionStatus.COMPLETED_MAYBE,
mue, repositoryIDString, codebaseURL ) ;
}
}
// If we get here, we have failed to load the class
dprint("getClassFromString failed with rep id "
+ repositoryIDString
+ " and codebase "
+ codebaseURL);
return null;
}
// Utility method used to get chars from bytes
char[] getConvertedChars(int numBytes,
CodeSetConversion.BTCConverter converter) {
// REVISIT - Look at CodeSetConversion.BTCConverter to see
// if it can work with an NIO ByteBuffer. We should
// avoid getting the bytes into an array if possible.
// To be honest, I doubt this saves much real time
if (bbwi.buflen - bbwi.position() >= numBytes) {
// If the entire string is in this buffer,
// just convert directly from the bbwi rather than
// allocating and copying.
byte[] tmpBuf;
if (bbwi.byteBuffer.hasArray())
{
tmpBuf = bbwi.byteBuffer.array();
}
else
{
tmpBuf = new byte[bbwi.buflen];
// Microbenchmarks are showing a loop of ByteBuffer.get(int)
// being faster than ByteBuffer.get(byte[], int, int).
for (int i = 0; i < bbwi.buflen; i++)
tmpBuf[i] = bbwi.byteBuffer.get(i);
}
char[] result = converter.getChars(tmpBuf,bbwi.position(),numBytes);
bbwi.position(bbwi.position() + numBytes);
return result;
} else {
// Stretches across buffers. Unless we provide an
// incremental conversion interface, allocate and
// copy the bytes.
byte[] bytes = new byte[numBytes];
read_octet_array(bytes, 0, bytes.length);
return converter.getChars(bytes, 0, numBytes);
}
}
protected CodeSetConversion.BTCConverter getCharConverter() {
if (charConverter == null)
charConverter = parent.createCharBTCConverter();
return charConverter;
}
protected CodeSetConversion.BTCConverter getWCharConverter() {
if (wcharConverter == null)
wcharConverter = parent.createWCharBTCConverter();
return wcharConverter;
}
protected void dprintThrowable(Throwable t) {
if (debug && t != null)
t.printStackTrace();
}
protected void dprint(String msg) {
if (debug) {
ORBUtility.dprint(this, msg);
}
}
/**
* Aligns the current position on the given octet boundary
* if there are enough bytes available to do so. Otherwise,
* it just returns. This is used for some (but not all)
* GIOP 1.2 message headers.
*/
void alignOnBoundary(int octetBoundary) {
int needed = computeAlignment(bbwi.position(), octetBoundary);
if (bbwi.position() + needed <= bbwi.buflen)
{
bbwi.position(bbwi.position() + needed);
}
}
public void resetCodeSetConverters() {
charConverter = null;
wcharConverter = null;
}
public void start_value() {
// Read value tag
int vType = readValueTag();
if (vType == 0) {
// Stream needs to go into a state where it
// throws standard exception until end_value
// is called. This means the sender didn't
// send any custom data. If the reader here
// tries to read more, we need to throw an
// exception before reading beyond where
// we're supposed to
specialNoOptionalDataState = true;
return;
}
if (vType == 0xffffffff) {
// One should never indirect to a custom wrapper
throw wrapper.customWrapperIndirection(
CompletionStatus.COMPLETED_MAYBE);
}
if (repIdUtil.isCodeBasePresent(vType)) {
throw wrapper.customWrapperWithCodebase(
CompletionStatus.COMPLETED_MAYBE);
}
if (repIdUtil.getTypeInfo(vType)
!= RepositoryIdUtility.SINGLE_REP_TYPE_INFO) {
throw wrapper.customWrapperNotSingleRepid(
CompletionStatus.COMPLETED_MAYBE);
}
// REVISIT - Could verify repository ID even though
// it isn't used elsewhere
read_repositoryId();
// Note: isChunked should be true here. Should have
// been set to true in the containing value's read_value
// method.
start_block();
end_flag--;
chunkedValueNestingLevel--;
}
public void end_value() {
if (specialNoOptionalDataState) {
specialNoOptionalDataState = false;
return;
}
handleEndOfValue();
readEndTag();
// Note that isChunked should still be true here.
// If the containing valuetype is the highest
// chunked value, it will get set to false
// at the end of read_value.
// allow for possible continuation chunk
start_block();
}
public void close() throws IOException
{
// tell BufferManagerRead to release any ByteBuffers
getBufferManager().close(bbwi);
// It's possible bbwi.byteBuffer is shared between
// this InputStream and an OutputStream. Thus, we check
// if the Input/Output streams are using the same ByteBuffer.
// If they sharing the same ByteBuffer we need to ensure only
// one of those ByteBuffers are released to the ByteBufferPool.
if (bbwi != null && getByteBuffer() != null)
{
MessageMediator messageMediator = parent.getMessageMediator();
if (messageMediator != null)
{
CDROutputObject outputObj =
(CDROutputObject)messageMediator.getOutputObject();
if (outputObj != null)
{
if (outputObj.isSharing(getByteBuffer()))
{
// Set OutputStream's ByteBuffer and bbwi to null
// so its ByteBuffer cannot be released to the pool
outputObj.setByteBuffer(null);
outputObj.setByteBufferWithInfo(null);
}
}
}
// release this stream's ByteBuffer to the pool
ByteBufferPool byteBufferPool = orb.getByteBufferPool();
if (debug)
{
// print address of ByteBuffer being released
int bbAddress = System.identityHashCode(bbwi.byteBuffer);
StringBuffer sb = new StringBuffer(80);
sb.append(".close - releasing ByteBuffer id (");
sb.append(bbAddress).append(") to ByteBufferPool.");
String msg = sb.toString();
dprint(msg);
}
byteBufferPool.releaseByteBuffer(bbwi.byteBuffer);
bbwi.byteBuffer = null;
bbwi = null;
}
}
}