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

 /*

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

 import java.util.*;

 import java.io.IOException;

 import org.omg.CORBA.Any;

 import org.omg.CORBA.BAD_PARAM;

 import org.omg.CORBA.BAD_POLICY;

 import org.omg.CORBA.BAD_INV_ORDER;

 import org.omg.CORBA.COMM_FAILURE;

 import org.omg.CORBA.CompletionStatus;

 import org.omg.CORBA.INTERNAL;

 import org.omg.CORBA.NVList;

 import org.omg.CORBA.OBJECT_NOT_EXIST;

 import org.omg.CORBA.ORBPackage.InvalidName;

 import org.omg.CORBA.SystemException;

 import org.omg.CORBA.UserException;

 import org.omg.CORBA.UNKNOWN;

 import org.omg.CORBA.portable.ApplicationException;

 import org.omg.CORBA.portable.RemarshalException;

 import org.omg.IOP.CodecFactory;

 import org.omg.PortableInterceptor.ForwardRequest;

 import org.omg.PortableInterceptor.Current;

 import org.omg.PortableInterceptor.Interceptor;

 import org.omg.PortableInterceptor.LOCATION_FORWARD;

 import org.omg.PortableInterceptor.ORBInitializer;

 import org.omg.PortableInterceptor.ORBInitInfo;

 import org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateName;

 import org.omg.PortableInterceptor.SUCCESSFUL;

 import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;

 import org.omg.PortableInterceptor.TRANSPORT_RETRY;

 import org.omg.PortableInterceptor.USER_EXCEPTION;

 import org.omg.PortableInterceptor.PolicyFactory;

 import org.omg.PortableInterceptor.ObjectReferenceTemplate ;

 import com.sun.corba.se.pept.encoding.OutputObject;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 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.protocol.giopmsgheaders.ReplyMessage;

 /**

  * Provides portable interceptor functionality.

  */

 public class PIHandlerImpl implements PIHandler

 {

     // REVISIT - delete these after framework merging.

     boolean printPushPopEnabled = false;

     int pushLevel = 0;

     private void printPush()

     {

         if (! printPushPopEnabled) return;

         printSpaces(pushLevel);

         pushLevel++;

         System.out.println("PUSH");

     }

     private void printPop()

     {

         if (! printPushPopEnabled) return;

         pushLevel--;

         printSpaces(pushLevel);

         System.out.println("POP");

     }

     private void printSpaces(int n)

     {

         for (int i = 0; i < n; i++) {

             System.out.print(" ");

         }

     }

     private ORB orb ;

     InterceptorsSystemException wrapper ;

     ORBUtilSystemException orbutilWrapper ;

     OMGSystemException omgWrapper ;

     // A unique id used in ServerRequestInfo.

     // This does not correspond to the GIOP request id.

     private int serverRequestIdCounter = 0;

     // Stores the codec factory for producing codecs

     CodecFactory codecFactory = null;

     // The arguments passed to the application's main method.  May be null.

     // This is used for ORBInitializers and set from set_parameters.

     String[] arguments = null;

     // The list of portable interceptors, organized by type:

     private InterceptorList interceptorList;

     // Cached information for optimization - do we have any interceptors

     // registered of the given types?  Set during ORB initialization.

     private boolean hasIORInterceptors;

     private boolean hasClientInterceptors;  // temp always true

     private boolean hasServerInterceptors;

     // The class responsible for invoking interceptors

     private InterceptorInvoker interceptorInvoker;

     // There will be one PICurrent instantiated for every ORB.

     private PICurrent current;

     // This table contains a list of PolicyFactories registered using

     // ORBInitInfo.registerPolicyFactory() method.

     // Key for the table is PolicyType which is an Integer

     // Value is PolicyFactory.

     private HashMap policyFactoryTable;

     // Table to convert from a ReplyMessage.? to a PI replyStatus short.

     // Note that this table relies on the order and constants of

     // ReplyMessage not to change.

     private final static short REPLY_MESSAGE_TO_PI_REPLY_STATUS[] = {

         SUCCESSFUL.value,       // = ReplyMessage.NO_EXCEPTION

         USER_EXCEPTION.value,   // = ReplyMessage.USER_EXCEPTION

         SYSTEM_EXCEPTION.value, // = ReplyMessage.SYSTEM_EXCEPTION

         LOCATION_FORWARD.value, // = ReplyMessage.LOCATION_FORWARD

         LOCATION_FORWARD.value, // = ReplyMessage.LOCATION_FORWARD_PERM

         TRANSPORT_RETRY.value   // = ReplyMessage.NEEDS_ADDRESSING_MODE

     };

     // ThreadLocal containing a stack to store client request info objects

     // and a disable count.

     private ThreadLocal threadLocalClientRequestInfoStack =

         new ThreadLocal() {

             protected Object initialValue() {

                 return new RequestInfoStack();

             }

         };

     // ThreadLocal containing the current server request info object.

     private ThreadLocal threadLocalServerRequestInfoStack =

         new ThreadLocal() {

             protected Object initialValue() {

                 return new RequestInfoStack();

             }

         };

     // Class to contain all ThreadLocal data for ClientRequestInfo

     // maintenance.

     //

     // We use an ArrayList instead since it is not thread-safe.

     // RequestInfoStack is used quite frequently.

     private final class RequestInfoStack extends Stack {

         // Number of times a request has been made to disable interceptors.

         // When this reaches 0, interception hooks are disabled.  Any higher

         // value indicates they are enabled.

         // NOTE: The is only currently used on the client side.

         public int disableCount = 0;

     }

     public PIHandlerImpl( ORB orb, String[] args ) {

         this.orb = orb ;

         wrapper = InterceptorsSystemException.get( orb,

             CORBALogDomains.RPC_PROTOCOL ) ;

         orbutilWrapper = ORBUtilSystemException.get( orb,

             CORBALogDomains.RPC_PROTOCOL ) ;

         omgWrapper = OMGSystemException.get( orb,

             CORBALogDomains.RPC_PROTOCOL ) ;

         arguments = args ;

         // Create codec factory:

         codecFactory = new CodecFactoryImpl( orb );

         // Create new interceptor list:

         interceptorList = new InterceptorList( wrapper );

         // Create a new PICurrent.

         current = new PICurrent( orb );

         // Create new interceptor invoker, initially disabled:

         interceptorInvoker = new InterceptorInvoker( orb, interceptorList,

                                                      current );

         // Register the PI current and Codec factory objects

         orb.getLocalResolver().register( ORBConstants.PI_CURRENT_NAME,

             ClosureFactory.makeConstant( current ) ) ;

         orb.getLocalResolver().register( ORBConstants.CODEC_FACTORY_NAME,

             ClosureFactory.makeConstant( codecFactory ) ) ;

     }

     public void initialize() {

         // If we have any orb initializers, make use of them:

         if( orb.getORBData().getORBInitializers() != null ) {

             // Create the ORBInitInfo object to pass to ORB intializers:

             ORBInitInfoImpl orbInitInfo = createORBInitInfo();

             // Make sure get_slot and set_slot are not called from within

             // ORB initializers:

             current.setORBInitializing( true );

             // Call pre_init on all ORB initializers:

             preInitORBInitializers( orbInitInfo );

             // Call post_init on all ORB initializers:

             postInitORBInitializers( orbInitInfo );

             // Proprietary: sort interceptors:

             interceptorList.sortInterceptors();

             // Re-enable get_slot and set_slot to be called from within

             // ORB initializers:

             current.setORBInitializing( false );

             // Ensure nobody makes any more calls on this object.

             orbInitInfo.setStage( ORBInitInfoImpl.STAGE_CLOSED );

             // Set cached flags indicating whether we have interceptors

             // registered of a given type.

             hasIORInterceptors = interceptorList.hasInterceptorsOfType(

                 InterceptorList.INTERCEPTOR_TYPE_IOR );

             // XXX This must always be true, so that using the new generic

             // RPC framework can pass info between the PI stack and the

             // framework invocation stack.  Temporary until Harold fixes

             // this.  Note that this must never be true until after the

             // ORBInitializer instances complete executing.

             //hasClientInterceptors = interceptorList.hasInterceptorsOfType(

                 //InterceptorList.INTERCEPTOR_TYPE_CLIENT );

             hasClientInterceptors = true;

             hasServerInterceptors = interceptorList.hasInterceptorsOfType(

                 InterceptorList.INTERCEPTOR_TYPE_SERVER );

             // Enable interceptor invoker (not necessary if no interceptors

             // are registered).  This should be the last stage of ORB

             // initialization.

             interceptorInvoker.setEnabled( true );

         }

     }

     /**

      *  ptc/00-08-06 p 205: "When an application calls ORB::destroy, the ORB

      *  1) waits for all requests in progress to complete

      *  2) calls the Interceptor::destroy operation for each interceptor

      *  3) completes destruction of the ORB"

      *

      * This must be called at the end of ORB.destroy.  Note that this is not

      * part of the PIHandler interface, since ORBImpl implements the ORB interface.

      */

     public void destroyInterceptors() {

         interceptorList.destroyAll();

     }

     public void objectAdapterCreated( ObjectAdapter oa )

     {

         if (!hasIORInterceptors)

             return ;

         interceptorInvoker.objectAdapterCreated( oa ) ;

     }

     public void adapterManagerStateChanged( int managerId,

         short newState )

     {

         if (!hasIORInterceptors)

             return ;

         interceptorInvoker.adapterManagerStateChanged( managerId, newState ) ;

     }

     public void adapterStateChanged( ObjectReferenceTemplate[]

         templates, short newState )

     {

         if (!hasIORInterceptors)

             return ;

         interceptorInvoker.adapterStateChanged( templates, newState ) ;

     }

     /*

      *****************

      * Client PI hooks

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

     public void disableInterceptorsThisThread() {

         if( !hasClientInterceptors ) return;

         RequestInfoStack infoStack =

             (RequestInfoStack)threadLocalClientRequestInfoStack.get();

         infoStack.disableCount++;

     }

     public void enableInterceptorsThisThread() {

         if( !hasClientInterceptors ) return;

         RequestInfoStack infoStack =

             (RequestInfoStack)threadLocalClientRequestInfoStack.get();

         infoStack.disableCount--;

     }

     public void invokeClientPIStartingPoint()

         throws RemarshalException

     {

         if( !hasClientInterceptors ) return;

         if( !isClientPIEnabledForThisThread() ) return;

         // Invoke the starting interception points and record exception

         // and reply status info in the info object:

         ClientRequestInfoImpl info = peekClientRequestInfoImplStack();

         interceptorInvoker.invokeClientInterceptorStartingPoint( info );

         // Check reply status.  If we will not have another chance later

         // to invoke the client ending points, do it now.

         short replyStatus = info.getReplyStatus();

         if( (replyStatus == SYSTEM_EXCEPTION.value) ||

             (replyStatus == LOCATION_FORWARD.value) )

         {

             // Note: Transport retry cannot happen here since this happens

             // before the request hits the wire.

             Exception exception = invokeClientPIEndingPoint(

                 convertPIReplyStatusToReplyMessage( replyStatus ),

                 info.getException() );

             if( exception == null ) {

                 // Do not throw anything.  Otherwise, it must be a

                 // SystemException, UserException or RemarshalException.

             } if( exception instanceof SystemException ) {

                 throw (SystemException)exception;

             } else if( exception instanceof RemarshalException ) {

                 throw (RemarshalException)exception;

             } else if( (exception instanceof UserException) ||

                      (exception instanceof ApplicationException) ) {

                 // It should not be possible for an interceptor to throw

                 // a UserException.  By asserting instead of throwing the

                 // UserException, we need not declare anything but

                 // RemarshalException in the throws clause.

                 throw wrapper.exceptionInvalid() ;

             }

         }

         else if( replyStatus != ClientRequestInfoImpl.UNINITIALIZED ) {

             throw wrapper.replyStatusNotInit() ;

         }

     }

     // Needed when an error forces a retry AFTER initiateClientPIRequest

     // but BEFORE invokeClientPIStartingPoint.

     public Exception makeCompletedClientRequest( int replyStatus,

         Exception exception ) {

         // 6763340

         return handleClientPIEndingPoint( replyStatus, exception, false ) ;

     }

     public Exception invokeClientPIEndingPoint( int replyStatus,

         Exception exception ) {

         // 6763340

         return handleClientPIEndingPoint( replyStatus, exception, true ) ;

     }

     public Exception handleClientPIEndingPoint(

         int replyStatus, Exception exception, boolean invokeEndingPoint ) {

         if( !hasClientInterceptors ) return exception;

         if( !isClientPIEnabledForThisThread() ) return exception;

         // Translate ReplyMessage.replyStatus into PI replyStatus:

         // Note: this is also an assertion to make sure a valid replyStatus

         // is passed in (IndexOutOfBoundsException will be thrown otherwise)

         short piReplyStatus = REPLY_MESSAGE_TO_PI_REPLY_STATUS[replyStatus];

         // Invoke the ending interception points and record exception

         // and reply status info in the info object:

         ClientRequestInfoImpl info = peekClientRequestInfoImplStack();

         info.setReplyStatus( piReplyStatus );

         info.setException( exception );

         if (invokeEndingPoint) {

             // 6763340

             interceptorInvoker.invokeClientInterceptorEndingPoint( info );

             piReplyStatus = info.getReplyStatus();

         }

         // Check reply status:

         if( (piReplyStatus == LOCATION_FORWARD.value) ||

             (piReplyStatus == TRANSPORT_RETRY.value) ) {

             // If this is a forward or a retry, reset and reuse

             // info object:

             info.reset();

             // fix for 6763340:

             if (invokeEndingPoint) {

                 info.setRetryRequest( RetryType.AFTER_RESPONSE ) ;

             } else {

                 info.setRetryRequest( RetryType.BEFORE_RESPONSE ) ;

             }

             // ... and return a RemarshalException so the orb internals know

             exception = new RemarshalException();

         } else if( (piReplyStatus == SYSTEM_EXCEPTION.value) ||

                  (piReplyStatus == USER_EXCEPTION.value) ) {

             exception = info.getException();

         }

         return exception;

     }

     public void initiateClientPIRequest( boolean diiRequest ) {

         if( !hasClientInterceptors ) return;

         if( !isClientPIEnabledForThisThread() ) return;

         // Get the most recent info object from the thread local

         // ClientRequestInfoImpl stack:

         RequestInfoStack infoStack =

             (RequestInfoStack)threadLocalClientRequestInfoStack.get();

         ClientRequestInfoImpl info = null;

         if (!infoStack.empty() ) {

             info = (ClientRequestInfoImpl)infoStack.peek();

         }

         if (!diiRequest && (info != null) && info.isDIIInitiate() ) {

             // In RequestImpl.doInvocation we already called

             // initiateClientPIRequest( true ), so ignore this initiate.

             info.setDIIInitiate( false );

         } else {

             // If there is no info object or if we are not retrying a request,

             // push a new ClientRequestInfoImpl on the stack:

             // 6763340: don't push unless this is not a retry

             if( (info == null) || !info.getRetryRequest().isRetry() ) {

                 info = new ClientRequestInfoImpl( orb );

                 infoStack.push( info );

                 printPush();

                 // Note: the entry count is automatically initialized to 0.

             }

             // Reset the retry request flag so that recursive calls will

             // push a new info object, and bump up entry count so we know

             // when to pop this info object:

             info.setRetryRequest( RetryType.NONE );

             info.incrementEntryCount();

             // KMC 6763340: I don't know why this wasn't set earlier,

             // but we do not want a retry to pick up the previous

             // reply status, so clear it here.  Most likely a new

             // info was pushed before, so that this was not a problem.

             info.setReplyStatus( RequestInfoImpl.UNINITIALIZED ) ;

             // If this is a DII request, make sure we ignore the next initiate.

             if( diiRequest ) {

                 info.setDIIInitiate( true );

             }

         }

     }

     public void cleanupClientPIRequest() {

         if( !hasClientInterceptors ) return;

         if( !isClientPIEnabledForThisThread() ) return;

         ClientRequestInfoImpl info = peekClientRequestInfoImplStack();

         RetryType rt = info.getRetryRequest() ;

         // fix for 6763340

         if (!rt.equals( RetryType.BEFORE_RESPONSE )) {

             // If the replyStatus has not yet been set, this is an indication

             // that the ORB threw an exception before we had a chance to

             // invoke the client interceptor ending points.

             //

             // _REVISIT_ We cannot handle any exceptions or ForwardRequests

             // flagged by the ending points here because there is no way

             // to gracefully handle this in any of the calling code.

             // This is a rare corner case, so we will ignore this for now.

             short replyStatus = info.getReplyStatus();

             if (replyStatus == info.UNINITIALIZED ) {

                 invokeClientPIEndingPoint( ReplyMessage.SYSTEM_EXCEPTION,

                     wrapper.unknownRequestInvoke(

                         CompletionStatus.COMPLETED_MAYBE ) ) ;

             }

         }

         // Decrement entry count, and if it is zero, pop it from the stack.

         info.decrementEntryCount();

         // fix for 6763340, and probably other cases (non-recursive retry)

         if (info.getEntryCount() == 0 && !info.getRetryRequest().isRetry()) {

             // RequestInfoStack<ClientRequestInfoImpl> infoStack =

             //     threadLocalClientRequestInfoStack.get();

             RequestInfoStack infoStack =

                 (RequestInfoStack)threadLocalClientRequestInfoStack.get();

             infoStack.pop();

             printPop();

         }

     }

     public void setClientPIInfo(CorbaMessageMediator messageMediator)

     {

         if( !hasClientInterceptors ) return;

         if( !isClientPIEnabledForThisThread() ) return;

         peekClientRequestInfoImplStack().setInfo(messageMediator);

     }

     public void setClientPIInfo( RequestImpl requestImpl ) {

         if( !hasClientInterceptors ) return;

         if( !isClientPIEnabledForThisThread() ) return;

         peekClientRequestInfoImplStack().setDIIRequest( requestImpl );

     }

     /*

      *****************

      * Server PI hooks

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

     public void invokeServerPIStartingPoint()

     {

         if( !hasServerInterceptors ) return;

         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();

         interceptorInvoker.invokeServerInterceptorStartingPoint( info );

         // Handle SystemException or ForwardRequest:

         serverPIHandleExceptions( info );

     }

     public void invokeServerPIIntermediatePoint()

     {

         if( !hasServerInterceptors ) return;

         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();

         interceptorInvoker.invokeServerInterceptorIntermediatePoint( info );

         // Clear servant from info object so that the user has control over

         // its lifetime:

         info.releaseServant();

         // Handle SystemException or ForwardRequest:

         serverPIHandleExceptions( info );

     }

     public void invokeServerPIEndingPoint( ReplyMessage replyMessage )

     {

         if( !hasServerInterceptors ) return;

         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();

         // REVISIT: This needs to be done "early" for the following workaround.

         info.setReplyMessage( replyMessage );

         // REVISIT: This was done inside of invokeServerInterceptorEndingPoint

         // but needs to be here for now.  See comment in that method for why.

         info.setCurrentExecutionPoint( info.EXECUTION_POINT_ENDING );

         // It is possible we might have entered this method more than

         // once (e.g. if an ending point threw a SystemException, then

         // a new ServerResponseImpl is created).

         if( !info.getAlreadyExecuted() ) {

             int replyStatus = replyMessage.getReplyStatus();

             // Translate ReplyMessage.replyStatus into PI replyStatus:

             // Note: this is also an assertion to make sure a valid

             // replyStatus is passed in (IndexOutOfBoundsException will be

             // thrown otherwise)

             short piReplyStatus =

                 REPLY_MESSAGE_TO_PI_REPLY_STATUS[replyStatus];

             // Make forwarded IOR available to interceptors, if applicable:

             if( ( piReplyStatus == LOCATION_FORWARD.value ) ||

                 ( piReplyStatus == TRANSPORT_RETRY.value ) )

             {

                 info.setForwardRequest( replyMessage.getIOR() );

             }

             // REVISIT: Do early above for now.

             // Make reply message available to interceptors:

             //info.setReplyMessage( replyMessage );

             // Remember exception so we can tell if an interceptor changed it.

             Exception prevException = info.getException();

             // _REVISIT_ We do not have access to the User Exception at

             // this point, so treat it as an UNKNOWN for now.

             // Note that if this is a DSI call, we do have the user exception.

             if( !info.isDynamic() &&

                 (piReplyStatus == USER_EXCEPTION.value) )

             {

                 info.setException( omgWrapper.unknownUserException(

                     CompletionStatus.COMPLETED_MAYBE ) ) ;

             }

             // Invoke the ending interception points:

             info.setReplyStatus( piReplyStatus );

             interceptorInvoker.invokeServerInterceptorEndingPoint( info );

             short newPIReplyStatus = info.getReplyStatus();

             Exception newException = info.getException();

             // Check reply status.  If an interceptor threw a SystemException

             // and it is different than the one that we came in with,

             // rethrow it so the proper response can be constructed:

             if( ( newPIReplyStatus == SYSTEM_EXCEPTION.value ) &&

                 ( newException != prevException ) )

             {

                 throw (SystemException)newException;

             }

             // If we are to forward the location:

             if( newPIReplyStatus == LOCATION_FORWARD.value ) {

                 if( piReplyStatus != LOCATION_FORWARD.value ) {

                     // Treat a ForwardRequest as a ForwardException.

                     IOR ior = info.getForwardRequestIOR();

                     throw new ForwardException( orb, ior ) ;

                 }

                 else if( info.isForwardRequestRaisedInEnding() ) {

                     // Treat a ForwardRequest by changing the IOR.

                     replyMessage.setIOR( info.getForwardRequestIOR() );

                 }

             }

         }

     }

     public void setServerPIInfo( Exception exception ) {

         if( !hasServerInterceptors ) return;

         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();

         info.setException( exception );

     }

     public void setServerPIInfo( NVList arguments )

     {

         if( !hasServerInterceptors ) return;

         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();

         info.setDSIArguments( arguments );

     }

     public void setServerPIExceptionInfo( Any exception )

     {

         if( !hasServerInterceptors ) return;

         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();

         info.setDSIException( exception );

     }

     public void setServerPIInfo( Any result )

     {

         if( !hasServerInterceptors ) return;

         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();

         info.setDSIResult( result );

     }

     public void initializeServerPIInfo( CorbaMessageMediator request,

         ObjectAdapter oa, byte[] objectId, ObjectKeyTemplate oktemp )

     {

         if( !hasServerInterceptors ) return;

         RequestInfoStack infoStack =

             (RequestInfoStack)threadLocalServerRequestInfoStack.get();

         ServerRequestInfoImpl info = new ServerRequestInfoImpl( orb );

         infoStack.push( info );

         printPush();

         // Notify request object that once response is constructed, make

         // sure we execute ending points.

         request.setExecutePIInResponseConstructor( true );

         info.setInfo( request, oa, objectId, oktemp );

     }

     public void setServerPIInfo( java.lang.Object servant,

                                           String targetMostDerivedInterface )

     {

         if( !hasServerInterceptors ) return;

         ServerRequestInfoImpl info = peekServerRequestInfoImplStack();

         info.setInfo( servant, targetMostDerivedInterface );

     }

     public void cleanupServerPIRequest() {

         if( !hasServerInterceptors ) return;

         RequestInfoStack infoStack =

             (RequestInfoStack)threadLocalServerRequestInfoStack.get();

         infoStack.pop();

         printPop();

     }

     /*

      **********************************************************************

      *  The following methods are private utility methods.

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

     /**

      * Handles exceptions for the starting and intermediate points for

      * server request interceptors.  This is common code that has been

      * factored out into this utility method.

      * <p>

      * This method will NOT work for ending points.

      */

     private void serverPIHandleExceptions( ServerRequestInfoImpl info )

     {

         int endingPointCall = info.getEndingPointCall();

         if(endingPointCall == ServerRequestInfoImpl.CALL_SEND_EXCEPTION) {

             // If a system exception was thrown, throw it to caller:

             throw (SystemException)info.getException();

         }

         else if( (endingPointCall == ServerRequestInfoImpl.CALL_SEND_OTHER) &&

                  (info.getForwardRequestException() != null) )

         {

             // If an interceptor throws a forward request, convert it

             // into a ForwardException for easier handling:

             IOR ior = info.getForwardRequestIOR();

             throw new ForwardException( orb, ior );

         }

     }

     /**

      * Utility method to convert a PI reply status short to a ReplyMessage

      * constant.  This is a reverse lookup on the table defined in

      * REPLY_MESSAGE_TO_PI_REPLY_STATUS.  The reverse lookup need not be

      * performed as quickly since it is only executed in exception

      * conditions.

      */

     private int convertPIReplyStatusToReplyMessage( short replyStatus ) {

         int result = 0;

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

             if( REPLY_MESSAGE_TO_PI_REPLY_STATUS[i] == replyStatus ) {

                 result = i;

                 break;

             }

         }

         return result;

     }

     /**

      * Convenience method to get the ClientRequestInfoImpl object off the

      * top of the ThreadLocal stack.  Throws an INTERNAL exception if

      * the Info stack is empty.

      */

     private ClientRequestInfoImpl peekClientRequestInfoImplStack() {

         RequestInfoStack infoStack =

             (RequestInfoStack)threadLocalClientRequestInfoStack.get();

         ClientRequestInfoImpl info = null;

         if( !infoStack.empty() ) {

             info = (ClientRequestInfoImpl)infoStack.peek();

         } else {

             throw wrapper.clientInfoStackNull() ;

         }

         return info;

     }

     /**

      * Convenience method to get the ServerRequestInfoImpl object off the

      * top of the ThreadLocal stack.  Returns null if there are none.

      */

     private ServerRequestInfoImpl peekServerRequestInfoImplStack() {

         RequestInfoStack infoStack =

             (RequestInfoStack)threadLocalServerRequestInfoStack.get();

         ServerRequestInfoImpl info = null;

         if( !infoStack.empty() ) {

             info = (ServerRequestInfoImpl)infoStack.peek();

         } else {

             throw wrapper.serverInfoStackNull() ;

         }

         return info;

     }

     /**

      * Convenience method to determine whether Client PI is enabled

      * for requests on this thread.

      */

     private boolean isClientPIEnabledForThisThread() {

         RequestInfoStack infoStack =

             (RequestInfoStack)threadLocalClientRequestInfoStack.get();

         return (infoStack.disableCount == 0);

     }

     /**

      * Call pre_init on all ORB initializers

      */

     private void preInitORBInitializers( ORBInitInfoImpl info ) {

         // Inform ORBInitInfo we are in pre_init stage

         info.setStage( ORBInitInfoImpl.STAGE_PRE_INIT );

         // Step through each initializer instantiation and call its

         // pre_init.  Ignore any exceptions.

         for( int i = 0; i < orb.getORBData().getORBInitializers().length;

             i++ ) {

             ORBInitializer init = orb.getORBData().getORBInitializers()[i];

             if( init != null ) {

                 try {

                     init.pre_init( info );

                 }

                 catch( Exception e ) {

                     // As per orbos/99-12-02, section 9.3.1.2, "If there are

                     // any exceptions, the ORB shall ignore them and proceed."

                 }

             }

         }

     }

     /**

      * Call post_init on all ORB initializers

      */

     private void postInitORBInitializers( ORBInitInfoImpl info ) {

         // Inform ORBInitInfo we are in post_init stage

         info.setStage( ORBInitInfoImpl.STAGE_POST_INIT );

         // Step through each initializer instantiation and call its post_init.

         // Ignore any exceptions.

         for( int i = 0; i < orb.getORBData().getORBInitializers().length;

             i++ ) {

             ORBInitializer init = orb.getORBData().getORBInitializers()[i];

             if( init != null ) {

                 try {

                     init.post_init( info );

                 }

                 catch( Exception e ) {

                     // As per orbos/99-12-02, section 9.3.1.2, "If there are

                     // any exceptions, the ORB shall ignore them and proceed."

                 }

             }

         }

     }

     /**

      * Creates the ORBInitInfo object to be passed to ORB intializers'

      * pre_init and post_init methods

      */

     private ORBInitInfoImpl createORBInitInfo() {

         ORBInitInfoImpl result = null;

         // arguments comes from set_parameters.  May be null.

         // _REVISIT_ The spec does not specify which ID this is to be.

         // We currently get this from the corba.ORB, which reads it from

         // the ORB_ID_PROPERTY property.

         String orbId = orb.getORBData().getORBId() ;

         result = new ORBInitInfoImpl( orb, arguments, orbId, codecFactory );

         return result;

     }

     /**

      * Called by ORBInitInfo when an interceptor needs to be registered.

      * The type is one of:

      * <ul>

      *   <li>INTERCEPTOR_TYPE_CLIENT - ClientRequestInterceptor

      *   <li>INTERCEPTOR_TYPE_SERVER - ServerRequestInterceptor

      *   <li>INTERCEPTOR_TYPE_IOR - IORInterceptor

      * </ul>

      *

      * @exception DuplicateName Thrown if an interceptor of the given

      *     name already exists for the given type.

      */

     public void register_interceptor( Interceptor interceptor, int type )

         throws DuplicateName

     {

         // We will assume interceptor is not null, since it is called

         // internally.

         if( (type >= InterceptorList.NUM_INTERCEPTOR_TYPES) || (type < 0) ) {

             throw wrapper.typeOutOfRange( new Integer( type ) ) ;

         }

         String interceptorName = interceptor.name();

         if( interceptorName == null ) {

             throw wrapper.nameNull() ;

         }

         // Register with interceptor list:

         interceptorList.register_interceptor( interceptor, type );

     }

     public Current getPICurrent( ) {

         return current;

     }

     /**

      * Called when an invalid null parameter was passed.  Throws a

      * BAD_PARAM with a minor code of 1

      */

     private void nullParam()

         throws BAD_PARAM

     {

         throw orbutilWrapper.nullParam() ;

     }

     /** This is the implementation of standard API defined in org.omg.CORBA.ORB

      *  class. This method finds the Policy Factory for the given Policy Type

      *  and instantiates the Policy object from the Factory. It will throw

      *  PolicyError exception, If the PolicyFactory for the given type is

      *  not registered.

      *  _REVISIT_, Once Policy Framework work is completed, Reorganize

      *  this method to com.sun.corba.se.spi.orb.ORB.

      */

     public org.omg.CORBA.Policy create_policy(int type, org.omg.CORBA.Any val)

         throws org.omg.CORBA.PolicyError

     {

         if( val == null ) {

             nullParam( );

         }

         if( policyFactoryTable == null ) {

             throw new org.omg.CORBA.PolicyError(

                 "There is no PolicyFactory Registered for type " + type,

                 BAD_POLICY.value );

         }

         PolicyFactory factory = (PolicyFactory)policyFactoryTable.get(

             new Integer(type) );

         if( factory == null ) {

             throw new org.omg.CORBA.PolicyError(

                 " Could Not Find PolicyFactory for the Type " + type,

                 BAD_POLICY.value);

         }

         org.omg.CORBA.Policy policy = factory.create_policy( type, val );

         return policy;

     }

     /** This method registers the Policy Factory in the policyFactoryTable,

      *  which is a HashMap. This method is made package private, because

      *  it is used internally by the  Interceptors.

      */

     public void registerPolicyFactory( int type, PolicyFactory factory ) {

         if( policyFactoryTable == null ) {

             policyFactoryTable = new HashMap();

         }

         Integer key = new Integer( type );

         java.lang.Object val = policyFactoryTable.get( key );

         if( val == null ) {

             policyFactoryTable.put( key, factory );

         }

         else {

             throw omgWrapper.policyFactoryRegFailed( new Integer( type ) ) ;

         }

     }

     public synchronized int allocateServerRequestId ()

     {

         return serverRequestIdCounter++;

     }

 }