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

 /*

  * Copyright (c) 2002, 2013, 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.

  */

 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) {

                 checkShutdownState();

         }

         preInit( null, props ) ;

         DataCollector dataCollector =

             DataCollectorFactory.create( props, getLocalHostName() ) ;

         postInit( null, dataCollector ) ;

     }

     protected void set_parameters(Applet app, Properties props)

     {

         preInit( null, props ) ;

         DataCollector dataCollector =

             DataCollectorFactory.create( app, props, getLocalHostName() ) ;

         postInit( null, dataCollector ) ;

     }

     protected void set_parameters (String[] params, Properties props)

     {

         preInit( params, props ) ;

         DataCollector dataCollector =

             DataCollectorFactory.create( params, props, getLocalHostName() ) ;

         postInit( params, dataCollector ) ;

     }

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

  * The following methods are standard public CORBA ORB APIs

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

     public synchronized org.omg.CORBA.portable.OutputStream create_output_stream()

     {

         checkShutdownState();

         return sun.corba.OutputStreamFactory.newEncapsOutputStream(this);

     }

     /**

      * Get a Current pseudo-object.

      * The Current interface is used to manage thread-specific

      * information for use by the transactions, security and other

      * services. This method is deprecated,

      * and replaced by ORB.resolve_initial_references("NameOfCurrentObject");

      *

      * @return          a Current pseudo-object.

      * @deprecated

      */

     public synchronized org.omg.CORBA.Current get_current()

     {

         checkShutdownState();

         /* _REVISIT_

            The implementation of get_current is not clear. How would

            ORB know whether the caller wants a Current for transactions

            or security ?? Or is it assumed that there is just one

            implementation for both ? If Current is thread-specific,

            then it should not be instantiated; so where does the

            ORB get a Current ?

            This should probably be deprecated. */

         throw wrapper.genericNoImpl() ;

     }

     /**

      * Create an NVList

      *

      * @param count     size of list to create

      * @result          NVList created

      *

      * @see NVList

      */

     public synchronized NVList create_list(int count)

     {

         checkShutdownState();

         return new NVListImpl(this, count);

     }

     /**

      * Create an NVList corresponding to an OperationDef

      *

      * @param oper      operation def to use to create list

      * @result          NVList created

      *

      * @see NVList

      */

     public synchronized NVList create_operation_list(org.omg.CORBA.Object oper)

     {

         checkShutdownState();

         throw wrapper.genericNoImpl() ;

     }

     /**

      * Create a NamedValue

      *

      * @result          NamedValue created

      */

     public synchronized NamedValue create_named_value(String s, Any any, int flags)

     {

         checkShutdownState();

         return new NamedValueImpl(this, s, any, flags);

     }

     /**

      * Create an ExceptionList

      *

      * @result          ExceptionList created

      */

     public synchronized org.omg.CORBA.ExceptionList create_exception_list()

     {

         checkShutdownState();

         return new ExceptionListImpl();

     }

     /**

      * Create a ContextList

      *

      * @result          ContextList created

      */

     public synchronized org.omg.CORBA.ContextList create_context_list()

     {

         checkShutdownState();

         return new ContextListImpl(this);

     }

     /**

      * Get the default Context object

      *

      * @result          the default Context object

      */

     public synchronized org.omg.CORBA.Context get_default_context()

     {

         checkShutdownState();

         throw wrapper.genericNoImpl() ;

     }

     /**

      * Create an Environment

      *

      * @result          Environment created

      */

     public synchronized org.omg.CORBA.Environment create_environment()

     {

         checkShutdownState();

         return new EnvironmentImpl();

     }

     public synchronized void send_multiple_requests_oneway(Request[] req)

     {

         checkShutdownState();

         // Invoke the send_oneway on each new Request

         for (int i = 0; i < req.length; i++) {

             req[i].send_oneway();

         }

     }

     /**

      * Send multiple dynamic requests asynchronously.

      *

      * @param req         an array of request objects.

      */

     public synchronized void send_multiple_requests_deferred(Request[] req)

     {

         checkShutdownState();

         // add the new Requests to pending dynamic Requests

         for (int i = 0; i < req.length; i++) {

             dynamicRequests.addElement(req[i]);

         }

         // Invoke the send_deferred on each new Request

         for (int i = 0; i < req.length; i++) {

             AsynchInvoke invokeObject = new AsynchInvoke( this,

                 (com.sun.corba.se.impl.corba.RequestImpl)req[i], true);

             new Thread(invokeObject).start();

         }

     }

     /**

      * Find out if any of the deferred invocations have a response yet.

      */

     public synchronized boolean poll_next_response()

     {

         checkShutdownState();

         Request currRequest;

         // poll on each pending request

         Enumeration ve = dynamicRequests.elements();

         while (ve.hasMoreElements() == true) {

             currRequest = (Request)ve.nextElement();

             if (currRequest.poll_response() == true) {

                 return true;

             }

         }

         return false;

     }

     /**

      * Get the next request that has gotten a response.

      *

      * @result            the next request ready with a response.

      */

     public org.omg.CORBA.Request get_next_response()

         throws org.omg.CORBA.WrongTransaction

     {

         synchronized( this ) {

             checkShutdownState();

         }

         while (true) {

             // check if there already is a response

             synchronized ( dynamicRequests ) {

                 Enumeration elems = dynamicRequests.elements();

                 while ( elems.hasMoreElements() ) {

                     Request currRequest = (Request)elems.nextElement();

                     if ( currRequest.poll_response() ) {

                         // get the response for this successfully polled Request

                         currRequest.get_response();

                         dynamicRequests.removeElement(currRequest);

                         return currRequest;

                     }

                 }

             }

             // wait for a response

             synchronized(this.svResponseReceived) {

                 while (!this.svResponseReceived.value()) {

                     try {

                         this.svResponseReceived.wait();

                     } catch(java.lang.InterruptedException ex) {

                         // NO-OP

                     }

                 }

                 // reinitialize the response flag

                 this.svResponseReceived.reset();

             }

         }

     }

     /**

      * Notify response to ORB for get_next_response

      */

     public void notifyORB()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (this.svResponseReceived) {

             this.svResponseReceived.set();

             this.svResponseReceived.notify();

         }

     }

     /**

      * Convert an object ref to a string.

      * @param obj The object to stringify.

      * @return A stringified object reference.

      */

     public synchronized String object_to_string(org.omg.CORBA.Object obj)

     {

         checkShutdownState();

         // Handle the null objref case

         if (obj == null) {

             IOR nullIOR = IORFactories.makeIOR( this ) ;

             return nullIOR.stringify();

         }

         IOR ior = null ;

         try {

             ior = ORBUtility.connectAndGetIOR( this, obj ) ;

         } catch (BAD_PARAM bp) {

             // Throw MARSHAL instead if this is a LOCAL_OBJECT_NOT_ALLOWED error.

             if (bp.minor == ORBUtilSystemException.LOCAL_OBJECT_NOT_ALLOWED) {

                 throw omgWrapper.notAnObjectImpl( bp ) ;

             } else

                 // Not a local object problem: just rethrow the exception.

                 // Do not wrap and log this, since it was already logged at its

                 // point of origin.

                 throw bp ;

         }

         return ior.stringify() ;

     }

     /**

      * Convert a stringified object reference to the object it represents.

      * @param str The stringified object reference.

      * @return The unstringified object reference.

      */

     public org.omg.CORBA.Object string_to_object(String str)

     {

         Operation op ;

         synchronized (this) {

             checkShutdownState();

             op = urlOperation ;

         }

         if (str == null)

             throw wrapper.nullParam() ;

         synchronized (urlOperationLock) {

             org.omg.CORBA.Object obj = (org.omg.CORBA.Object)op.operate( str ) ;

             return obj ;

         }

     }

     // pure java orb support, moved this method from FVDCodeBaseImpl.

     // Note that we connect this if we have not already done so.

     public synchronized IOR getFVDCodeBaseIOR()

     {

         checkShutdownState();

         if (codeBaseIOR != null) // i.e. We are already connected to it

             return codeBaseIOR;

         // backward compatability 4365188

         CodeBase cb;

         ValueHandler vh = ORBUtility.createValueHandler();

         cb = (CodeBase)vh.getRunTimeCodeBase();

         return ORBUtility.connectAndGetIOR( this, cb ) ;

     }

     /**

      * Get the TypeCode for a primitive type.

      *

      * @param tcKind    the integer kind for the primitive type

      * @return          the requested TypeCode

      */

     public synchronized TypeCode get_primitive_tc(TCKind tcKind)

     {

         checkShutdownState();

         return get_primitive_tc( tcKind.value() ) ;

     }

     /**

      * Create a TypeCode for a structure.

      *

      * @param id                the logical id for the typecode.

      * @param name      the name for the typecode.

      * @param members   an array describing the members of the TypeCode.

      * @return          the requested TypeCode.

      */

     public synchronized TypeCode create_struct_tc(String id,

                                      String name,

                                      StructMember[] members)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_struct, id, name, members);

     }

     /**

      * Create a TypeCode for a union.

      *

      * @param id                the logical id for the typecode.

      * @param name      the name for the typecode.

      * @param discriminator_type

      *                  the type of the union discriminator.

      * @param members   an array describing the members of the TypeCode.

      * @return          the requested TypeCode.

      */

     public synchronized TypeCode create_union_tc(String id,

                                     String name,

                                     TypeCode discriminator_type,

                                     UnionMember[] members)

     {

         checkShutdownState();

         return new TypeCodeImpl(this,

                                 TCKind._tk_union,

                                 id,

                                 name,

                                 discriminator_type,

                                 members);

     }

     /**

      * Create a TypeCode for an enum.

      *

      * @param id                the logical id for the typecode.

      * @param name      the name for the typecode.

      * @param members   an array describing the members of the TypeCode.

      * @return          the requested TypeCode.

      */

     public synchronized TypeCode create_enum_tc(String id,

                                    String name,

                                    String[] members)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_enum, id, name, members);

     }

     /**

      * Create a TypeCode for an alias.

      *

      * @param id                the logical id for the typecode.

      * @param name      the name for the typecode.

      * @param original_type

      *                  the type this is an alias for.

      * @return          the requested TypeCode.

      */

     public synchronized TypeCode create_alias_tc(String id,

                                     String name,

                                     TypeCode original_type)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_alias, id, name, original_type);

     }

     /**

      * Create a TypeCode for an exception.

      *

      * @param id                the logical id for the typecode.

      * @param name      the name for the typecode.

      * @param members   an array describing the members of the TypeCode.

      * @return          the requested TypeCode.

      */

     public synchronized TypeCode create_exception_tc(String id,

                                         String name,

                                         StructMember[] members)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_except, id, name, members);

     }

     /**

      * Create a TypeCode for an interface.

      *

      * @param id                the logical id for the typecode.

      * @param name      the name for the typecode.

      * @return          the requested TypeCode.

      */

     public synchronized TypeCode create_interface_tc(String id,

                                         String name)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_objref, id, name);

     }

     /**

      * Create a TypeCode for a string.

      *

      * @param bound     the bound for the string.

      * @return          the requested TypeCode.

      */

     public synchronized TypeCode create_string_tc(int bound)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_string, bound);

     }

     /**

      * Create a TypeCode for a wide string.

      *

      * @param bound     the bound for the string.

      * @return          the requested TypeCode.

      */

     public synchronized TypeCode create_wstring_tc(int bound)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_wstring, bound);

     }

     /**

      * Create a TypeCode for a sequence.

      *

      * @param bound     the bound for the sequence.

      * @param element_type

      *                  the type of elements of the sequence.

      * @return          the requested TypeCode.

      */

     public synchronized TypeCode create_sequence_tc(int bound,

                                        TypeCode element_type)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_sequence, bound, element_type);

     }

     /**

      * Create a recursive TypeCode in a sequence.

      *

      * @param bound     the bound for the sequence.

      * @param offset    the index to the enclosing TypeCode that is

      *                  being referenced.

      * @return          the requested TypeCode.

      */

     public synchronized TypeCode create_recursive_sequence_tc(int bound,

                                                  int offset)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_sequence, bound, offset);

     }

     /**

      * Create a TypeCode for an array.

      *

      * @param length    the length of the array.

      * @param element_type

      *                  the type of elements of the array.

      * @return          the requested TypeCode.

      */

     public synchronized TypeCode create_array_tc(int length,

                                     TypeCode element_type)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_array, length, element_type);

     }

     public synchronized org.omg.CORBA.TypeCode create_native_tc(String id,

                                                    String name)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_native, id, name);

     }

     public synchronized org.omg.CORBA.TypeCode create_abstract_interface_tc(

                                                                String id,

                                                                String name)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_abstract_interface, id, name);

     }

     public synchronized org.omg.CORBA.TypeCode create_fixed_tc(short digits, short scale)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_fixed, digits, scale);

     }

     public synchronized org.omg.CORBA.TypeCode create_value_tc(String id,

                                                   String name,

                                                   short type_modifier,

                                                   TypeCode concrete_base,

                                                   ValueMember[] members)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_value, id, name,

                                 type_modifier, concrete_base, members);

     }

     public synchronized org.omg.CORBA.TypeCode create_recursive_tc(String id) {

         checkShutdownState();

         return new TypeCodeImpl(this, id);

     }

     public synchronized org.omg.CORBA.TypeCode create_value_box_tc(String id,

                                                       String name,

                                                       TypeCode boxed_type)

     {

         checkShutdownState();

         return new TypeCodeImpl(this, TCKind._tk_value_box, id, name,

             boxed_type);

     }

     /**

      * Create a new Any

      *

      * @return          the new Any created.

      */

     public synchronized Any create_any()

     {

         checkShutdownState();

         return new AnyImpl(this);

     }

     // TypeCodeFactory interface methods.

     // Keeping track of type codes by repository id.

     // Keeping a cache of TypeCodes associated with the class

     // they got created from in Util.writeAny().

     public synchronized void setTypeCodeForClass(Class c, TypeCodeImpl tci)

     {

         checkShutdownState();

         if (typeCodeForClassMap == null)

             typeCodeForClassMap = Collections.synchronizedMap(

                 new WeakHashMap(64));

         // Store only one TypeCode per class.

         if ( ! typeCodeForClassMap.containsKey(c))

             typeCodeForClassMap.put(c, tci);

     }

     public synchronized TypeCodeImpl getTypeCodeForClass(Class c)

     {

         checkShutdownState();

         if (typeCodeForClassMap == null)

             return null;

         return (TypeCodeImpl)typeCodeForClassMap.get(c);

     }

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

  * The following methods deal with listing and resolving the initial

  * (bootstrap) object references such as "NameService".

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

     /**

      * Get a list of the initially available CORBA services.

      * This does not work unless an ORBInitialHost is specified during

      * initialization (or unless there is an ORB running on the AppletHost)

      * since the localhostname

      * is inaccessible to applets. If a service properties URL was specified,

      * then it is used, otherwise the bootstrapping protocol is used.

      * @return A list of the initial services available.

      */

     public String[] list_initial_services()

     {

         Resolver res ;

         synchronized( this ) {

             checkShutdownState();

             res = resolver ;

         }

         synchronized (resolverLock) {

             java.util.Set keys = res.list() ;

             return (String[])keys.toArray( new String[keys.size()] ) ;

         }

     }

     /**

      * Resolve the stringified reference of one of the initially

      * available CORBA services.

      * @param identifier The stringified object reference of the

      * desired service.

      * @return An object reference for the desired service.

      * @exception InvalidName The supplied identifier is not associated

      * with a known service.

      * @exception SystemException One of a fixed set of Corba system exceptions.

      */

     public org.omg.CORBA.Object resolve_initial_references(

         String identifier) throws InvalidName

     {

         Resolver res ;

         synchronized( this ) {

             checkShutdownState();

             res = resolver ;

         }

         synchronized (resolverLock) {

             org.omg.CORBA.Object result = res.resolve( identifier ) ;

             if (result == null)

                 throw new InvalidName() ;

             else

                 return result ;

         }

     }

     /**

      * If this operation is called with an id, <code>"Y"</code>, and an

      * object, <code>YY</code>, then a subsequent call to

      * <code>ORB.resolve_initial_references( "Y" )</code> will

      * return object <code>YY</code>.

      *

      * @param id The ID by which the initial reference will be known.

      * @param obj The initial reference itself.

      * @throws InvalidName if this operation is called with an empty string id

      *     or this operation is called with an id that is already registered,

      *     including the default names defined by OMG.

      * @throws BAD_PARAM if the obj parameter is null.

      */

     public void register_initial_reference(

         String id, org.omg.CORBA.Object obj ) throws InvalidName

     {

         CorbaServerRequestDispatcher insnd ;

         synchronized (this) {

             checkShutdownState();

         }

         if ((id == null) || (id.length() == 0))

             throw new InvalidName() ;

         synchronized (this) {

             checkShutdownState();

         }

         synchronized (resolverLock) {

             insnd = insNamingDelegate ;

             java.lang.Object obj2 = localResolver.resolve( id ) ;

             if (obj2 != null)

                 throw new InvalidName(id + " already registered") ;

             localResolver.register( id, ClosureFactory.makeConstant( obj )) ;

         }

         synchronized (this) {

             if (StubAdapter.isStub(obj))

                 // Make all remote object references available for INS.

                 requestDispatcherRegistry.registerServerRequestDispatcher(

                     insnd, id ) ;

         }

     }

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

  * The following methods (introduced in POA / CORBA2.1) deal with

  * shutdown / single threading.

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

     public void run()

     {

         synchronized (this) {

             checkShutdownState();

         }

         synchronized (runObj) {

             try {

                 runObj.wait();

             } catch ( InterruptedException ex ) {}

         }

     }

     public void shutdown(boolean wait_for_completion) {

         boolean wait = false;

         synchronized (this) {

             checkShutdownState();

             // This is to avoid deadlock: don't allow a thread that is

             // processing a request to call shutdown( true ), because

             // the shutdown would block waiting for the request to complete,

             // while the request would block waiting for shutdown to complete.

             if (wait_for_completion &&

                 isProcessingInvocation.get() == Boolean.TRUE) {

                 throw omgWrapper.shutdownWaitForCompletionDeadlock();

             }

             if (status == STATUS_SHUTTING_DOWN) {

                 if (wait_for_completion) {

                     wait = true;

                 } else {

                     return;

                 }

             }

             status = STATUS_SHUTTING_DOWN;

         }

         // Avoid more than one thread performing shutdown at a time.

         synchronized (shutdownObj) {

             // At this point, the ORB status is certainly STATUS_SHUTTING_DOWN.

             // If wait is true, another thread already called shutdown( true ),

             // and so we wait for completion

             if (wait) {

                 while (true) {

                     synchronized (this) {

                         if (status == STATUS_SHUTDOWN)

                             break;

                     }

                     try {

                         shutdownObj.wait();

                     } catch (InterruptedException exc) {

                         // NOP: just loop and wait until state is changed

                     }

                 }

             } else {

                 // perform the actual shutdown

                 shutdownServants(wait_for_completion);

                 if (wait_for_completion) {

                     synchronized ( waitForCompletionObj ) {

                         while (numInvocations > 0) {

                             try {

                                 waitForCompletionObj.wait();

                             } catch (InterruptedException ex) {}

                         }

                     }

                 }

                 synchronized (runObj) {

                     runObj.notifyAll();

                 }

                 status = STATUS_SHUTDOWN;

                 shutdownObj.notifyAll();

             }

         }

     }

     // Cause all ObjectAdapaterFactories to clean up all of their internal state, which

     // may include activated objects that have associated state and callbacks that must

     // complete in order to shutdown.  This will cause new request to be rejected.

     protected void shutdownServants(boolean wait_for_completion) {

         Set<ObjectAdapterFactory> oaset;

         synchronized (this) {

             oaset = new HashSet<>(requestDispatcherRegistry.getObjectAdapterFactories());

         }

         for (ObjectAdapterFactory oaf : oaset)

             oaf.shutdown(wait_for_completion);

     }

     // Note that the caller must hold the ORBImpl lock.

     public void checkShutdownState()

     {

         if (status == STATUS_DESTROYED) {

             throw wrapper.orbDestroyed() ;

         }

         if (status == STATUS_SHUTDOWN) {

             throw omgWrapper.badOperationAfterShutdown() ;

         }

     }

     public boolean isDuringDispatch()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         Boolean value = (Boolean)(isProcessingInvocation.get()) ;

         return value.booleanValue() ;

     }

     public void startingDispatch()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (invocationObj) {

             isProcessingInvocation.set(Boolean.TRUE);

             numInvocations++;

         }

     }

     public void finishedDispatch()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (invocationObj) {

             numInvocations--;

             isProcessingInvocation.set(false);

             if (numInvocations == 0) {

                 synchronized (waitForCompletionObj) {

                     waitForCompletionObj.notifyAll();

                 }

             } else if (numInvocations < 0) {

                 throw wrapper.numInvocationsAlreadyZero(

                     CompletionStatus.COMPLETED_YES);

             }

         }

     }

     /**

      *  formal/99-10-07 p 159: "If destroy is called on an ORB that has

      *  not been shut down, it will start the shutdown process and block until

      *  the ORB has shut down before it destroys the ORB."

      */

     public void destroy()

     {

         boolean shutdownFirst = false;

         synchronized (this) {

             shutdownFirst = (status == STATUS_OPERATING);

         }

         if (shutdownFirst) {

             shutdown(true);

         }

         synchronized (this) {

             if (status < STATUS_DESTROYED) {

                 getCorbaTransportManager().close();

                 getPIHandler().destroyInterceptors();

                 status = STATUS_DESTROYED;

             }

         }

         synchronized (threadPoolManagerAccessLock) {

             if (orbOwnsThreadPoolManager) {

                 try {

                     threadpoolMgr.close();

                     threadpoolMgr = null;

                 } catch (IOException exc) {

                     wrapper.ioExceptionOnClose(exc);

                 }

             }

         }

         try {

             monitoringManager.close();

             monitoringManager = null;

         } catch (IOException exc) {

             wrapper.ioExceptionOnClose(exc);

         }

         CachedCodeBase.cleanCache(this);

         try {

             pihandler.close();

         } catch (IOException exc) {

             wrapper.ioExceptionOnClose(exc);

         }

         super.destroy();

         badServerIdHandlerAccessLock = null;

         clientDelegateFactoryAccessorLock = null;

         corbaContactInfoListFactoryAccessLock = null;

         objectKeyFactoryAccessLock = null;

         legacyServerSocketManagerAccessLock = null;

         threadPoolManagerAccessLock = null;

         transportManager = null;

         legacyServerSocketManager = null;

         OAInvocationInfoStack  = null;

         clientInvocationInfoStack  = null;

         codeBaseIOR = null;

         dynamicRequests  = null;

         svResponseReceived  = null;

         runObj = null;

         shutdownObj = null;

         waitForCompletionObj = null;

         invocationObj = null;

         isProcessingInvocation = null;

         typeCodeForClassMap  = null;

         valueFactoryCache = null;

         orbVersionThreadLocal = null;

         requestDispatcherRegistry = null;

         copierManager = null;

         toaFactory = null;

         poaFactory = null;

         pihandler = null;

         configData = null;

         badServerIdHandler = null;

         clientDelegateFactory = null;

         corbaContactInfoListFactory = null;

         resolver = null;

         localResolver = null;

         insNamingDelegate = null;

         urlOperation = null;

         taggedComponentFactoryFinder = null;

         taggedProfileFactoryFinder = null;

         taggedProfileTemplateFactoryFinder = null;

         objectKeyFactory = null;

     }

     /**

      * Registers a value factory for a particular repository ID.

      *

      * @param repositoryID the repository ID.

      * @param factory the factory.

      * @return the previously registered factory for the given repository ID,

      * or null if no such factory was previously registered.

      * @exception org.omg.CORBA.BAD_PARAM if the registration fails.

      **/

     public synchronized ValueFactory register_value_factory(String repositoryID,

         ValueFactory factory)

     {

         checkShutdownState();

         if ((repositoryID == null) || (factory == null))

             throw omgWrapper.unableRegisterValueFactory() ;

         return (ValueFactory)valueFactoryCache.put(repositoryID, factory);

     }

     /**

      * Unregisters a value factory for a particular repository ID.

      *

      * @param repositoryID the repository ID.

      **/

     public synchronized void unregister_value_factory(String repositoryID)

     {

         checkShutdownState();

         if (valueFactoryCache.remove(repositoryID) == null)

             throw wrapper.nullParam() ;

     }

     /**

      * Finds and returns a value factory for the given repository ID.

      * The value factory returned was previously registered by a call to

      * {@link #register_value_factory} or is the default factory.

      *

      * @param repositoryID the repository ID.

      * @return the value factory.

      * @exception org.omg.CORBA.BAD_PARAM if unable to locate a factory.

      **/

     public synchronized ValueFactory lookup_value_factory(String repositoryID)

     {

         checkShutdownState();

         ValueFactory factory =

             (ValueFactory)valueFactoryCache.get(repositoryID);

         if (factory == null) {

             try {

                 factory = Utility.getFactory(null, null, null, repositoryID);

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

                 throw wrapper.unableFindValueFactory( ex ) ;

             }

         }

         return factory ;

     }

     public OAInvocationInfo peekInvocationInfo()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         StackImpl stack = (StackImpl)(OAInvocationInfoStack.get()) ;

         return (OAInvocationInfo)(stack.peek()) ;

     }

     public void pushInvocationInfo( OAInvocationInfo info )

     {

         synchronized (this) {

                 checkShutdownState();

         }

         StackImpl stack = (StackImpl)(OAInvocationInfoStack.get()) ;

         stack.push( info ) ;

     }

     public OAInvocationInfo popInvocationInfo()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         StackImpl stack = (StackImpl)(OAInvocationInfoStack.get()) ;

         return (OAInvocationInfo)(stack.pop()) ;

     }

     /**

      * The bad server id handler is used by the Locator to

      * send back the location of a persistant server to the client.

      */

     private Object badServerIdHandlerAccessLock = new Object();

     public void initBadServerIdHandler()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (badServerIdHandlerAccessLock) {

             Class cls = configData.getBadServerIdHandler() ;

             if (cls != null) {

                 try {

                     Class[] params = new Class[] { org.omg.CORBA.ORB.class };

                     java.lang.Object[] args = new java.lang.Object[]{this};

                     Constructor cons = cls.getConstructor(params);

                     badServerIdHandler =

                         (BadServerIdHandler) cons.newInstance(args);

                 } catch (Exception e) {

                     throw wrapper.errorInitBadserveridhandler( e ) ;

                 }

             }

         }

     }

     public void setBadServerIdHandler( BadServerIdHandler handler )

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (badServerIdHandlerAccessLock) {

             badServerIdHandler = handler;

         }

     }

     public void handleBadServerId( ObjectKey okey )

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (badServerIdHandlerAccessLock) {

             if (badServerIdHandler == null)

                 throw wrapper.badServerId() ;

             else

                 badServerIdHandler.handle( okey ) ;

         }

     }

     public synchronized org.omg.CORBA.Policy create_policy( int type,

         org.omg.CORBA.Any val ) throws org.omg.CORBA.PolicyError

     {

         checkShutdownState() ;

         return pihandler.create_policy( type, val ) ;

     }

     /** This is the implementation of the public API used to connect

      *  a servant-skeleton to the ORB.

      */

     public synchronized void connect(org.omg.CORBA.Object servant)

     {

         checkShutdownState();

         if (getTOAFactory() == null)

             throw wrapper.noToa() ;

         try {

             String codebase = javax.rmi.CORBA.Util.getCodebase( servant.getClass() ) ;

             getTOAFactory().getTOA( codebase ).connect( servant ) ;

         } catch ( Exception ex ) {

             throw wrapper.orbConnectError( ex ) ;

         }

     }

     public synchronized void disconnect(org.omg.CORBA.Object obj)

     {

         checkShutdownState();

         if (getTOAFactory() == null)

             throw wrapper.noToa() ;

         try {

             getTOAFactory().getTOA().disconnect( obj ) ;

         } catch ( Exception ex ) {

             throw wrapper.orbConnectError( ex ) ;

         }

     }

     public int getTransientServerId()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         if( configData.getORBServerIdPropertySpecified( ) ) {

             // ORBServerId is specified then use that value

             return configData.getPersistentServerId( );

         }

         return transientServerId;

     }

     public RequestDispatcherRegistry getRequestDispatcherRegistry()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         return requestDispatcherRegistry;

     }

     public ServiceContextRegistry getServiceContextRegistry()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         return serviceContextRegistry ;

     }

     // XXX All of the isLocalXXX checking needs to be revisited.

     // First of all, all three of these methods are called from

     // only one place in impl.ior.IORImpl.  Second, we have problems

     // both with multi-homed hosts and with multi-profile IORs.

     // A possible strategy: like the LocalClientRequestDispatcher, we need

     // to determine this more abstractly at the ContactInfo level.

     // This level should probably just get the CorbaContactInfoList from

     // the IOR, then iterator over ContactInfo.  If any ContactInfo is

     // local, the IOR is local, and we can pick one to create the

     // LocalClientRequestDispatcher as well.  Bottom line: this code needs to move.

     // XXX What about multi-homed host?

     public boolean isLocalHost( String hostName )

     {

         synchronized (this) {

                 checkShutdownState();

         }

         return hostName.equals( configData.getORBServerHost() ) ||

             hostName.equals( getLocalHostName() ) ;

     }

     public boolean isLocalServerId( int subcontractId, int serverId )

     {

         synchronized (this) {

                 checkShutdownState();

         }

         if ((subcontractId < ORBConstants.FIRST_POA_SCID) ||

             (subcontractId > ORBConstants.MAX_POA_SCID))

             return serverId == getTransientServerId( ) ;

         // XXX isTransient info should be stored in subcontract registry

         if (ORBConstants.isTransient( subcontractId ))

             return (serverId == getTransientServerId()) ;

         else if (configData.getPersistentServerIdInitialized())

             return (serverId == configData.getPersistentServerId()) ;

         else

             return false ;

     }

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

      *  The following public methods are for ORB shutdown.

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

     private String getHostName(String host)

         throws java.net.UnknownHostException

     {

         return InetAddress.getByName( host ).getHostAddress();

     }

     /* keeping a copy of the getLocalHostName so that it can only be called

      * internally and the unauthorized clients cannot have access to the

      * localHost information, originally, the above code was calling

      * getLocalHostName from Connection.java.  If the hostname is cached in

      * Connection.java, then

      * it is a security hole, since any unauthorized client has access to

      * the host information.  With this change it is used internally so the

      * security problem is resolved.  Also in Connection.java, the

      * getLocalHost() implementation has changed to always call the

      * InetAddress.getLocalHost().getHostAddress()

      * The above mentioned method has been removed from the connection class

      */

     private static String localHostString = null;

     private synchronized String getLocalHostName()

     {

         if (localHostString == null) {

             try {

                 localHostString = InetAddress.getLocalHost().getHostAddress();

             } catch (Exception ex) {

                 throw wrapper.getLocalHostFailed( ex ) ;

             }

         }

         return localHostString ;

     }

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

  *  The following public methods are for ORB shutdown.

  *

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

     /** This method always returns false because the ORB never needs the

      *  main thread to do work.

      */

     public synchronized boolean work_pending()

     {

         checkShutdownState();

         throw wrapper.genericNoImpl() ;

     }

     /** This method does nothing. It is not required by the spec to do anything!

      */

     public synchronized void perform_work()

     {

         checkShutdownState();

         throw wrapper.genericNoImpl() ;

     }

     public synchronized void set_delegate(java.lang.Object servant){

         checkShutdownState();

         POAFactory poaFactory = getPOAFactory() ;

         if (poaFactory != null)

             ((org.omg.PortableServer.Servant)servant)

                 ._set_delegate( poaFactory.getDelegateImpl() ) ;

         else

             throw wrapper.noPoa() ;

     }

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

     //

     // pept.broker.Broker

     //

     public ClientInvocationInfo createOrIncrementInvocationInfo()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         StackImpl invocationInfoStack =

             (StackImpl) clientInvocationInfoStack.get();

         ClientInvocationInfo clientInvocationInfo = null;

         if (!invocationInfoStack.empty()) {

             clientInvocationInfo =

                 (ClientInvocationInfo) invocationInfoStack.peek();

         }

         if ((clientInvocationInfo == null) ||

             (!clientInvocationInfo.isRetryInvocation()))

         {

             // This is a new call - not a retry.

             clientInvocationInfo = new CorbaInvocationInfo(this);

             startingDispatch();

             invocationInfoStack.push(clientInvocationInfo);

         }

         // Reset retry so recursive calls will get a new info object.

         clientInvocationInfo.setIsRetryInvocation(false);

         clientInvocationInfo.incrementEntryCount();

         return clientInvocationInfo;

     }

     public void releaseOrDecrementInvocationInfo()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         int entryCount = -1;

         ClientInvocationInfo clientInvocationInfo = null;

         StackImpl invocationInfoStack =

             (StackImpl)clientInvocationInfoStack.get();

         if (!invocationInfoStack.empty()) {

             clientInvocationInfo =

                 (ClientInvocationInfo)invocationInfoStack.peek();

         } else {

             throw wrapper.invocationInfoStackEmpty() ;

         }

         clientInvocationInfo.decrementEntryCount();

         entryCount = clientInvocationInfo.getEntryCount();

         if (clientInvocationInfo.getEntryCount() == 0) {

             // 6763340: don't pop if this is a retry!

             if (!clientInvocationInfo.isRetryInvocation()) {

                 invocationInfoStack.pop();

             }

             finishedDispatch();

         }

     }

     public ClientInvocationInfo getInvocationInfo()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         StackImpl invocationInfoStack =

             (StackImpl) clientInvocationInfoStack.get();

         return (ClientInvocationInfo) invocationInfoStack.peek();

     }

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

     //

     //

     //

     private Object clientDelegateFactoryAccessorLock = new Object();

     public void setClientDelegateFactory( ClientDelegateFactory factory )

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (clientDelegateFactoryAccessorLock) {

             clientDelegateFactory = factory ;

         }

     }

     public ClientDelegateFactory getClientDelegateFactory()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (clientDelegateFactoryAccessorLock) {

             return clientDelegateFactory ;

         }

     }

     private Object corbaContactInfoListFactoryAccessLock = new Object();

     public void setCorbaContactInfoListFactory( CorbaContactInfoListFactory factory )

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (corbaContactInfoListFactoryAccessLock) {

             corbaContactInfoListFactory = factory ;

         }

     }

     public synchronized CorbaContactInfoListFactory getCorbaContactInfoListFactory()

     {

         checkShutdownState();

         return corbaContactInfoListFactory ;

     }

     /** Set the resolver used in this ORB.  This resolver will be used for list_initial_services

      * and resolve_initial_references.

      */

     public void setResolver( Resolver resolver )

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (resolverLock) {

             this.resolver = resolver ;

         }

     }

     /** Get the resolver used in this ORB.  This resolver will be used for list_initial_services

      * and resolve_initial_references.

      */

     public Resolver getResolver()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (resolverLock) {

             return resolver ;

         }

     }

     /** Set the LocalResolver used in this ORB.  This LocalResolver is used for

      * register_initial_reference only.

      */

     public void setLocalResolver( LocalResolver resolver )

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (resolverLock) {

             this.localResolver = resolver ;

         }

     }

     /** Get the LocalResolver used in this ORB.  This LocalResolver is used for

      * register_initial_reference only.

      */

     public LocalResolver getLocalResolver()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (resolverLock) {

             return localResolver ;

         }

     }

     /** Set the operation used in string_to_object calls.  The Operation must expect a

      * String and return an org.omg.CORBA.Object.

      */

     public void setURLOperation( Operation stringToObject )

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (urlOperationLock) {

             urlOperation = stringToObject ;

         }

     }

     /** Get the operation used in string_to_object calls.  The Operation must expect a

      * String and return an org.omg.CORBA.Object.

      */

     public Operation getURLOperation()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (urlOperationLock) {

             return urlOperation ;

         }

     }

     public void setINSDelegate( CorbaServerRequestDispatcher sdel )

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (resolverLock) {

             insNamingDelegate = sdel ;

         }

     }

     public TaggedComponentFactoryFinder getTaggedComponentFactoryFinder()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         return taggedComponentFactoryFinder ;

     }

     public IdentifiableFactoryFinder getTaggedProfileFactoryFinder()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         return taggedProfileFactoryFinder ;

     }

     public IdentifiableFactoryFinder getTaggedProfileTemplateFactoryFinder()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         return taggedProfileTemplateFactoryFinder ;

     }

     private Object objectKeyFactoryAccessLock = new Object();

     public ObjectKeyFactory getObjectKeyFactory()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (objectKeyFactoryAccessLock) {

             return objectKeyFactory ;

         }

     }

     public void setObjectKeyFactory( ObjectKeyFactory factory )

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (objectKeyFactoryAccessLock) {

             objectKeyFactory = factory ;

         }

     }

     private Object transportManagerAccessorLock = new Object();

     public TransportManager getTransportManager()

     {

         synchronized (transportManagerAccessorLock) {

             if (transportManager == null) {

                 transportManager = new CorbaTransportManagerImpl(this);

             }

             return transportManager;

         }

     }

     public CorbaTransportManager getCorbaTransportManager()

     {

         return (CorbaTransportManager) getTransportManager();

     }

     private Object legacyServerSocketManagerAccessLock = new Object();

     public LegacyServerSocketManager getLegacyServerSocketManager()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (legacyServerSocketManagerAccessLock) {

             if (legacyServerSocketManager == null) {

                 legacyServerSocketManager = new LegacyServerSocketManagerImpl(this);

             }

             return legacyServerSocketManager;

         }

     }

     private Object threadPoolManagerAccessLock = new Object();

     public void setThreadPoolManager(ThreadPoolManager mgr)

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (threadPoolManagerAccessLock) {

             threadpoolMgr = mgr;

         }

     }

     public ThreadPoolManager getThreadPoolManager()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         synchronized (threadPoolManagerAccessLock) {

             if (threadpoolMgr == null) {

                 threadpoolMgr = new ThreadPoolManagerImpl();

                 orbOwnsThreadPoolManager = true;

             }

             return threadpoolMgr;

         }

     }

     public CopierManager getCopierManager()

     {

         synchronized (this) {

                 checkShutdownState();

         }

         return copierManager ;

     }

 } // Class ORBImpl

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

 /// Helper class for a Synchronization Variable

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

 class SynchVariable

 {

     // Synchronization Variable

     public boolean _flag;

     // Constructor

     SynchVariable()

     {

         _flag = false;

     }

     // set Flag to true

     public void set()

     {

         _flag = true;

     }

         // get value

     public boolean value()

     {

         return _flag;

     }

     // reset Flag to true

     public void reset()

     {

         _flag = false;

     }

 }

 // End of file.