jdk8-mips64-public/corba: comparison src/share/classes/com/sun/corba/se/impl/encoding/CDRInputStream_1

--1:000000000000
+:7ef37b2cdcad
+/*
+* 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;
+}
+}
+}

comparison: src/share/classes/com/sun/corba/se/impl/encoding/CDRInputStream_1_0.java

src/share/classes/com/sun/corba/se/impl/encoding/CDRInputStream_1_0.java

Mercurial > jdk8-mips64-public > corba / file comparison

comparison: src/share/classes/com/sun/corba/se/impl/encoding/CDRInputStream_1_0.java

src/share/classes/com/sun/corba/se/impl/encoding/CDRInputStream_1_0.java