1. /*

  2.  * @(#)CDRInputStream.java	1.30 03/01/23

  3.  *

  4.  * Copyright 2003 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. package com.sun.corba.se.internal.iiop;

  8. 

  9. import java.io.IOException;

  10. import java.io.Serializable;

  11. import java.math.BigDecimal;

  12. 

  13. import org.omg.CORBA.TypeCode;

  14. import org.omg.CORBA.Principal;

  15. import org.omg.CORBA.Any;

  16. import com.sun.org.omg.SendingContext.CodeBase;

  17. import org.omg.CORBA.BAD_PARAM;

  18. import org.omg.CORBA.INTERNAL;

  19. import org.omg.CORBA.CompletionStatus;

  20. 

  21. import com.sun.corba.se.internal.core.GIOPVersion;

  22. import com.sun.corba.se.internal.core.CodeSetConversion;

  23. import com.sun.corba.se.internal.core.OSFCodeSetRegistry;

  24. import com.sun.corba.se.internal.orbutil.MinorCodes;

  25. 

  26. /**

  27.  * This is delegates to the real implementation.

  28.  *

  29.  * NOTE:

  30.  *

  31.  * Before using the stream for valuetype unmarshaling, one must call

  32.  * performORBVersionSpecificInit().

  33.  */

  34. public abstract class CDRInputStream

  35.     extends org.omg.CORBA_2_3.portable.InputStream

  36.     implements com.sun.corba.se.internal.core.MarshalInputStream,

  37.                org.omg.CORBA.DataInputStream

  38. {

  39.     private CDRInputStreamBase impl;

  40. 

  41.     // We can move this out somewhere later.  For now, it serves its purpose

  42.     // to create a concrete CDR delegate based on the GIOP version.

  43.     private static class InputStreamFactory {

  44.         

  45.         public static CDRInputStreamBase newInputStream(GIOPVersion version)

  46.         {

  47.             switch(version.intValue()) 

  48.             {

  49.                 case GIOPVersion.VERSION_1_0:

  50.                     return new CDRInputStream_1_0();

  51.                 case GIOPVersion.VERSION_1_1:

  52.                     return new CDRInputStream_1_1();

  53.                 case GIOPVersion.VERSION_1_2:

  54.                     return new CDRInputStream_1_2();

  55.                 default:

  56.                     // REVISIT - what is appropriate?  INTERNAL exceptions

  57.                     // are really hard to track later.

  58.                     throw new org.omg.CORBA.INTERNAL();

  59.             }

  60.         }

  61.     }

  62. 

  63.     // Required for the case when a ClientResponseImpl is

  64.     // created with a SystemException due to a dead server/closed

  65.     // connection with no warning.  Note that the stream will

  66.     // not be initialized in this case.

  67.     // 

  68.     // Probably also required by ServerRequestImpl.

  69.     // 

  70.     // REVISIT.

  71.     public CDRInputStream() {

  72.     }

  73. 

  74.     public CDRInputStream(CDRInputStream is) {

  75.         impl = is.impl.dup();

  76.         impl.setParent(this);

  77.     }

  78. 

  79.     public CDRInputStream(CDRInputStreamBase impl) {

  80.         this.impl = impl;

  81. 

  82.         impl.setParent(this);

  83.     }

  84. 

  85.     public CDRInputStream(org.omg.CORBA.ORB orb, byte[] data, int size, GIOPVersion version) {

  86. 

  87.         impl = InputStreamFactory.newInputStream(version);

  88. 

  89.         // A grow strategy is used for decoding encapsulations.

  90.         // streaming behaviour is incorrect.

  91.         BufferManagerRead bufMgr = new BufferManagerReadGrow();

  92. 

  93.         impl.init(orb, data, size, false, bufMgr);

  94.         impl.setParent(this);

  95.     }

  96. 

  97.     public CDRInputStream(org.omg.CORBA.ORB orb,

  98.                           byte[] data,

  99.                           int size,

  100.                           boolean littleEndian,

  101.                           GIOPVersion version)

  102.     {

  103.         impl = InputStreamFactory.newInputStream(version);

  104. 

  105.         BufferManagerRead bufMgr = BufferManagerFactory.newBufferManagerRead(version, orb);

  106. 

  107.         impl.init(orb, data, size, littleEndian, bufMgr);

  108.         impl.setParent(this);

  109.     }

  110. 

  111.     public CDRInputStream(org.omg.CORBA.ORB orb,

  112.                           byte[] data,

  113.                           int size,

  114.                           boolean littleEndian,

  115.                           GIOPVersion version,

  116.                           boolean allowFragmentation)

  117.     {

  118.         impl = InputStreamFactory.newInputStream(version);

  119. 

  120.         BufferManagerRead bufMgr;

  121.         if (!allowFragmentation)

  122.             bufMgr = new BufferManagerReadGrow();

  123.         else

  124.             bufMgr = BufferManagerFactory.newBufferManagerRead(version, orb);

  125. 

  126.         impl.init(orb, data, size, littleEndian, bufMgr);

  127.         impl.setParent(this);

  128.     }

  129. 

  130.     public CDRInputStream(org.omg.CORBA.ORB orb,

  131.                           boolean littleEndian,

  132.                           GIOPVersion version,

  133.                           boolean allowFragmentation)

  134.     {

  135.         impl = InputStreamFactory.newInputStream(version);

  136. 

  137.         BufferManagerRead bufMgr;

  138.         if (!allowFragmentation)

  139.             bufMgr = new BufferManagerReadGrow();

  140.         else

  141.             bufMgr = BufferManagerFactory.newBufferManagerRead(version, orb);

  142. 

  143.         impl.init(orb, bufMgr, littleEndian);

  144.         impl.setParent(this);

  145.     }

  146. 

  147.     // org.omg.CORBA.portable.InputStream

  148.     public final boolean read_boolean() {

  149.         return impl.read_boolean();

  150.     }

  151. 

  152.     public final char read_char() {

  153.         return impl.read_char();

  154.     }

  155. 

  156.     public final char read_wchar() {

  157.         return impl.read_wchar();

  158.     }

  159. 

  160.     public final byte read_octet() {

  161.         return impl.read_octet();

  162.     }

  163. 

  164.     public final short read_short() {

  165.         return impl.read_short();

  166.     }

  167. 

  168.     public final short read_ushort() {

  169.         return impl.read_ushort();

  170.     }

  171. 

  172.     public final int read_long() {

  173.         return impl.read_long();

  174.     }

  175. 

  176.     public final int read_ulong() {

  177.         return impl.read_ulong();

  178.     }

  179. 

  180.     public final long read_longlong() {

  181.         return impl.read_longlong();

  182.     }

  183. 

  184.     public final long read_ulonglong() {

  185.         return impl.read_ulonglong();

  186.     }

  187. 

  188.     public final float read_float() {

  189.         return impl.read_float();

  190.     }

  191. 

  192.     public final double read_double() {

  193.         return impl.read_double();

  194.     }

  195. 

  196.     public final String read_string() {

  197.         return impl.read_string();

  198.     }

  199. 

  200.     public final String read_wstring() {

  201.         return impl.read_wstring();

  202.     }

  203. 

  204.     public final void read_boolean_array(boolean[] value, int offset, int length) {

  205.         impl.read_boolean_array(value, offset, length);

  206.     }

  207. 

  208.     public final void read_char_array(char[] value, int offset, int length) {

  209.         impl.read_char_array(value, offset, length);

  210.     }

  211. 

  212.     public final void read_wchar_array(char[] value, int offset, int length) {

  213.         impl.read_wchar_array(value, offset, length);

  214.     }

  215. 

  216.     public final void read_octet_array(byte[] value, int offset, int length) {

  217.         impl.read_octet_array(value, offset, length);

  218.     }

  219. 

  220.     public final void read_short_array(short[] value, int offset, int length) {

  221.         impl.read_short_array(value, offset, length);

  222.     }

  223. 

  224.     public final void read_ushort_array(short[] value, int offset, int length) {

  225.         impl.read_ushort_array(value, offset, length);

  226.     }

  227. 

  228.     public final void read_long_array(int[] value, int offset, int length) {

  229.         impl.read_long_array(value, offset, length);

  230.     }

  231. 

  232.     public final void read_ulong_array(int[] value, int offset, int length) {

  233.         impl.read_ulong_array(value, offset, length);

  234.     }

  235. 

  236.     public final void read_longlong_array(long[] value, int offset, int length) {

  237.         impl.read_longlong_array(value, offset, length);

  238.     }

  239. 

  240.     public final void read_ulonglong_array(long[] value, int offset, int length) {

  241.         impl.read_ulonglong_array(value, offset, length);

  242.     }

  243. 

  244.     public final void read_float_array(float[] value, int offset, int length) {

  245.         impl.read_float_array(value, offset, length);

  246.     }

  247. 

  248.     public final void read_double_array(double[] value, int offset, int length) {

  249.         impl.read_double_array(value, offset, length);

  250.     }

  251. 

  252.     public final org.omg.CORBA.Object read_Object() {

  253.         return impl.read_Object();

  254.     }

  255. 

  256.     public final TypeCode read_TypeCode() {

  257.         return impl.read_TypeCode();

  258.     }

  259.     public final Any read_any() {

  260.         return impl.read_any();

  261.     }

  262. 

  263.     public final Principal read_Principal() {

  264.         return impl.read_Principal();

  265.     }

  266. 

  267.     public final int read() throws java.io.IOException {

  268.         return impl.read();

  269.     }

  270. 

  271.     public final java.math.BigDecimal read_fixed() {

  272.         return impl.read_fixed();

  273.     }

  274. 

  275.     public final org.omg.CORBA.Context read_Context() {

  276.         return impl.read_Context();

  277.     }

  278. 

  279.     public final org.omg.CORBA.Object read_Object(java.lang.Class clz) {

  280.         return impl.read_Object(clz);

  281.     }

  282. 

  283.     public final org.omg.CORBA.ORB orb() {

  284.         return impl.orb();

  285.     }

  286. 

  287.     // org.omg.CORBA_2_3.portable.InputStream

  288.     public final java.io.Serializable read_value() {

  289.         return impl.read_value();

  290.     }

  291. 

  292.     public final java.io.Serializable read_value(java.lang.Class clz) {

  293.         return impl.read_value(clz);

  294.     }

  295. 

  296.     public final java.io.Serializable read_value(org.omg.CORBA.portable.BoxedValueHelper factory) {

  297.         return impl.read_value(factory);

  298.     }

  299. 

  300.     public final java.io.Serializable read_value(java.lang.String rep_id) {

  301.         return impl.read_value(rep_id);

  302.     }

  303. 

  304.     public final java.io.Serializable read_value(java.io.Serializable value) {

  305.         return impl.read_value(value);

  306.     }

  307. 

  308.     public final java.lang.Object read_abstract_interface() {

  309.         return impl.read_abstract_interface();

  310.     }

  311. 

  312.     public final java.lang.Object read_abstract_interface(java.lang.Class clz) {

  313.         return impl.read_abstract_interface(clz);

  314.     }

  315.     // com.sun.corba.se.internal.core.MarshalInputStream

  316. 

  317.     public final void consumeEndian() {

  318.         impl.consumeEndian();

  319.     }

  320. 

  321.     public final int getPosition() {

  322.         return impl.getPosition();

  323.     }

  324. 

  325.     // org.omg.CORBA.DataInputStream

  326. 

  327.     public final java.lang.Object read_Abstract () {

  328.         return impl.read_Abstract();

  329.     }

  330. 

  331.     public final java.io.Serializable read_Value () {

  332.         return impl.read_Value();

  333.     }

  334. 

  335.     public final void read_any_array (org.omg.CORBA.AnySeqHolder seq, int offset, int length) {

  336.         impl.read_any_array(seq, offset, length);

  337.     }

  338. 

  339.     public final void read_boolean_array (org.omg.CORBA.BooleanSeqHolder seq, int offset, int length) {

  340.         impl.read_boolean_array(seq, offset, length);

  341.     }

  342. 

  343.     public final void read_char_array (org.omg.CORBA.CharSeqHolder seq, int offset, int length) {

  344.         impl.read_char_array(seq, offset, length);

  345.     }

  346. 

  347.     public final void read_wchar_array (org.omg.CORBA.WCharSeqHolder seq, int offset, int length) {

  348.         impl.read_wchar_array(seq, offset, length);

  349.     }

  350. 

  351.     public final void read_octet_array (org.omg.CORBA.OctetSeqHolder seq, int offset, int length) {

  352.         impl.read_octet_array(seq, offset, length);

  353.     }

  354. 

  355.     public final void read_short_array (org.omg.CORBA.ShortSeqHolder seq, int offset, int length) {

  356.         impl.read_short_array(seq, offset, length);

  357.     }

  358. 

  359.     public final void read_ushort_array (org.omg.CORBA.UShortSeqHolder seq, int offset, int length) {

  360.         impl.read_ushort_array(seq, offset, length);

  361.     }

  362. 

  363.     public final void read_long_array (org.omg.CORBA.LongSeqHolder seq, int offset, int length) {

  364.         impl.read_long_array(seq, offset, length);

  365.     }

  366. 

  367.     public final void read_ulong_array (org.omg.CORBA.ULongSeqHolder seq, int offset, int length) {

  368.         impl.read_ulong_array(seq, offset, length);

  369.     }

  370. 

  371.     public final void read_ulonglong_array (org.omg.CORBA.ULongLongSeqHolder seq, int offset, int length) {

  372.         impl.read_ulonglong_array(seq, offset, length);

  373.     }

  374. 

  375.     public final void read_longlong_array (org.omg.CORBA.LongLongSeqHolder seq, int offset, int length) {

  376.         impl.read_longlong_array(seq, offset, length);

  377.     }

  378. 

  379.     public final void read_float_array (org.omg.CORBA.FloatSeqHolder seq, int offset, int length) {

  380.         impl.read_float_array(seq, offset, length);

  381.     }

  382. 

  383.     public final void read_double_array (org.omg.CORBA.DoubleSeqHolder seq, int offset, int length) {

  384.         impl.read_double_array(seq, offset, length);

  385.     }

  386. 

  387.     // org.omg.CORBA.portable.ValueBase

  388.     public final String[] _truncatable_ids() {

  389.         return impl._truncatable_ids();

  390.     }

  391. 

  392.     // java.io.InputStream

  393.     public final int read(byte b[]) throws IOException {

  394.         return impl.read(b);

  395.     }

  396. 

  397.     public final int read(byte b[], int off, int len) throws IOException {

  398.         return impl.read(b, off, len);

  399.     }

  400. 

  401.     public final long skip(long n) throws IOException {

  402.         return impl.skip(n);

  403.     }

  404. 

  405.     public final int available() throws IOException {

  406.         return impl.available();

  407.     }

  408. 

  409.     public final void close() throws IOException {

  410.         impl.close();

  411.     }

  412. 

  413.     public final void mark(int readlimit) {

  414.         impl.mark(readlimit);

  415.     }

  416. 

  417.     public final void reset() {

  418.         impl.reset();

  419.     }

  420. 

  421.     public final boolean markSupported() {

  422.         return impl.markSupported();

  423.     }

  424. 

  425.     public abstract CDRInputStream dup();

  426. 

  427.     // Needed by TCUtility

  428.     public final java.math.BigDecimal read_fixed(short digits, short scale) {

  429.         return impl.read_fixed(digits, scale);

  430.     }

  431. 

  432.     public final boolean isLittleEndian() {

  433.         return impl.isLittleEndian();

  434.     }

  435. 

  436.     protected final byte[] getByteBuffer() {

  437.         return impl.getByteBuffer();

  438.     }

  439. 

  440.     protected final void setByteBuffer(byte buffer[]) {

  441.         impl.setByteBuffer(buffer);

  442.     }

  443. 

  444.     public final int getBufferLength() {

  445.         return impl.getBufferLength();

  446.     }

  447. 

  448.     protected final void setBufferLength(int value) {

  449.         impl.setBufferLength(value);

  450.     }

  451. 

  452.     protected final int getIndex() {

  453.         return impl.getIndex();

  454.     }

  455. 

  456.     protected final void setIndex(int value) {

  457.         impl.setIndex(value);

  458.     }

  459. 

  460.     public final void orb(org.omg.CORBA.ORB orb) {

  461.         impl.orb(orb);

  462.     }

  463. 

  464.     public final GIOPVersion getGIOPVersion() {

  465.         return impl.getGIOPVersion();

  466.     }

  467. 

  468.     public final BufferManagerRead getBufferManager() {

  469.         return impl.getBufferManager();

  470.     }

  471. 

  472.     // This should be overridden by any stream (ex: IIOPInputStream)

  473.     // which wants to read values.  Thus, TypeCodeInputStream doesn't

  474.     // have to do this.

  475.     public CodeBase getCodeBase() {

  476.         return null;

  477.     }

  478. 

  479.     // Use Latin-1 for GIOP 1.0 or when code set negotiation was not

  480.     // performed.

  481.     protected CodeSetConversion.BTCConverter createCharBTCConverter() {

  482.         return CodeSetConversion.impl().getBTCConverter(OSFCodeSetRegistry.ISO_8859_1,

  483.                                                         impl.isLittleEndian());

  484.     }

  485. 

  486.     // Subclasses must decide what to do here.  It's inconvenient to

  487.     // make the class and this method abstract because of dup().

  488.     protected abstract CodeSetConversion.BTCConverter createWCharBTCConverter();

  489. 

  490.     // Prints the current buffer in a human readable form

  491.     void printBuffer() {

  492.         impl.printBuffer();

  493.     }

  494. 

  495.     /**

  496.      * Aligns the current position on the given octet boundary

  497.      * if there are enough bytes available to do so.  Otherwise,

  498.      * it just returns.  This is used for some (but not all)

  499.      * GIOP 1.2 message headers.

  500.      */

  501.     public void alignOnBoundary(int octetBoundary) {

  502.         impl.alignOnBoundary(octetBoundary);

  503.     }

  504. 

  505.     /**

  506.      * This must be called after determining the proper ORB version,

  507.      * and setting it on the stream's ORB instance.  It can be called

  508.      * after reading the service contexts, since that is the only place

  509.      * we can get the ORB version info.

  510.      *

  511.      * Trying to unmarshal things requiring repository IDs before calling

  512.      * this will result in NullPtrExceptions.

  513.      */

  514.     public void performORBVersionSpecificInit() {

  515.         // In the case of SystemExceptions, a stream is created

  516.         // with its default constructor (and thus no impl is set).

  517.         if (impl != null)

  518.             impl.performORBVersionSpecificInit();

  519.     }

  520. 

  521.     /**

  522.      * Resets any internal references to code set converters.

  523.      * This is useful for forcing the CDR stream to reacquire

  524.      * converters (probably from its subclasses) when state

  525.      * has changed.

  526.      */

  527.     public void resetCodeSetConverters() {

  528.         impl.resetCodeSetConverters();

  529.     }

  530. }