/*

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

import org.omg.CORBA.SystemException;

import org.omg.CORBA.CompletionStatus;

import org.omg.CORBA.BAD_OPERATION;

import org.omg.CORBA.BAD_INV_ORDER;

import org.omg.CORBA.BAD_PARAM;

import org.omg.CORBA.ORB;

import org.omg.CORBA.Any;

import org.omg.CORBA.TypeCode;

import org.omg.CORBA.Principal;

import org.omg.CORBA.portable.InputStream;

import org.omg.CORBA.portable.OutputStream;

import org.omg.CORBA.portable.BoxedValueHelper;

import org.omg.CORBA.portable.ValueFactory;

import org.omg.CORBA.portable.Streamable;

import org.omg.CORBA.portable.Delegate;

import java.util.Hashtable;

import java.util.NoSuchElementException;

import java.rmi.Remote;

import java.rmi.NoSuchObjectException;

import java.rmi.RemoteException;

import java.rmi.server.RemoteStub;

import javax.rmi.PortableRemoteObject;

import javax.rmi.CORBA.Stub;

import javax.rmi.CORBA.Tie;

import javax.rmi.CORBA.Util;

import java.io.Serializable;

import java.io.File;

import java.io.FileInputStream;

import org.omg.PortableServer.POA;

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

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.impl.logging.UtilSystemException ;

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

/**

 *  Handy class full of static functions.

 */

public final class Utility {

    public static final String STUB_PREFIX = "_";

    public static final String RMI_STUB_SUFFIX = "_Stub";

    public static final String DYNAMIC_STUB_SUFFIX = "_DynamicStub" ;

    public static final String IDL_STUB_SUFFIX = "Stub";

    public static final String TIE_SUFIX = "_Tie";

    private static IdentityHashtable tieCache = new IdentityHashtable();

    private static IdentityHashtable tieToStubCache = new IdentityHashtable();

    private static IdentityHashtable stubToTieCache = new IdentityHashtable();

    private static Object CACHE_MISS = new Object();

    private static UtilSystemException wrapper = UtilSystemException.get(

        CORBALogDomains.UTIL ) ;

    private static OMGSystemException omgWrapper = OMGSystemException.get(

        CORBALogDomains.UTIL ) ;

    /**

     * Ensure that stubs, ties, and implementation objects

     * are 'connected' to the runtime. Converts implementation

     * objects to a type suitable for sending on the wire.

     * @param obj the object to connect.

     * @param orb the ORB to connect to if obj is exported to IIOP.

     * @param convertToStub true if implementation types should be

     * converted to Stubs rather than just org.omg.CORBA.Object.

     * @return the connected object.

     * @exception NoSuchObjectException if obj is an implementation

     * which has not been exported.

     */

    public static Object autoConnect(Object obj, ORB orb, boolean convertToStub)

    {

        if (obj == null) {

            return obj;

        }

        if (StubAdapter.isStub(obj)) {

            try {

                StubAdapter.getDelegate(obj) ;

            } catch (BAD_OPERATION okay) {

                try {

                    StubAdapter.connect( obj, orb ) ;

                } catch (RemoteException e) {

                    // The stub could not be connected because it

                    // has an invalid IOR...

                    throw wrapper.objectNotConnected( e,

                        obj.getClass().getName() ) ;

                }

            }

            return obj;

        }

        if (obj instanceof Remote) {

            Remote remoteObj = (Remote)obj;

            Tie theTie = Util.getTie(remoteObj);

            if (theTie != null) {

                try {

                    theTie.orb();

                } catch (SystemException okay) {

                    theTie.orb(orb);

                }

                if (convertToStub) {

                    Object result = loadStub(theTie,null,null,true);

                    if (result != null) {

                        return result;

                    } else {

                        throw wrapper.couldNotLoadStub(obj.getClass().getName());

                    }

                } else {

                    return StubAdapter.activateTie( theTie );

                }

            } else {

                // This is an implementation object which has not been

                // exported to IIOP OR is a JRMP stub or implementation

                // object which cannot be marshalled into an ORB stream...

                throw wrapper.objectNotExported( obj.getClass().getName() ) ;

            }

        }

        // Didn't need to do anything, just return the input...

        return obj;

    }

    /*

     * Get a new instance of an RMI-IIOP Tie for the

     * given server object.

     */

    public static Tie loadTie(Remote obj) {

        Tie result = null;

        Class objClass = obj.getClass();

        // Have we tried to find this guy before?

        synchronized (tieCache) {

            Object it = tieCache.get(obj);

            if (it == null) {

                // No, so try it...

                try {

                    // First try the classname...

                    result = loadTie(objClass);

                    // If we don't have a valid tie at this point,

                    // walk up the parent chain until we either

                    // load a tie or encounter PortableRemoteObject

                    // or java.lang.Object...

                    while (result == null &&

                           (objClass = objClass.getSuperclass()) != null &&

                           objClass != PortableRemoteObject.class &&

                           objClass != Object.class) {

                        result = loadTie(objClass);

                    }

                } catch (Exception ex) {

                    wrapper.loadTieFailed( ex, objClass.getName() ) ;

                }

                // Did we get it?

                if (result == null) {

                    // Nope, so cache that fact...

                    tieCache.put(obj,CACHE_MISS);

                } else {

                    // Yes, so cache it...

                    tieCache.put(obj,result);

                }

            } else {

                // Yes, return a new instance or fail again if

                // it was a miss last time...

                if (it != CACHE_MISS) {

                    try {

                        result = (Tie) it.getClass().newInstance();

                    } catch (Exception e) {

                    }

                }

            }

        }

        return result;

    }

    /*

     * Load an RMI-IIOP Tie

     */

    private static Tie loadTie(Class theClass)

    {

        return com.sun.corba.se.spi.orb.ORB.getStubFactoryFactory().

            getTie( theClass ) ;

    }

    /*

     * Clear the stub/tie caches. Intended for use by

     * test code.

     */

    public static void clearCaches() {

        synchronized (tieToStubCache) {

            tieToStubCache.clear();

        }

        synchronized (tieCache) {

            tieCache.clear();

        }

        synchronized (stubToTieCache) {

            stubToTieCache.clear();

        }

    }

    /*

     * Load a class and check that it is assignable to a given type.

     * @param className the class name.

     * @param remoteCodebase the codebase to use. May be null.

     * @param loader the class loader of last resort. May be null.

     * @param expectedType the expected type. May be null.

     * @return the loaded class.

     */

    static Class loadClassOfType(String className, String remoteCodebase,

        ClassLoader loader, Class expectedType,

        ClassLoader expectedTypeClassLoader) throws ClassNotFoundException

    {

        Class loadedClass = null;

        try {

            //Sequence finding of the stubs according to spec

            try{

                //If-else is put here for speed up of J2EE.

                //According to the OMG spec, the if clause is not dead code.

                //It can occur if some compiler has allowed generation

                //into org.omg.stub hierarchy for non-offending

                //classes. This will encourage people to

                //produce non-offending class stubs in their own hierarchy.

                if (!PackagePrefixChecker.hasOffendingPrefix(

                    PackagePrefixChecker.withoutPackagePrefix(className))){

                    loadedClass = Util.loadClass(

                        PackagePrefixChecker.withoutPackagePrefix(className),

                        remoteCodebase,

                        loader);

                } else {

                    loadedClass = Util.loadClass(className, remoteCodebase,

                        loader);

                }

            } catch (ClassNotFoundException cnfe) {

                loadedClass = Util.loadClass(className, remoteCodebase,

                    loader);

            }

            if (expectedType == null)

                return loadedClass;

        } catch (ClassNotFoundException cnfe) {

            if (expectedType == null)

                throw cnfe;

        }

        // If no class was loaded, or if the loaded class is not of the

        // correct type, make a further attempt to load the correct class

        // using the classloader of the expected type.

        // _REVISIT_ Is this step necessary, or should the Util,loadClass

        // algorithm always produce a valid class if the setup is correct?

        // Does the OMG standard algorithm need to be changed to include

        // this step?

        if (loadedClass == null || !expectedType.isAssignableFrom(loadedClass)){

            if (expectedType.getClassLoader() != expectedTypeClassLoader)

                throw new IllegalArgumentException(

                    "expectedTypeClassLoader not class loader of "  +

                    "expected Type.");

            if (expectedTypeClassLoader != null)

                loadedClass = expectedTypeClassLoader.loadClass(className);

            else {

                ClassLoader cl = Thread.currentThread().getContextClassLoader();

                if (cl == null)

                    cl = ClassLoader.getSystemClassLoader();

                loadedClass = cl.loadClass(className);

            }

        }

        return loadedClass;

    }

    /*

     * Load a class and check that it is compatible with a given type.

     * @param className the class name.

     * @param remoteCodebase the codebase to use. May be null.

     * @param loadingContext the loading context. May be null.

     * @param relatedType the related type. May be null.

     * @return the loaded class.

     */

    public static Class loadClassForClass (String className,

                                           String remoteCodebase,

                                           ClassLoader loader,

                                           Class relatedType,

                                           ClassLoader relatedTypeClassLoader)

        throws ClassNotFoundException

    {

        if (relatedType == null)

            return Util.loadClass(className, remoteCodebase, loader);

        Class loadedClass = null;

        try {

            loadedClass = Util.loadClass(className, remoteCodebase, loader);

        } catch (ClassNotFoundException cnfe) {

            if (relatedType.getClassLoader() == null)

                throw cnfe;

        }

        // If no class was not loaded, or if the loaded class is not of the

        // correct type, make a further attempt to load the correct class

        // using the classloader of the related type.

        // _REVISIT_ Is this step necessary, or should the Util,loadClass

        // algorithm always produce a valid class if the setup is correct?

        // Does the OMG standard algorithm need to be changed to include

        // this step?

        if (loadedClass == null ||

            (loadedClass.getClassLoader() != null &&

             loadedClass.getClassLoader().loadClass(relatedType.getName()) !=

                 relatedType))

        {

            if (relatedType.getClassLoader() != relatedTypeClassLoader)

                throw new IllegalArgumentException(

                    "relatedTypeClassLoader not class loader of relatedType.");

            if (relatedTypeClassLoader != null)

                loadedClass = relatedTypeClassLoader.loadClass(className);

        }

        return loadedClass;

    }

    /**

     * Get the helper for an IDLValue

     *

     * Throws MARSHAL exception if no helper found.

     */

    public static BoxedValueHelper getHelper(Class clazz, String codebase,

        String repId)

    {

        String className = null;

        if (clazz != null) {

            className = clazz.getName();

            if (codebase == null)

                codebase = Util.getCodebase(clazz);

        } else {

            if (repId != null)

                className = RepositoryId.cache.getId(repId).getClassName();

            if (className == null) // no repId or unrecognized repId

                throw wrapper.unableLocateValueHelper(

                    CompletionStatus.COMPLETED_MAYBE);

        }

        try {

            ClassLoader clazzLoader =

                (clazz == null ? null : clazz.getClassLoader());

            Class helperClass =

                loadClassForClass(className+"Helper", codebase, clazzLoader,

                clazz, clazzLoader);

            return (BoxedValueHelper)helperClass.newInstance();

        } catch (ClassNotFoundException cnfe) {

            throw wrapper.unableLocateValueHelper( CompletionStatus.COMPLETED_MAYBE,

                cnfe );

        } catch (IllegalAccessException iae) {

            throw wrapper.unableLocateValueHelper( CompletionStatus.COMPLETED_MAYBE,

                iae );

        } catch (InstantiationException ie) {

            throw wrapper.unableLocateValueHelper( CompletionStatus.COMPLETED_MAYBE,

                ie );

        } catch (ClassCastException cce) {

            throw wrapper.unableLocateValueHelper( CompletionStatus.COMPLETED_MAYBE,

                cce );

        }

    }

    /**

     * Get the factory for an IDLValue

     *

     * Throws MARSHAL exception if no factory found.

     */

    public static ValueFactory getFactory(Class clazz, String codebase,

                               ORB orb, String repId)

    {

        ValueFactory factory = null;

        if ((orb != null) && (repId != null)) {

            try {

                factory = ((org.omg.CORBA_2_3.ORB)orb).lookup_value_factory(

                    repId);

            } catch (org.omg.CORBA.BAD_PARAM ex) {

                // Try other way

            }

        }

        String className = null;

        if (clazz != null) {

            className = clazz.getName();

            if (codebase == null)

                codebase = Util.getCodebase(clazz);

        } else {

            if (repId != null)

                className = RepositoryId.cache.getId(repId).getClassName();

            if (className == null) // no repId or unrecognized repId

                throw omgWrapper.unableLocateValueFactory(

                    CompletionStatus.COMPLETED_MAYBE);

        }

        // if earlier search found a non-default factory, or the same default

        // factory that loadClassForClass would return, bale out now...

        if (factory != null &&

            (!factory.getClass().getName().equals(className+"DefaultFactory") ||

             (clazz == null && codebase == null)))

            return factory;

        try {

            ClassLoader clazzLoader =

                (clazz == null ? null : clazz.getClassLoader());

            Class factoryClass =

                loadClassForClass(className+"DefaultFactory", codebase,

                clazzLoader, clazz, clazzLoader);

            return (ValueFactory)factoryClass.newInstance();

        } catch (ClassNotFoundException cnfe) {

            throw omgWrapper.unableLocateValueFactory(

                CompletionStatus.COMPLETED_MAYBE, cnfe);

        } catch (IllegalAccessException iae) {

            throw omgWrapper.unableLocateValueFactory(

                CompletionStatus.COMPLETED_MAYBE, iae);

        } catch (InstantiationException ie) {

            throw omgWrapper.unableLocateValueFactory(

                CompletionStatus.COMPLETED_MAYBE, ie);

        } catch (ClassCastException cce) {

            throw omgWrapper.unableLocateValueFactory(

                CompletionStatus.COMPLETED_MAYBE, cce);

        }

    }

    /*

     * Load an RMI-IIOP Stub given a Tie.

     * @param tie the tie.

     * @param stubClass the stub class. May be null.

     * @param remoteCodebase the codebase to use. May be null.

     * @param onlyMostDerived if true, will fail if cannot load a stub for the

     * first repID in the tie. If false, will walk all repIDs.

     * @return the stub or null if not found.

     */

    public static Remote loadStub(Tie tie,

                                  PresentationManager.StubFactory stubFactory,

                                  String remoteCodebase,

                                  boolean onlyMostDerived)

    {

        StubEntry entry = null;

        // Do we already have it cached?

        synchronized (tieToStubCache) {

            Object cached = tieToStubCache.get(tie);

            if (cached == null) {

                // No, so go try to load it...

                entry = loadStubAndUpdateCache(

                        tie, stubFactory, remoteCodebase, onlyMostDerived);

            } else {

                // Yes, is it a stub?  If not, it was a miss last

                // time, so return null again...

                if (cached != CACHE_MISS) {

                    // It's a stub.

                    entry = (StubEntry) cached;

                    // Does the cached stub meet the requirements

                    // of the caller? If the caller does not require

                    // the most derived stub and does not require

                    // a specific stub type, we don't have to check

                    // any further because the cached type is good

                    // enough...

                    if (!entry.mostDerived && onlyMostDerived) {

                        // We must reload because we do not have

                        // the most derived cached already...

                        // The stubFactory arg must be null here