/*

 * 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

 * particular file as subject to the "Classpath" exception as provided

 *

 * 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.

 *

 */

/*

 * Licensed Materials - Property of IBM

 * RMI-IIOP v1.0

 * Copyright IBM Corp. 1998 1999  All Rights Reserved

 *

 */

package com.sun.corba.se.impl.io;

import javax.rmi.CORBA.Util;

import javax.rmi.PortableRemoteObject;

import java.util.Hashtable;

import java.util.Stack;

import java.io.IOException;

import java.util.EmptyStackException;

import com.sun.corba.se.impl.util.Utility;

import com.sun.corba.se.impl.io.IIOPInputStream;

import com.sun.corba.se.impl.io.IIOPOutputStream;

import com.sun.corba.se.impl.util.RepositoryId;

import com.sun.corba.se.impl.util.Utility;

import org.omg.CORBA.TCKind;

import org.omg.CORBA.MARSHAL;

import org.omg.CORBA.BAD_PARAM;

import org.omg.CORBA.CompletionStatus;

import org.omg.CORBA.portable.IndirectionException;

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

import com.sun.org.omg.SendingContext.CodeBaseHelper;

import java.security.AccessController;

import java.security.PrivilegedAction;

import com.sun.corba.se.impl.io.IIOPInputStream.ActiveRecursionManager;

import com.sun.corba.se.spi.logging.CORBALogDomains;

import com.sun.corba.se.impl.logging.OMGSystemException;

import com.sun.corba.se.impl.logging.UtilSystemException;

public class ValueHandlerImpl implements javax.rmi.CORBA.ValueHandlerMultiFormat {

    // Property to override our maximum stream format version

    public static final String FORMAT_VERSION_PROPERTY

        = "com.sun.CORBA.MaxStreamFormatVersion";

    private static final byte MAX_SUPPORTED_FORMAT_VERSION = (byte)2;

    private static final byte STREAM_FORMAT_VERSION_1 = (byte)1;

    // The ValueHandler's maximum stream format version to advertise,

    // set in a static initializer.

    private static final byte MAX_STREAM_FORMAT_VERSION;

    static {

        MAX_STREAM_FORMAT_VERSION = getMaxStreamFormatVersion();

    }

    // Looks for the FORMAT_VERSION_PROPERTY system property

    // to allow the user to override our default stream format

    // version.  Note that this still only allows them to pick

    // a supported version (1 through MAX_STREAM_FORMAT_VERSION).

    private static byte getMaxStreamFormatVersion() {

        try {

            String propValue = (String) AccessController.doPrivileged(

                                        new PrivilegedAction() {

                public java.lang.Object run() {

                    return System.getProperty(ValueHandlerImpl.FORMAT_VERSION_PROPERTY);

                }

            });

            // The property wasn't set

            if (propValue == null)

                return MAX_SUPPORTED_FORMAT_VERSION;

            byte result = Byte.parseByte(propValue);

            // REVISIT.  Just set to MAX_SUPPORTED_FORMAT_VERSION

            // or really let the system shutdown with this Error?

            if (result < 1 || result > MAX_SUPPORTED_FORMAT_VERSION)

                // XXX I18N, logging needed.

                throw new ExceptionInInitializerError("Invalid stream format version: "

                                                      + result

                                                      + ".  Valid range is 1 through "

                                                      + MAX_SUPPORTED_FORMAT_VERSION);

            return result;

        } catch (Exception ex) {

            // REVISIT.  Swallow this or really let

            // the system shutdown with this Error?

            Error err = new ExceptionInInitializerError(ex);

            err.initCause( ex ) ;

            throw err ;

        }

    }

    public static final short kRemoteType = 0;

    public static final short kAbstractType = 1;

    public static final short kValueType = 2;

    private Hashtable inputStreamPairs = null;

    private Hashtable outputStreamPairs = null;

    private CodeBase codeBase = null;

    private boolean useHashtables = true;

    private boolean isInputStream = true;

    private IIOPOutputStream outputStreamBridge = null;

    private IIOPInputStream inputStreamBridge = null;

    private OMGSystemException omgWrapper = OMGSystemException.get(

        CORBALogDomains.RPC_ENCODING ) ;

    private UtilSystemException utilWrapper = UtilSystemException.get(

        CORBALogDomains.RPC_ENCODING ) ;

    // See javax.rmi.CORBA.ValueHandlerMultiFormat

    public byte getMaximumStreamFormatVersion() {

        return MAX_STREAM_FORMAT_VERSION;

    }

    // See javax.rmi.CORBA.ValueHandlerMultiFormat

    public void writeValue(org.omg.CORBA.portable.OutputStream out,

                           java.io.Serializable value,

                           byte streamFormatVersion) {

        if (streamFormatVersion == 2) {

            if (!(out instanceof org.omg.CORBA.portable.ValueOutputStream)) {

                throw omgWrapper.notAValueoutputstream() ;

            }

        } else if (streamFormatVersion != 1) {

            throw omgWrapper.invalidStreamFormatVersion(

                new Integer(streamFormatVersion) ) ;

        }

        writeValueWithVersion(out, value, streamFormatVersion);

    }

    public ValueHandlerImpl(){}

    public ValueHandlerImpl(boolean isInputStream) {

        this();

        useHashtables = false;

        this.isInputStream = isInputStream;

    }

    /**

     * Writes the value to the stream using java semantics.

     * @param out The stream to write the value to

     * @param value The value to be written to the stream

     **/

    public void writeValue(org.omg.CORBA.portable.OutputStream _out,

                           java.io.Serializable value) {

        writeValueWithVersion(_out, value, STREAM_FORMAT_VERSION_1);

    }

    private void writeValueWithVersion(org.omg.CORBA.portable.OutputStream _out,

                                       java.io.Serializable value,

                                       byte streamFormatVersion) {

        org.omg.CORBA_2_3.portable.OutputStream out =

            (org.omg.CORBA_2_3.portable.OutputStream) _out;

        if (!useHashtables) {

            if (outputStreamBridge == null) {

                outputStreamBridge = createOutputStream();

                outputStreamBridge.setOrbStream(out);

            }

            try {

                outputStreamBridge.increaseRecursionDepth();

                writeValueInternal(outputStreamBridge, out, value, streamFormatVersion);

            } finally {

                outputStreamBridge.decreaseRecursionDepth();

            }

            return;

        }

        IIOPOutputStream jdkToOrbOutputStreamBridge = null;

        if (outputStreamPairs == null)

            outputStreamPairs = new Hashtable();

        jdkToOrbOutputStreamBridge = (IIOPOutputStream)outputStreamPairs.get(_out);

        if (jdkToOrbOutputStreamBridge == null) {

            jdkToOrbOutputStreamBridge = createOutputStream();

            jdkToOrbOutputStreamBridge.setOrbStream(out);

            outputStreamPairs.put(_out, jdkToOrbOutputStreamBridge);

        }

        try {

            jdkToOrbOutputStreamBridge.increaseRecursionDepth();

            writeValueInternal(jdkToOrbOutputStreamBridge, out, value, streamFormatVersion);

        } finally {

            if (jdkToOrbOutputStreamBridge.decreaseRecursionDepth() == 0) {

                outputStreamPairs.remove(_out);

            }

        }

    }

    private void writeValueInternal(IIOPOutputStream bridge,

                                    org.omg.CORBA_2_3.portable.OutputStream out,

                                    java.io.Serializable value,

                                    byte streamFormatVersion)

    {

        Class clazz = value.getClass();

        if (clazz.isArray())

            write_Array(out, value, clazz.getComponentType());

        else

            bridge.simpleWriteObject(value, streamFormatVersion);

    }

    /**

     * Reads a value from the stream using java semantics.

     * @param in The stream to read the value from

     * @param clazz The type of the value to be read in

     * @param sender The sending context runtime

     **/

    public java.io.Serializable readValue(org.omg.CORBA.portable.InputStream _in,

                                          int offset,

                                          java.lang.Class clazz,

                                          String repositoryID,

                                          org.omg.SendingContext.RunTime _sender)

    {

        // Must use narrow rather than a direct cast to a com.sun

        // class.  Fix for bug 4379539.

        CodeBase sender = CodeBaseHelper.narrow(_sender);

        org.omg.CORBA_2_3.portable.InputStream in =

            (org.omg.CORBA_2_3.portable.InputStream) _in;

        if (!useHashtables) {

            if (inputStreamBridge == null) {

                inputStreamBridge = createInputStream();

                inputStreamBridge.setOrbStream(in);

                inputStreamBridge.setSender(sender); //d11638

                // backward compatability 4365188

                inputStreamBridge.setValueHandler(this);

            }

            java.io.Serializable result = null;

            try {

                inputStreamBridge.increaseRecursionDepth();

                result = (java.io.Serializable) readValueInternal(inputStreamBridge, in, offset, clazz, repositoryID, sender);

            } finally {

                if (inputStreamBridge.decreaseRecursionDepth() == 0) {

                    // Indirections are resolved immediately since

                    // the change to the active recursion manager,

                    // so this will never happen.

                }

            }

            return result;

        }

        IIOPInputStream jdkToOrbInputStreamBridge = null;

        if (inputStreamPairs == null)

            inputStreamPairs = new Hashtable();

        jdkToOrbInputStreamBridge = (IIOPInputStream)inputStreamPairs.get(_in);

        if (jdkToOrbInputStreamBridge == null) {

            jdkToOrbInputStreamBridge = createInputStream();

            jdkToOrbInputStreamBridge.setOrbStream(in);

            jdkToOrbInputStreamBridge.setSender(sender); //d11638

            // backward compatability 4365188

            jdkToOrbInputStreamBridge.setValueHandler(this);

            inputStreamPairs.put(_in, jdkToOrbInputStreamBridge);

        }

        java.io.Serializable result = null;

        try {

            jdkToOrbInputStreamBridge.increaseRecursionDepth();

            result = (java.io.Serializable) readValueInternal(jdkToOrbInputStreamBridge, in, offset, clazz, repositoryID, sender);

        } finally {

            if (jdkToOrbInputStreamBridge.decreaseRecursionDepth() == 0) {

                inputStreamPairs.remove(_in);

            }

        }

        return result;

    }

    private java.io.Serializable readValueInternal(IIOPInputStream bridge,

                                                  org.omg.CORBA_2_3.portable.InputStream in,

                                                  int offset,

                                                  java.lang.Class clazz,

                                                  String repositoryID,

                                                  com.sun.org.omg.SendingContext.CodeBase sender)

    {

        java.io.Serializable result = null;

        if (clazz == null) {

            // clazz == null indicates an FVD situation for a nonexistant class

            if (isArray(repositoryID)){

                read_Array(bridge, in, null, sender, offset);

            } else {

                bridge.simpleSkipObject(repositoryID, sender);

            }

            return result;

        }

        if (clazz.isArray()) {

            result = (java.io.Serializable)read_Array(bridge, in, clazz, sender, offset);

        } else {

            result = (java.io.Serializable)bridge.simpleReadObject(clazz, repositoryID, sender, offset);

        }

        return result;

    }

    /**

     * Returns the repository ID for the given RMI value Class.

     * @param clz The class to return a repository ID for.

     * @return the repository ID of the Class.

     **/

    public java.lang.String getRMIRepositoryID(java.lang.Class clz) {

        return RepositoryId.createForJavaType(clz);

    }

    /**

     * Indicates whether the given Class performs custom or

     * default marshaling.

     * @param clz The class to test for custom marshaling.

     * @return True if the class performs custom marshaling, false

     * if it does not.

     **/

    public boolean isCustomMarshaled(java.lang.Class clz) {

        return ObjectStreamClass.lookup(clz).isCustomMarshaled();

    }

    /**

     * Returns the CodeBase for this ValueHandler.  This is used by

     * the ORB runtime.  The server sends the service context containing

     * the IOR for this CodeBase on the first GIOP reply.  The clients

     * do the same on the first GIOP request.

     * @return the SendingContext.CodeBase of this ValueHandler.

     **/

    public org.omg.SendingContext.RunTime getRunTimeCodeBase() {

        if (codeBase != null)

            return codeBase;

        else {

            codeBase = new FVDCodeBaseImpl();

            // backward compatability 4365188

            // set the valueHandler so that correct/incorrect RepositoryID

            // calculations can be done based on the ORB version

            FVDCodeBaseImpl fvdImpl = (FVDCodeBaseImpl) codeBase;

            fvdImpl.setValueHandler(this);

            return codeBase;

        }

    }

    // methods supported for backward compatability so that the appropriate

    // Rep-id calculations take place based on the ORB version

    /**

     *  Returns a boolean of whether or not RepositoryId indicates

     *  FullValueDescriptor.

     *  used for backward compatability

     */

     public boolean useFullValueDescription(Class clazz, String repositoryID)

        throws IOException

     {

        return RepositoryId.useFullValueDescription(clazz, repositoryID);

     }

     public String getClassName(String id)

     {

        RepositoryId repID = RepositoryId.cache.getId(id);

        return repID.getClassName();

     }

     public Class getClassFromType(String id)

        throws ClassNotFoundException

     {

        RepositoryId repId = RepositoryId.cache.getId(id);

        return repId.getClassFromType();

     }

     public Class getAnyClassFromType(String id)

        throws ClassNotFoundException

     {

        RepositoryId repId = RepositoryId.cache.getId(id);

        return repId.getAnyClassFromType();

     }

     public String createForAnyType(Class cl)

     {

        return RepositoryId.createForAnyType(cl);

     }

     public String getDefinedInId(String id)

     {

        RepositoryId repId = RepositoryId.cache.getId(id);

        return repId.getDefinedInId();

     }

     public String getUnqualifiedName(String id)

     {

        RepositoryId repId = RepositoryId.cache.getId(id);

        return repId.getUnqualifiedName();

     }

     public String getSerialVersionUID(String id)

     {

        RepositoryId repId = RepositoryId.cache.getId(id);

        return repId.getSerialVersionUID();

     }

     public boolean isAbstractBase(Class clazz)

     {

        return RepositoryId.isAbstractBase(clazz);

     }

     public boolean isSequence(String id)

     {

        RepositoryId repId = RepositoryId.cache.getId(id);

        return repId.isSequence();

     }

    /**

     * If the value contains a writeReplace method then the result

     * is returned.  Otherwise, the value itself is returned.

     * @return the true value to marshal on the wire.

     **/

    public java.io.Serializable writeReplace(java.io.Serializable value) {

        return ObjectStreamClass.lookup(value.getClass()).writeReplace(value);

    }

    /**

     * Encapsulates writing of Java char arrays so that the 1.3 subclass

     * can override it without exposing internals across packages.  This

     * is a fix for bug 4367783.

     */

    protected void writeCharArray(org.omg.CORBA_2_3.portable.OutputStream out,

                                char[] array,

                                int offset,

                                int length)

    {

        out.write_wchar_array(array, offset, length);

    }

    private void write_Array(org.omg.CORBA_2_3.portable.OutputStream out, java.io.Serializable obj, Class type) {

        int i, length;

        if (type.isPrimitive()) {

            if (type == Integer.TYPE) {

                int[] array = (int[])((Object)obj);

                length = array.length;

                out.write_ulong(length);

                out.write_long_array(array, 0, length);

            } else if (type == Byte.TYPE) {

                byte[] array = (byte[])((Object)obj);

                length = array.length;

                out.write_ulong(length);

                out.write_octet_array(array, 0, length);

            } else if (type == Long.TYPE) {

                long[] array = (long[])((Object)obj);

                length = array.length;

                out.write_ulong(length);

                out.write_longlong_array(array, 0, length);

            } else if (type == Float.TYPE) {

                float[] array = (float[])((Object)obj);

                length = array.length;

                out.write_ulong(length);

                out.write_float_array(array, 0, length);

            } else if (type == Double.TYPE) {

                double[] array = (double[])((Object)obj);

                length = array.length;

                out.write_ulong(length);

                out.write_double_array(array, 0, length);

            } else if (type == Short.TYPE) {

                short[] array = (short[])((Object)obj);

                length = array.length;

                out.write_ulong(length);

                out.write_short_array(array, 0, length);

            } else if (type == Character.TYPE) {

                char[] array = (char[])((Object)obj);

                length = array.length;

                out.write_ulong(length);

                writeCharArray(out, array, 0, length);

            } else if (type == Boolean.TYPE) {

                boolean[] array = (boolean[])((Object)obj);

                length = array.length;

                out.write_ulong(length);

                out.write_boolean_array(array, 0, length);