/*

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

 */

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

import java.applet.Applet;

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

import java.lang.reflect.InvocationTargetException;

import java.util.Set;

import java.util.HashSet;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.Properties;

import java.util.Vector;

import java.util.Hashtable;

import java.util.Map;

import java.util.HashMap;

import java.util.LinkedList;

import java.util.Collection;

import java.util.Collections;

import java.util.StringTokenizer;

import java.util.Enumeration;

import java.util.WeakHashMap;

import java.net.InetAddress;

import java.security.PrivilegedAction;

import java.security.AccessController;

import javax.rmi.CORBA.Util;

import javax.rmi.CORBA.ValueHandler;

import org.omg.CORBA.Context;

import org.omg.CORBA.ContextList;

import org.omg.CORBA.Environment;

import org.omg.CORBA.ExceptionList;

import org.omg.CORBA.ORBPackage.InvalidName;

import org.omg.CORBA.NVList;

import org.omg.CORBA.TCKind;

import org.omg.CORBA.NamedValue;

import org.omg.CORBA.Request;

import org.omg.CORBA.SystemException;

import org.omg.CORBA.CompletionStatus;

import org.omg.CORBA.TypeCode;

import org.omg.CORBA.Any;

import org.omg.CORBA.StructMember;

import org.omg.CORBA.UnionMember;

import org.omg.CORBA.ValueMember;

import org.omg.CORBA.BAD_PARAM;

import org.omg.CORBA.MARSHAL;

import org.omg.CORBA.portable.ValueFactory;

import org.omg.CORBA.ORBPackage.InvalidName;

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

import com.sun.corba.se.pept.broker.Broker;

import com.sun.corba.se.pept.protocol.ClientInvocationInfo;

import com.sun.corba.se.pept.transport.ContactInfo;

import com.sun.corba.se.pept.transport.ConnectionCache;

import com.sun.corba.se.pept.transport.TransportManager;

import com.sun.corba.se.spi.ior.IOR;

import com.sun.corba.se.spi.ior.IdentifiableFactoryFinder;

import com.sun.corba.se.spi.ior.TaggedComponentFactoryFinder;

import com.sun.corba.se.spi.ior.IORFactories;

import com.sun.corba.se.spi.ior.ObjectKey;

import com.sun.corba.se.spi.ior.ObjectKeyFactory;

import com.sun.corba.se.spi.ior.iiop.IIOPFactories;

import com.sun.corba.se.spi.ior.iiop.GIOPVersion;

import com.sun.corba.se.spi.oa.OAInvocationInfo;

import com.sun.corba.se.spi.oa.ObjectAdapterFactory;

import com.sun.corba.se.spi.orb.DataCollector;

import com.sun.corba.se.spi.orb.Operation;

import com.sun.corba.se.spi.orb.ORBData;

import com.sun.corba.se.spi.orb.ORBConfigurator;

import com.sun.corba.se.spi.orb.ParserImplBase;

import com.sun.corba.se.spi.orb.PropertyParser;

import com.sun.corba.se.spi.orb.OperationFactory;

import com.sun.corba.se.spi.orb.ORBVersion;

import com.sun.corba.se.spi.orb.ORBVersionFactory;

import com.sun.corba.se.spi.orbutil.closure.ClosureFactory;

import com.sun.corba.se.spi.orbutil.threadpool.ThreadPoolManager;

import com.sun.corba.se.spi.protocol.ClientDelegateFactory;

import com.sun.corba.se.spi.protocol.RequestDispatcherRegistry;

import com.sun.corba.se.spi.protocol.CorbaServerRequestDispatcher;

import com.sun.corba.se.spi.protocol.RequestDispatcherDefault;

import com.sun.corba.se.spi.protocol.PIHandler;

import com.sun.corba.se.spi.protocol.CorbaMessageMediator;

import com.sun.corba.se.spi.protocol.ForwardException;

import com.sun.corba.se.spi.resolver.Resolver;

import com.sun.corba.se.spi.resolver.LocalResolver;

import com.sun.corba.se.spi.orb.StringPair;

import com.sun.corba.se.spi.orb.StringPair;

import com.sun.corba.se.spi.transport.CorbaContactInfoListFactory;

import com.sun.corba.se.spi.transport.CorbaTransportManager;

import com.sun.corba.se.spi.legacy.connection.LegacyServerSocketManager;

import com.sun.corba.se.spi.copyobject.CopierManager;

import com.sun.corba.se.spi.presentation.rmi.PresentationDefaults;

import com.sun.corba.se.spi.presentation.rmi.PresentationManager;

import com.sun.corba.se.spi.presentation.rmi.StubAdapter;

import com.sun.corba.se.spi.servicecontext.ServiceContextRegistry;

import com.sun.corba.se.impl.corba.TypeCodeFactory;

import com.sun.corba.se.impl.corba.TypeCodeImpl;

import com.sun.corba.se.impl.corba.NVListImpl;

import com.sun.corba.se.impl.corba.ExceptionListImpl;

import com.sun.corba.se.impl.corba.ContextListImpl;

import com.sun.corba.se.impl.corba.NamedValueImpl;

import com.sun.corba.se.impl.corba.EnvironmentImpl;

import com.sun.corba.se.impl.corba.AsynchInvoke;

import com.sun.corba.se.impl.corba.AnyImpl;

import com.sun.corba.se.impl.corba.RequestImpl;

import com.sun.corba.se.impl.dynamicany.DynAnyFactoryImpl;

import com.sun.corba.se.impl.encoding.EncapsOutputStream;

import com.sun.corba.se.impl.encoding.CachedCodeBase;

import com.sun.corba.se.impl.interceptors.PIHandlerImpl;

import com.sun.corba.se.impl.interceptors.PINoOpHandlerImpl;

import com.sun.corba.se.impl.ior.TaggedComponentFactoryFinderImpl;

import com.sun.corba.se.impl.ior.TaggedProfileFactoryFinderImpl;

import com.sun.corba.se.impl.ior.TaggedProfileTemplateFactoryFinderImpl;

import com.sun.corba.se.impl.oa.toa.TOAFactory;

import com.sun.corba.se.impl.oa.poa.BadServerIdHandler;

import com.sun.corba.se.impl.oa.poa.DelegateImpl;

import com.sun.corba.se.impl.oa.poa.POAFactory;

import com.sun.corba.se.impl.orbutil.ORBConstants;

import com.sun.corba.se.impl.orbutil.ORBUtility;

import com.sun.corba.se.impl.orbutil.StackImpl;

import com.sun.corba.se.impl.orbutil.threadpool.ThreadPoolImpl;

import com.sun.corba.se.impl.orbutil.threadpool.ThreadPoolManagerImpl;

import com.sun.corba.se.impl.protocol.RequestDispatcherRegistryImpl;

import com.sun.corba.se.impl.protocol.CorbaInvocationInfo;

import com.sun.corba.se.impl.transport.CorbaTransportManagerImpl;

import com.sun.corba.se.impl.legacy.connection.LegacyServerSocketManagerImpl;

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

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

import com.sun.corba.se.impl.copyobject.CopierManagerImpl;

import com.sun.corba.se.impl.presentation.rmi.PresentationManagerImpl;

/**

 * The JavaIDL ORB implementation.

 */

public class ORBImpl extends com.sun.corba.se.spi.orb.ORB

{

    protected TransportManager transportManager;

    protected LegacyServerSocketManager legacyServerSocketManager;

    private ThreadLocal OAInvocationInfoStack ;

    private ThreadLocal clientInvocationInfoStack ;

    // pure java orb, caching the servant IOR per ORB

    private static IOR codeBaseIOR ;

    // Vector holding deferred Requests

    private Vector            dynamicRequests ;

    private SynchVariable     svResponseReceived ;

    private java.lang.Object runObj = new java.lang.Object();

    private java.lang.Object shutdownObj = new java.lang.Object();

    private java.lang.Object waitForCompletionObj = new java.lang.Object();

    private static final byte STATUS_OPERATING = 1;

    private static final byte STATUS_SHUTTING_DOWN = 2;

    private static final byte STATUS_SHUTDOWN = 3;

    private static final byte STATUS_DESTROYED = 4;

    private byte status = STATUS_OPERATING;

    // XXX Should we move invocation tracking to the first level server dispatcher?

    private java.lang.Object invocationObj = new java.lang.Object();

    private int numInvocations = 0;

    // thread local variable to store a boolean to detect deadlock in

    // ORB.shutdown(true).

    private ThreadLocal isProcessingInvocation = new ThreadLocal () {

        protected java.lang.Object initialValue() {

            return Boolean.FALSE;

        }

    };

    // This map is caching TypeCodes created for a certain class (key)

    // and is used in Util.writeAny()

    private Map typeCodeForClassMap ;

    // Cache to hold ValueFactories (Helper classes) keyed on repository ids

    private Hashtable valueFactoryCache = new Hashtable();

    // thread local variable to store the current ORB version.

    // default ORB version is the version of ORB with correct Rep-id

    // changes

    private ThreadLocal orbVersionThreadLocal ;

    private RequestDispatcherRegistry requestDispatcherRegistry ;

    private CopierManager copierManager ;

    private int transientServerId ;

    private ServiceContextRegistry serviceContextRegistry ;

    // Needed here to implement connect/disconnect

    private TOAFactory toaFactory ;

    // Needed here for set_delegate

    private POAFactory poaFactory ;

    // The interceptor handler, which provides portable interceptor services for

    // subcontracts and object adapters.

    private PIHandler pihandler ;

    private ORBData configData ;

    private BadServerIdHandler badServerIdHandler ;

    private ClientDelegateFactory clientDelegateFactory ;

    private CorbaContactInfoListFactory corbaContactInfoListFactory ;

    // All access to resolver, localResolver, and urlOperation must be protected using

    // resolverLock.  Do not hold the ORBImpl lock while accessing

    // resolver, or deadlocks may occur.

    // Note that we now have separate locks for each resolver type.  This is due

    // to bug 6980681 and 6238477, which was caused by a deadlock while resolving a

    // corbaname: URL that contained a reference to the same ORB as the

    // ORB making the call to string_to_object.  This caused a deadlock between the

    // client thread holding the single lock for access to the urlOperation,

    // and the server thread handling the client is_a request waiting on the

    // same lock to access the localResolver.

    // Used for resolver_initial_references and list_initial_services

    private Resolver resolver ;

    // Used for register_initial_references

    private LocalResolver localResolver ;

    // Converts strings to object references for resolvers and string_to_object

    private Operation urlOperation ;

    private final Object urlOperationLock = new java.lang.Object() ;

    private CorbaServerRequestDispatcher insNamingDelegate ;

    // resolverLock must be used for all access to either resolver or

    // localResolver, since it is possible for the resolver to indirectly

    // refer to the localResolver.  Also used to protect access to

    // insNamingDelegate.

    private final Object resolverLock = new Object() ;

    private TaggedComponentFactoryFinder taggedComponentFactoryFinder ;

    private IdentifiableFactoryFinder taggedProfileFactoryFinder ;

    private IdentifiableFactoryFinder taggedProfileTemplateFactoryFinder ;

    private ObjectKeyFactory objectKeyFactory ;

    private boolean orbOwnsThreadPoolManager = false ;

    private ThreadPoolManager threadpoolMgr;

    private void dprint( String msg )

    {

        ORBUtility.dprint( this, msg ) ;

    }

    ////////////////////////////////////////////////////

    //

    // NOTE:

    //

    // Methods that are synchronized MUST stay synchronized.

    //

    // Methods that are NOT synchronized must stay that way to avoid deadlock.

    //

    //

    // REVISIT:

    //

    // checkShutDownState - lock on different object - and normalize usage.

    // starting/FinishDispatch and Shutdown

    //

    public ORBData getORBData()

    {

        return configData ;

    }

    public PIHandler getPIHandler()

    {

        return pihandler ;

    }

    /**

     * Create a new ORB. Should be followed by the appropriate

     * set_parameters() call.

     */

    public ORBImpl()

    {

        // All initialization is done through set_parameters().

    }

    public ORBVersion getORBVersion()

    {

        synchronized (this) {

                checkShutdownState();

        }

        return (ORBVersion)(orbVersionThreadLocal.get()) ;

    }

    public void setORBVersion(ORBVersion verObj)

    {

        synchronized (this) {

                checkShutdownState();

        }

        orbVersionThreadLocal.set(verObj);

    }

/****************************************************************************

 * The following methods are ORB initialization

 ****************************************************************************/

    // preInit initializes all non-pluggable ORB data that is independent

    // of the property parsing.

    private void preInit( String[] params, Properties props )

    {

        // Before ORBConfiguration we need to set a PINoOpHandlerImpl,

        // because PersisentServer Initialization inside configurator will

        // invoke orb.resolve_initial_references( ) which will result in a

        // check on piHandler to invoke Interceptors. We do not want any

        // Interceptors to be invoked before the complete ORB initialization.

        // piHandler will be replaced by a real PIHandler implementation at the

        // end of this method.

        pihandler = new PINoOpHandlerImpl( );

        // This is the unique id of this server (JVM). Multiple incarnations

        // of this server will get different ids.

        // Compute transientServerId = milliseconds since Jan 1, 1970

        // Note: transientServerId will wrap in about 2^32 / 86400000 = 49.7 days.

        // If two ORBS are started at the same time then there is a possibility

        // of having the same transientServerId. This may result in collision

        // and may be a problem in ior.isLocal() check to see if the object

        // belongs to the current ORB. This problem is taken care of by checking

        // to see if the IOR port matches ORB server port in legacyIsLocalServerPort()

        // method.

        //

        // XXX need to move server ID to a string for CORBA 3.0.  At that point,

        // make this more unique (possibly use java.rmi.server.UID).

        transientServerId = (int)System.currentTimeMillis();

        orbVersionThreadLocal  = new ThreadLocal () {

            protected java.lang.Object initialValue() {

                // set default to version of the ORB with correct Rep-ids

                return ORBVersionFactory.getORBVersion() ;

            }

        };

        requestDispatcherRegistry = new RequestDispatcherRegistryImpl(

            this, ORBConstants.DEFAULT_SCID);

        copierManager = new CopierManagerImpl( this ) ;

        taggedComponentFactoryFinder =

            new TaggedComponentFactoryFinderImpl(this) ;

        taggedProfileFactoryFinder =

            new TaggedProfileFactoryFinderImpl(this) ;

        taggedProfileTemplateFactoryFinder =

            new TaggedProfileTemplateFactoryFinderImpl(this) ;

        dynamicRequests = new Vector();

        svResponseReceived = new SynchVariable();

        OAInvocationInfoStack =

            new ThreadLocal () {

                protected java.lang.Object initialValue()

                {

                    return new StackImpl();

                }

            };

        clientInvocationInfoStack =

            new ThreadLocal() {

                protected java.lang.Object initialValue() {

                    return new StackImpl();

                }

            };

        serviceContextRegistry = new ServiceContextRegistry( this ) ;

    }

    protected void setDebugFlags( String[] args )

    {

        for (int ctr=0; ctr<args.length; ctr++ ) {

            String token = args[ctr] ;

            // If there is a public boolean data member in this class

            // named token + "DebugFlag", set it to true.

            try {

                Field fld = this.getClass().getField( token + "DebugFlag" ) ;

                int mod = fld.getModifiers() ;

                if (Modifier.isPublic( mod ) && !Modifier.isStatic( mod ))

                    if (fld.getType() == boolean.class)

                        fld.setBoolean( this, true ) ;

            } catch (Exception exc) {

                // ignore it XXX log this as info

            }

        }

    }

    // Class that defines a parser that gets the name of the

    // ORBConfigurator class.

    private static class ConfigParser extends ParserImplBase {

        // The default here is the ORBConfiguratorImpl that we define,

        // but this can be replaced.

        public Class configurator = ORBConfiguratorImpl.class ;

        public PropertyParser makeParser()

        {

            PropertyParser parser = new PropertyParser() ;

            parser.add( ORBConstants.SUN_PREFIX + "ORBConfigurator",

                OperationFactory.classAction(), "configurator" ) ;

            return parser ;

        }

    }

    private void postInit( String[] params, DataCollector dataCollector )

    {

        // First, create the standard ORB config data.

        // This must be initialized before the ORBConfigurator

        // is executed.

        configData = new ORBDataParserImpl( this, dataCollector) ;

        // Set the debug flags early so they can be used by other

        // parts of the initialization.

        setDebugFlags( configData.getORBDebugFlags() ) ;

        // REVISIT: this should go away after more transport init cleanup

        // and going to ORT based ORBD.

        getTransportManager();

        getLegacyServerSocketManager();

        // Create a parser to get the configured ORBConfigurator.

        ConfigParser parser = new ConfigParser() ;

        parser.init( dataCollector ) ;

        ORBConfigurator configurator =  null ;

        try {

            configurator =

                (ORBConfigurator)(parser.configurator.newInstance()) ;

        } catch (Exception iexc) {

            throw wrapper.badOrbConfigurator( iexc, parser.configurator.getName() ) ;

        }

        // Finally, run the configurator.  Note that the default implementation allows

        // other configurators with their own parsers to run,

        // using the same DataCollector.

        try {

            configurator.configure( dataCollector, this ) ;

        } catch (Exception exc) {

            throw wrapper.orbConfiguratorError( exc ) ;

        }

        // Last of all, create the PIHandler and run the ORB initializers.

        pihandler = new PIHandlerImpl( this, params) ;

        pihandler.initialize() ;

        // Initialize the thread manager pool and byte buffer pool

        // so they may be initialized & accessed without synchronization

        getThreadPoolManager();

        super.getByteBufferPool();

    }

    private synchronized POAFactory getPOAFactory()

    {

        if (poaFactory == null) {

            poaFactory = (POAFactory)requestDispatcherRegistry.getObjectAdapterFactory(

                ORBConstants.TRANSIENT_SCID ) ;

        }

        return poaFactory ;

    }

    private synchronized TOAFactory getTOAFactory()

    {

        if (toaFactory == null) {

            toaFactory = (TOAFactory)requestDispatcherRegistry.getObjectAdapterFactory(

                ORBConstants.TOA_SCID ) ;

        }

        return toaFactory ;

    }

    public void set_parameters( Properties props )

    {

        synchronized (this) {