impl/protocol/CorbaServerRequestDispatcherImpl.java

/*
 * Copyright (c) 1998, 2004, 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.
 */
/*
 * Licensed Materials - Property of IBM
 * RMI-IIOP v1.0
 * Copyright IBM Corp. 1998 1999  All Rights Reserved
 *
 */


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

import org.omg.PortableServer.Servant ;

import org.omg.CORBA.SystemException;
import org.omg.CORBA.INTERNAL;
import org.omg.CORBA.UNKNOWN;
import org.omg.CORBA.CompletionStatus;
import org.omg.CORBA.Any;

import org.omg.CORBA.portable.InvokeHandler;
import org.omg.CORBA.portable.InputStream;
import org.omg.CORBA.portable.OutputStream;
import org.omg.CORBA.portable.UnknownException;
import org.omg.CORBA.portable.ResponseHandler;

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

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

import com.sun.corba.se.spi.orb.ORB;
import com.sun.corba.se.spi.orb.ORBVersion;
import com.sun.corba.se.spi.orb.ORBVersionFactory;
import com.sun.corba.se.spi.ior.IOR ;
import com.sun.corba.se.spi.ior.ObjectKey;
import com.sun.corba.se.spi.ior.ObjectKeyTemplate;
import com.sun.corba.se.spi.ior.ObjectAdapterId;
import com.sun.corba.se.spi.oa.ObjectAdapterFactory;
import com.sun.corba.se.spi.oa.ObjectAdapter;
import com.sun.corba.se.spi.oa.OAInvocationInfo;
import com.sun.corba.se.spi.oa.OADestroyed;
import com.sun.corba.se.spi.oa.NullServant;
import com.sun.corba.se.spi.protocol.CorbaMessageMediator;
import com.sun.corba.se.spi.protocol.CorbaServerRequestDispatcher;
import com.sun.corba.se.spi.protocol.ForwardException ;
import com.sun.corba.se.spi.protocol.RequestDispatcherRegistry;
import com.sun.corba.se.spi.transport.CorbaConnection;
import com.sun.corba.se.spi.logging.CORBALogDomains;
import com.sun.corba.se.spi.ior.iiop.GIOPVersion;

import com.sun.corba.se.impl.protocol.SpecialMethod ;
import com.sun.corba.se.spi.servicecontext.ServiceContext;
import com.sun.corba.se.spi.servicecontext.ServiceContexts;
import com.sun.corba.se.spi.servicecontext.UEInfoServiceContext;
import com.sun.corba.se.spi.servicecontext.CodeSetServiceContext;
import com.sun.corba.se.spi.servicecontext.SendingContextServiceContext;
import com.sun.corba.se.spi.servicecontext.ORBVersionServiceContext;

import com.sun.corba.se.impl.corba.ServerRequestImpl ;
import com.sun.corba.se.impl.encoding.MarshalInputStream;
import com.sun.corba.se.impl.encoding.MarshalOutputStream;
import com.sun.corba.se.impl.encoding.CodeSetComponentInfo;
import com.sun.corba.se.impl.encoding.OSFCodeSetRegistry;
import com.sun.corba.se.impl.orbutil.ORBConstants;
import com.sun.corba.se.impl.orbutil.ORBUtility;
import com.sun.corba.se.impl.protocol.RequestCanceledException;
import com.sun.corba.se.impl.logging.ORBUtilSystemException;
import com.sun.corba.se.impl.logging.POASystemException;

public class CorbaServerRequestDispatcherImpl
    implements CorbaServerRequestDispatcher
{
    protected ORB orb; // my ORB instance
    private ORBUtilSystemException wrapper ;
    private POASystemException poaWrapper ;

    // Added from last version because it broke the build - RTW
    // XXX remove me and rebuild: probably no longer needed
    // public static final int UNKNOWN_EXCEPTION_INFO_ID = 9;

    public CorbaServerRequestDispatcherImpl(ORB orb)
    {
        this.orb = orb;
        wrapper = ORBUtilSystemException.get( orb,
            CORBALogDomains.RPC_PROTOCOL ) ;
        poaWrapper = POASystemException.get( orb,
            CORBALogDomains.RPC_PROTOCOL ) ;
    }

    /** XXX/REVISIT:
     * We do not want to look for a servant in the POA/ServantManager case,
     * but we could in most other cases.  The OA could have a method that
     * returns true if the servant MAY exist, and false only if the servant
     * definitely DOES NOT exist.
     *
     * XXX/REVISIT:
     * We may wish to indicate OBJECT_HERE by some mechanism other than
     * returning a null result.
     *
     * Called from ORB.locate when a LocateRequest arrives.
     * Result is not always absolutely correct: may indicate OBJECT_HERE
     * for non-existent objects, which is resolved on invocation.  This
     * "bug" is unavoidable, since in general the object may be destroyed
     * between a locate and a request.  Note that this only checks that
     * the appropriate ObjectAdapter is available, not that the servant
     * actually exists.
     * Need to signal one of OBJECT_HERE, OBJECT_FORWARD, OBJECT_NOT_EXIST.
     * @return Result is null if object is (possibly) implemented here, otherwise
     * an IOR indicating objref to forward the request to.
     * @exception OBJECT_NOT_EXIST is thrown if we know the object does not
     * exist here, and we are not forwarding.
     */
    public IOR locate(ObjectKey okey)
    {
        try {
            if (orb.subcontractDebugFlag)
                dprint(".locate->");

            ObjectKeyTemplate oktemp = okey.getTemplate() ;

            try {
                checkServerId(okey);
            } catch (ForwardException fex) {
                return fex.getIOR() ;
            }

            // Called only for its side-effect of throwing appropriate exceptions
            findObjectAdapter(oktemp);

            return null ;
        } finally {
            if (orb.subcontractDebugFlag)
                dprint(".locate<-");
        }
    }

    public void dispatch(MessageMediator messageMediator)
    {
        CorbaMessageMediator request = (CorbaMessageMediator) messageMediator;
        try {
            if (orb.subcontractDebugFlag) {
                dprint(".dispatch->: " + opAndId(request));
            }

            // to set the codebase information, if any transmitted; and also
            // appropriate ORB Version.
            consumeServiceContexts(request);

            // Now that we have the service contexts processed and the
            // correct ORBVersion set, we must finish initializing the
            // stream.
            ((MarshalInputStream)request.getInputObject())
                .performORBVersionSpecificInit();

            ObjectKey okey = request.getObjectKey();

            // Check that this server is the right server
            try {
                checkServerId(okey);
            } catch (ForwardException fex) {
                if (orb.subcontractDebugFlag) {
                    dprint(".dispatch: " + opAndId(request)
                           + ": bad server id");
                }

                request.getProtocolHandler()
                    .createLocationForward(request, fex.getIOR(), null);
                return;
            }

            String operation = request.getOperationName();
            ObjectAdapter objectAdapter = null ;

            try {
                byte[] objectId = okey.getId().getId() ;
                ObjectKeyTemplate oktemp = okey.getTemplate() ;
                objectAdapter = findObjectAdapter(oktemp);

                java.lang.Object servant = getServantWithPI(request, objectAdapter,
                    objectId, oktemp, operation);

                dispatchToServant(servant, request, objectId, objectAdapter);
            } catch (ForwardException ex) {
                if (orb.subcontractDebugFlag) {
                    dprint(".dispatch: " + opAndId(request)
                           + ": ForwardException caught");
                }

                // Thrown by Portable Interceptors from InterceptorInvoker,
                // through Response constructor.
                request.getProtocolHandler()
                    .createLocationForward(request, ex.getIOR(), null);
            } catch (OADestroyed ex) {
                if (orb.subcontractDebugFlag) {
                    dprint(".dispatch: " + opAndId(request)
                           + ": OADestroyed exception caught");
                }

                // DO NOT CALL THIS HERE:
                // releaseServant(objectAdapter);
                // The problem is that OADestroyed is only thrown by oa.enter, in
                // which case oa.exit should NOT be called, and neither should
                // the invocationInfo stack be popped.

                // Destroyed POAs can be recreated by normal adapter activation.
                // So just restart the dispatch.
                dispatch(request);
            } catch (RequestCanceledException ex) {
                if (orb.subcontractDebugFlag) {
                    dprint(".dispatch: " + opAndId(request)
                           + ": RequestCanceledException caught");
                }

                // IDLJ generated non-tie based skeletons do not catch the
                // RequestCanceledException. Rethrow the exception, which will
                // cause the worker thread to unwind the dispatch and wait for
                // other requests.
                throw ex;
            } catch (UnknownException ex) {
                if (orb.subcontractDebugFlag) {
                    dprint(".dispatch: " + opAndId(request)
                           + ": UnknownException caught " + ex);
                }

                // RMIC generated tie skeletons convert all Throwable exception
                // types (including RequestCanceledException, ThreadDeath)
                // thrown during reading fragments into UnknownException.
                // If RequestCanceledException was indeed raised,
                // then rethrow it, which will eventually cause the worker
                // thread to unstack the dispatch and wait for other requests.
                if (ex.originalEx instanceof RequestCanceledException) {
                    throw (RequestCanceledException) ex.originalEx;
                }

                ServiceContexts contexts = new ServiceContexts(orb);
                UEInfoServiceContext usc = new UEInfoServiceContext(
                    ex.originalEx);

                contexts.put( usc ) ;

                SystemException sysex = wrapper.unknownExceptionInDispatch(
                        CompletionStatus.COMPLETED_MAYBE, ex ) ;
                request.getProtocolHandler()
                    .createSystemExceptionResponse(request, sysex,
                        contexts);
            } catch (Throwable ex) {
                if (orb.subcontractDebugFlag) {
                    dprint(".dispatch: " + opAndId(request)
                           + ": other exception " + ex);
                }
                request.getProtocolHandler()
                    .handleThrowableDuringServerDispatch(
                        request, ex, CompletionStatus.COMPLETED_MAYBE);
            }
            return;
        } finally {
            if (orb.subcontractDebugFlag) {
                dprint(".dispatch<-: " + opAndId(request));
            }
        }
    }

    private void releaseServant(ObjectAdapter objectAdapter)
    {
        try {
            if (orb.subcontractDebugFlag) {
                dprint(".releaseServant->");
            }

            if (objectAdapter == null) {
                if (orb.subcontractDebugFlag) {
                    dprint(".releaseServant: null object adapter");
                }
                return ;
            }

            try {
                objectAdapter.returnServant();
            } finally {
                objectAdapter.exit();
                orb.popInvocationInfo() ;
            }
        } finally {
            if (orb.subcontractDebugFlag) {
                dprint(".releaseServant<-");
            }
        }
    }

    // Note that objectAdapter.enter() must be called before getServant.
    private java.lang.Object getServant(ObjectAdapter objectAdapter, byte[] objectId,
        String operation)
        throws OADestroyed
    {
        try {
            if (orb.subcontractDebugFlag) {
                dprint(".getServant->");
            }

            OAInvocationInfo info = objectAdapter.makeInvocationInfo(objectId);
            info.setOperation(operation);
            orb.pushInvocationInfo(info);
            objectAdapter.getInvocationServant(info);
            return info.getServantContainer() ;
        } finally {
            if (orb.subcontractDebugFlag) {
                dprint(".getServant<-");
            }
        }
    }

    protected java.lang.Object getServantWithPI(CorbaMessageMediator request,
                                                 ObjectAdapter objectAdapter,
        byte[] objectId, ObjectKeyTemplate oktemp, String operation)
        throws OADestroyed
    {
        try {
            if (orb.subcontractDebugFlag) {
                dprint(".getServantWithPI->");
            }

            // Prepare Portable Interceptors for a new server request
            // and invoke receive_request_service_contexts.  The starting
            // point may throw a SystemException or ForwardException.
            orb.getPIHandler().initializeServerPIInfo(request, objectAdapter,
                objectId, oktemp);
            orb.getPIHandler().invokeServerPIStartingPoint();

            objectAdapter.enter() ;

            // This must be set just after the enter so that exceptions thrown by
            // enter do not cause
            // the exception reply to pop the thread stack and do an extra oa.exit.
            if (request != null)
                request.setExecuteReturnServantInResponseConstructor(true);

            java.lang.Object servant = getServant(objectAdapter, objectId,
                operation);

            // Note: we do not know the MDI on a null servant.
            // We only end up in that situation if _non_existent called,
            // so that the following handleNullServant call does not throw an
            // exception.
            String mdi = "unknown" ;

            if (servant instanceof NullServant)
                handleNullServant(operation, (NullServant)servant);
            else
                mdi = objectAdapter.getInterfaces(servant, objectId)[0] ;

            orb.getPIHandler().setServerPIInfo(servant, mdi);

            if (((servant != null) &&
                !(servant instanceof org.omg.CORBA.DynamicImplementation) &&
                !(servant instanceof org.omg.PortableServer.DynamicImplementation)) ||
                (SpecialMethod.getSpecialMethod(operation) != null)) {
                orb.getPIHandler().invokeServerPIIntermediatePoint();
            }

            return servant ;
        } finally {
            if (orb.subcontractDebugFlag) {
                dprint(".getServantWithPI<-");
            }
        }
    }

    protected void checkServerId(ObjectKey okey)
    {
        try {
            if (orb.subcontractDebugFlag) {
                dprint(".checkServerId->");
            }

            ObjectKeyTemplate oktemp = okey.getTemplate() ;
            int sId = oktemp.getServerId() ;
            int scid = oktemp.getSubcontractId() ;

            if (!orb.isLocalServerId(scid, sId)) {
                if (orb.subcontractDebugFlag) {
                    dprint(".checkServerId: bad server id");
                }

                orb.handleBadServerId(okey);
            }
        } finally {
            if (orb.subcontractDebugFlag) {
                dprint(".checkServerId<-");
            }
        }
    }

    private ObjectAdapter findObjectAdapter(ObjectKeyTemplate oktemp)
    {
        try {
            if (orb.subcontractDebugFlag) {
                dprint(".findObjectAdapter->");
            }

            RequestDispatcherRegistry scr = orb.getRequestDispatcherRegistry() ;
            int scid = oktemp.getSubcontractId() ;
            ObjectAdapterFactory oaf = scr.getObjectAdapterFactory(scid);
            if (oaf == null) {
                if (orb.subcontractDebugFlag) {
                    dprint(".findObjectAdapter: failed to find ObjectAdapterFactory");
                }

                throw wrapper.noObjectAdapterFactory() ;
            }

            ObjectAdapterId oaid = oktemp.getObjectAdapterId() ;
            ObjectAdapter oa = oaf.find(oaid);

            if (oa == null) {
                if (orb.subcontractDebugFlag) {
                    dprint(".findObjectAdapter: failed to find ObjectAdaptor");
                }

                throw wrapper.badAdapterId() ;
            }

            return oa ;
        } finally {
            if (orb.subcontractDebugFlag) {
                dprint(".findObjectAdapter<-");
            }
        }
    }

    /** Always throws OBJECT_NOT_EXIST if operation is not a special method.
    * If operation is _non_existent or _not_existent, this will just
    * return without performing any action, so that _non_existent can return
    * false.  Always throws OBJECT_NOT_EXIST for any other special method.
    * Update for issue 4385.
    */
    protected void handleNullServant(String operation, NullServant nserv )
    {
        try {
            if (orb.subcontractDebugFlag) {
                dprint(".handleNullServant->: " + operation);
            }

            SpecialMethod specialMethod =
                SpecialMethod.getSpecialMethod(operation);

            if ((specialMethod == null) ||
                !specialMethod.isNonExistentMethod()) {
                if (orb.subcontractDebugFlag) {
                    dprint(".handleNullServant: " + operation
                           + ": throwing OBJECT_NOT_EXIST");
                }

                throw nserv.getException() ;
            }
        } finally {
            if (orb.subcontractDebugFlag) {
                dprint(".handleNullServant<-: " + operation);
            }
        }
    }

    protected void consumeServiceContexts(CorbaMessageMediator request)
    {
        try {
            if (orb.subcontractDebugFlag) {
                dprint(".consumeServiceContexts->: "
                       + opAndId(request));
            }

            ServiceContexts ctxts = request.getRequestServiceContexts();
            ServiceContext sc ;

            GIOPVersion giopVersion = request.getGIOPVersion();

            // we cannot depend on this since for our local case, we do not send
            // in this service context.  Can we rely on just the CodeSetServiceContext?
            // boolean rtSC = false; // Runtime ServiceContext

            boolean hasCodeSetContext = processCodeSetContext(request, ctxts);

            if (orb.subcontractDebugFlag) {
                dprint(".consumeServiceContexts: " + opAndId(request)
                       + ": GIOP version: " + giopVersion);
                dprint(".consumeServiceContexts: " + opAndId(request)
                       + ": as code set context? " + hasCodeSetContext);
            }

            sc = ctxts.get(
                SendingContextServiceContext.SERVICE_CONTEXT_ID ) ;

            if (sc != null) {
                SendingContextServiceContext scsc =
                    (SendingContextServiceContext)sc ;
                IOR ior = scsc.getIOR() ;

                try {
                    ((CorbaConnection)request.getConnection())
                        .setCodeBaseIOR(ior);
                } catch (ThreadDeath td) {
                    throw td ;
                } catch (Throwable t) {
                    throw wrapper.badStringifiedIor( t ) ;
                }
            }

            // the RTSC is sent only once during session establishment.  We
            // need to find out if the CodeBaseRef is already set.  If yes,
            // then also the rtSC flag needs to be set to true
            // this is not possible for the LocalCase since there is no
            // IIOPConnection for the LocalCase

            // used for a case where we have JDK 1.3 supporting 1.0 protocol,
            // but sending 2 service contexts, that is not normal as per
            // GIOP rules, based on above information, we figure out that we
            // are talking to the legacy ORB and set the ORB Version Accordingly.

            // this special case tell us that it is legacy SUN orb
            // and not a foreign one
            // rtSC is not available for localcase due to which this generic
            // path would fail if relying on rtSC
            //if (giopVersion.equals(GIOPVersion.V1_0) && hasCodeSetContext && rtSC)
            boolean isForeignORB = false;

            if (giopVersion.equals(GIOPVersion.V1_0) && hasCodeSetContext) {
                if (orb.subcontractDebugFlag) {
                    dprint(".consumeServiceCOntexts: " + opAndId(request)
                           + ": Determined to be an old Sun ORB");
                }

                orb.setORBVersion(ORBVersionFactory.getOLD()) ;
                // System.out.println("setting legacy ORB version");
            } else {
                // If it didn't include our ORB version service context (below),
                // then it must be a foreign ORB.
                isForeignORB = true;
            }

            // try to get the ORBVersion sent as part of the ServiceContext
            // if any
            sc = ctxts.get( ORBVersionServiceContext.SERVICE_CONTEXT_ID ) ;
            if (sc != null) {
                ORBVersionServiceContext ovsc =
                   (ORBVersionServiceContext) sc;

                ORBVersion version = ovsc.getVersion();
                orb.setORBVersion(version);

                isForeignORB = false;
            }

            if (isForeignORB) {
                if (orb.subcontractDebugFlag) {
                    dprint(".consumeServiceContexts: " + opAndId(request)
                           + ": Determined to be a foreign ORB");
                }

                orb.setORBVersion(ORBVersionFactory.getFOREIGN());
            }
        } finally {
            if (orb.subcontractDebugFlag) {
                dprint(".consumeServiceContexts<-: " + opAndId(request));
            }
        }
    }

    protected CorbaMessageMediator dispatchToServant(
        java.lang.Object servant,
        CorbaMessageMediator req,
        byte[] objectId, ObjectAdapter objectAdapter)
    {
        try {
            if (orb.subcontractDebugFlag) {
                dprint(".dispatchToServant->: " + opAndId(req));
            }

            CorbaMessageMediator response = null ;

            String operation = req.getOperationName() ;

            SpecialMethod method = SpecialMethod.getSpecialMethod(operation) ;
            if (method != null) {
                if (orb.subcontractDebugFlag) {
                    dprint(".dispatchToServant: " + opAndId(req)
                           + ": Handling special method");
                }

                response = method.invoke(servant, req, objectId, objectAdapter);
                return response ;
            }

            // Invoke on the servant using the portable DSI skeleton
            if (servant instanceof org.omg.CORBA.DynamicImplementation) {
                if (orb.subcontractDebugFlag) {
                    dprint(".dispatchToServant: " + opAndId(req)
                           + ": Handling old style DSI type servant");
                }

                org.omg.CORBA.DynamicImplementation dynimpl =
                    (org.omg.CORBA.DynamicImplementation)servant;
                ServerRequestImpl sreq = new ServerRequestImpl(req, orb);

                // Note: When/if dynimpl.invoke calls arguments() or
                // set_exception() then intermediate points are run.
                dynimpl.invoke(sreq);

                response = handleDynamicResult(sreq, req);
            } else if (servant instanceof org.omg.PortableServer.DynamicImplementation) {
                if (orb.subcontractDebugFlag) {
                    dprint(".dispatchToServant: " + opAndId(req)
                           + ": Handling POA DSI type servant");
                }

                org.omg.PortableServer.DynamicImplementation dynimpl =
                    (org.omg.PortableServer.DynamicImplementation)servant;
                ServerRequestImpl sreq = new ServerRequestImpl(req, orb);

                // Note: When/if dynimpl.invoke calls arguments() or
                // set_exception() then intermediate points are run.
                dynimpl.invoke(sreq);

                response = handleDynamicResult(sreq, req);
            } else {
                if (orb.subcontractDebugFlag) {
                    dprint(".dispatchToServant: " + opAndId(req)
                           + ": Handling invoke handler type servant");
                }

                InvokeHandler invhandle = (InvokeHandler)servant ;

                OutputStream stream =
                    (OutputStream)invhandle._invoke(
                      operation,
                      (org.omg.CORBA.portable.InputStream)req.getInputObject(),
                      req);
                response = (CorbaMessageMediator)
                    ((OutputObject)stream).getMessageMediator();
            }

            return response ;
        } finally {
            if (orb.subcontractDebugFlag) {
                dprint(".dispatchToServant<-: " + opAndId(req));
            }
        }
    }

    protected CorbaMessageMediator handleDynamicResult(
        ServerRequestImpl sreq,
        CorbaMessageMediator req)
    {
        try {
            if (orb.subcontractDebugFlag) {
                dprint(".handleDynamicResult->: " + opAndId(req));
            }

            CorbaMessageMediator response = null ;

            // Check if ServerRequestImpl.result() has been called
            Any excany = sreq.checkResultCalled();

            if (excany == null) { // normal return
                if (orb.subcontractDebugFlag) {
                    dprint(".handleDynamicResult: " + opAndId(req)
                           + ": handling normal result");
                }

                // Marshal out/inout/return parameters into the ReplyMessage
                response = sendingReply(req);
                OutputStream os = (OutputStream) response.getOutputObject();
                sreq.marshalReplyParams(os);
            }  else {
                if (orb.subcontractDebugFlag) {
                    dprint(".handleDynamicResult: " + opAndId(req)
                           + ": handling error");
                }

                response = sendingReply(req, excany);
            }

            return response ;
        } finally {
            if (orb.subcontractDebugFlag) {
                dprint(".handleDynamicResult<-: " + opAndId(req));
            }
        }
    }

    protected CorbaMessageMediator sendingReply(CorbaMessageMediator req)
    {
        try {
            if (orb.subcontractDebugFlag) {
                dprint(".sendingReply->: " + opAndId(req));
            }

            ServiceContexts scs = new ServiceContexts(orb);
            return req.getProtocolHandler().createResponse(req, scs);
        } finally {
            if (orb.subcontractDebugFlag) {
                dprint(".sendingReply<-: " + opAndId(req));
            }
        }
    }

    /** Must always be called, just after the servant's method returns.
     *  Creates the ReplyMessage header and puts in the transaction context
     *  if necessary.
     */
    protected CorbaMessageMediator sendingReply(CorbaMessageMediator req, Any excany)
    {
        try {
            if (orb.subcontractDebugFlag) {
                dprint(".sendingReply/Any->: " + opAndId(req));
            }

            ServiceContexts scs = new ServiceContexts(orb);

            // Check if the servant set a SystemException or
            // UserException
            CorbaMessageMediator resp;
            String repId=null;
            try {
                repId = excany.type().id();
            } catch (org.omg.CORBA.TypeCodePackage.BadKind e) {
                throw wrapper.problemWithExceptionTypecode( e ) ;
            }

            if (ORBUtility.isSystemException(repId)) {
                if (orb.subcontractDebugFlag) {
                    dprint(".sendingReply/Any: " + opAndId(req)
                           + ": handling system exception");
                }

                // Get the exception object from the Any
                InputStream in = excany.create_input_stream();
                SystemException ex = ORBUtility.readSystemException(in);
                // Marshal the exception back
                resp = req.getProtocolHandler()
                    .createSystemExceptionResponse(req, ex, scs);
            } else {
                if (orb.subcontractDebugFlag) {
                    dprint(".sendingReply/Any: " + opAndId(req)
                           + ": handling user exception");
                }

                resp = req.getProtocolHandler()
                    .createUserExceptionResponse(req, scs);
                OutputStream os = (OutputStream)resp.getOutputObject();
                excany.write_value(os);
            }

            return resp;
        } finally {
            if (orb.subcontractDebugFlag) {
                dprint(".sendingReply/Any<-: " + opAndId(req));
            }
        }
    }

    /**
     * Handles setting the connection's code sets if required.
     * Returns true if the CodeSetContext was in the request, false
     * otherwise.
     */
    protected boolean processCodeSetContext(
        CorbaMessageMediator request, ServiceContexts contexts)
    {
        try {
            if (orb.subcontractDebugFlag) {
                dprint(".processCodeSetContext->: " + opAndId(request));
            }

            ServiceContext sc = contexts.get(
                CodeSetServiceContext.SERVICE_CONTEXT_ID);
            if (sc != null) {
                // Somehow a code set service context showed up in the local case.
                if (request.getConnection() == null) {
                    return true;
                }

                // If it's GIOP 1.0, it shouldn't have this context at all.  Our legacy
                // ORBs sent it and we need to know if it's here to make ORB versioning
                // decisions, but we don't use the contents.
                if (request.getGIOPVersion().equals(GIOPVersion.V1_0)) {
                    return true;
                }

                CodeSetServiceContext cssc = (CodeSetServiceContext)sc ;
                CodeSetComponentInfo.CodeSetContext csctx = cssc.getCodeSetContext();

                // Note on threading:
                //
                // getCodeSetContext and setCodeSetContext are synchronized
                // on the Connection.  At worst, this will result in
                // multiple threads entering this block and calling
                // setCodeSetContext but not actually changing the
                // values on the Connection.
                //
                // Alternative would be to lock the connection for the
                // whole block, but it's fine either way.

                // The connection's codeSetContext is null until we've received a
                // request with a code set context with the negotiated code sets.
                if (((CorbaConnection)request.getConnection())
                    .getCodeSetContext() == null)
                {

                    // Use these code sets on this connection
                    if (orb.subcontractDebugFlag) {
                        dprint(".processCodeSetContext: " + opAndId(request)
                               + ": Setting code sets to: " + csctx);
                    }

                    ((CorbaConnection)request.getConnection())
                        .setCodeSetContext(csctx);

                    // We had to read the method name using ISO 8859-1
                    // (which is the default in the CDRInputStream for
                    // char data), but now we may have a new char
                    // code set.  If it isn't ISO8859-1, we must tell
                    // the CDR stream to null any converter references
                    // it has created so that it will reacquire
                    // the code sets again using the new info.
                    //
                    // This should probably compare with the stream's
                    // char code set rather than assuming it's ISO8859-1.
                    // (However, the operation name is almost certainly
                    // ISO8859-1 or ASCII.)
                    if (csctx.getCharCodeSet() !=
                        OSFCodeSetRegistry.ISO_8859_1.getNumber()) {
                        ((MarshalInputStream)request.getInputObject())
                            .resetCodeSetConverters();
                    }
                }
            }

            // If no code set information is ever sent from the client,
            // the server will use ISO8859-1 for char and throw an
            // exception for any wchar transmissions.
            //
            // In the local case, we use ORB provided streams for
            // marshaling and unmarshaling.  Currently, they use
            // ISO8859-1 for char/string and UTF16 for wchar/wstring.
            return sc != null ;
        } finally {
            if (orb.subcontractDebugFlag) {
                dprint(".processCodeSetContext<-: " + opAndId(request));
            }
        }
    }

    protected void dprint(String msg)
    {
        ORBUtility.dprint("CorbaServerRequestDispatcherImpl", msg);
    }

    protected String opAndId(CorbaMessageMediator mediator)
    {
        return ORBUtility.operationNameAndRequestId(mediator);
    }
}

// End of file.