/*

 * 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 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(" ");

        }

    }

    // 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();