jdk8-mips64-public/corba: src/share/classes/com/sun/corba/se/impl/orb/ORBImpl.java@bfd167e38830 (annotated)

src/share/classes/com/sun/corba/se/impl/orb/ORBImpl.java@bfd167e38830 (annotated)

src/share/classes/com/sun/corba/se/impl/orb/ORBImpl.java

Mon, 28 May 2018 10:29:43 +0800

author: aoqi
date: Mon, 28 May 2018 10:29:43 +0800
changeset 1655: bfd167e38830
parent 1618: 4145ba26d9ff
parent 748: 6845b95cba6b
permissions: -rw-r--r--

Merge

 /*
  * Copyright (c) 2002, 2017, 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.util.Set;
 import java.util.HashSet;
 import java.util.Properties;
 import java.util.Vector;
 import java.util.Hashtable;
 import java.util.Map;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.WeakHashMap;
 import java.net.InetAddress;
 import java.security.PrivilegedAction;
 import java.security.Security;
 import java.security.AccessController;
 import javax.rmi.CORBA.ValueHandler;
 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.portable.ValueFactory;
 import org.omg.CORBA.ORBPackage.InvalidName;
 import com.sun.org.omg.SendingContext.CodeBase;
 import com.sun.corba.se.pept.protocol.ClientInvocationInfo;
 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.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.PIHandler;
 import com.sun.corba.se.spi.resolver.Resolver;
 import com.sun.corba.se.spi.resolver.LocalResolver;
 import com.sun.corba.se.spi.transport.CorbaContactInfoListFactory;
 import com.sun.corba.se.spi.transport.CorbaTransportManager;
 import com.sun.corba.se.spi.ior.IORTypeCheckRegistry;
 import com.sun.corba.se.spi.legacy.connection.LegacyServerSocketManager;
 import com.sun.corba.se.spi.logging.CORBALogDomains;
 import com.sun.corba.se.spi.copyobject.CopierManager;
 import com.sun.corba.se.spi.presentation.rmi.StubAdapter;
 import com.sun.corba.se.spi.servicecontext.ServiceContextRegistry;
 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.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.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.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.ior.IORTypeCheckRegistryImpl;
 /**
  * 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 ;
     private IORTypeCheckRegistry iorTypeCheckRegistry;
     // 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 static final String IORTYPECHECKREGISTRY_FILTER_PROPNAME = "com.sun.CORBA.ORBIorTypeCheckRegistryFilter";
     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 ) ;
     }
     private void initIORTypeCheckRegistry() {
         String filterProps = AccessController
                 .doPrivileged(new PrivilegedAction<String>() {
                     public String run() {
                         String props = System
                                 .getProperty(IORTYPECHECKREGISTRY_FILTER_PROPNAME);
                         if (props == null) {
                             props = Security
                                     .getProperty(IORTYPECHECKREGISTRY_FILTER_PROPNAME);
                         }
                         return props;
                     }
                 });
         if (filterProps != null) {
             try {
                 iorTypeCheckRegistry = new IORTypeCheckRegistryImpl(filterProps, this);
             } catch (Exception ex) {
                 throw wrapper.bootstrapException(ex);
             }
             if (this.orbInitDebugFlag) {
                 dprint(".initIORTypeCheckRegistry, IORTypeCheckRegistryImpl created for properties == "
                         + filterProps);
             }
         } else {
             if (this.orbInitDebugFlag) {
                 dprint(".initIORTypeCheckRegistry, IORTypeCheckRegistryImpl NOT created for properties == ");
             }
         }
     }
     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();
         initIORTypeCheckRegistry();
     }
     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 ;
     }
     @Override
     public void validateIORClass(String iorClassName) {
         if (iorTypeCheckRegistry != null) {
             if (!iorTypeCheckRegistry.isValidIORType(iorClassName)) {
                 throw ORBUtilSystemException.get( this,
                         CORBALogDomains.OA_IOR ).badStringifiedIor();
             }
         }
     }
 } // 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.

Mercurial > jdk8-mips64-public > corba / annotate

src/share/classes/com/sun/corba/se/impl/orb/ORBImpl.java@bfd167e38830 (annotated)

src/share/classes/com/sun/corba/se/impl/orb/ORBImpl.java