/*
 * @(#)CorbaClientRequestDispatcherImpl.java	1.86 04/06/21
 *
 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

/*
 * Licensed Materials - Property of IBM
 * RMI-IIOP v1.0
 * Copyright IBM Corp. 1998 1999  All Rights Reserved
 *
 * US Government Users Restricted Rights - Use, duplication or
 * disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */

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

import java.io.IOException;
import java.util.Iterator;
import java.rmi.RemoteException;

import javax.rmi.CORBA.Util;
import javax.rmi.CORBA.Tie;

import org.omg.CORBA.COMM_FAILURE;
import org.omg.CORBA.INTERNAL;
import org.omg.CORBA.SystemException;
import org.omg.CORBA.Request;
import org.omg.CORBA.NamedValue;
import org.omg.CORBA.NVList;
import org.omg.CORBA.Context;
import org.omg.CORBA.ContextList;
import org.omg.CORBA.ExceptionList;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.portable.RemarshalException;
import org.omg.CORBA_2_3.portable.InputStream;
import org.omg.CORBA_2_3.portable.OutputStream;
import org.omg.CORBA.portable.Delegate;
import org.omg.CORBA.portable.ServantObject;
import org.omg.CORBA.portable.ApplicationException;
import org.omg.CORBA.portable.UnknownException;
import org.omg.IOP.ExceptionDetailMessage;
import org.omg.IOP.TAG_CODE_SETS;

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

import com.sun.corba.se.pept.broker.Broker;
import com.sun.corba.se.pept.encoding.InputObject;
import com.sun.corba.se.pept.encoding.OutputObject;
import com.sun.corba.se.pept.protocol.ClientRequestDispatcher;
import com.sun.corba.se.pept.protocol.MessageMediator;
import com.sun.corba.se.pept.transport.Connection;
import com.sun.corba.se.pept.transport.OutboundConnectionCache;
import com.sun.corba.se.pept.transport.ContactInfo;

import com.sun.corba.se.spi.ior.IOR;
import com.sun.corba.se.spi.ior.iiop.GIOPVersion;
import com.sun.corba.se.spi.ior.iiop.IIOPProfileTemplate;
import com.sun.corba.se.spi.ior.iiop.CodeSetsComponent;
import com.sun.corba.se.spi.oa.OAInvocationInfo;
import com.sun.corba.se.spi.oa.ObjectAdapterFactory;
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.protocol.CorbaMessageMediator;
import com.sun.corba.se.spi.protocol.RequestDispatcherRegistry;
import com.sun.corba.se.spi.transport.CorbaContactInfo ;
import com.sun.corba.se.spi.transport.CorbaContactInfoList ;
import com.sun.corba.se.spi.transport.CorbaContactInfoListIterator ;
import com.sun.corba.se.spi.transport.CorbaConnection;
import com.sun.corba.se.spi.logging.CORBALogDomains;

import com.sun.corba.se.spi.servicecontext.MaxStreamFormatVersionServiceContext;
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.spi.servicecontext.MaxStreamFormatVersionServiceContext;
import com.sun.corba.se.spi.servicecontext.UnknownServiceContext;

import com.sun.corba.se.impl.encoding.CDRInputObject;
import com.sun.corba.se.impl.encoding.CodeSetComponentInfo;
import com.sun.corba.se.impl.encoding.CodeSetConversion;
import com.sun.corba.se.impl.encoding.EncapsInputStream;
import com.sun.corba.se.impl.encoding.MarshalOutputStream;
import com.sun.corba.se.impl.encoding.MarshalInputStream;
import com.sun.corba.se.impl.logging.ORBUtilSystemException;
import com.sun.corba.se.impl.orbutil.ORBUtility;
import com.sun.corba.se.impl.orbutil.ORBConstants;
import com.sun.corba.se.impl.protocol.giopmsgheaders.ReplyMessage;
import com.sun.corba.se.impl.protocol.giopmsgheaders.KeyAddr;
import com.sun.corba.se.impl.protocol.giopmsgheaders.ProfileAddr;
import com.sun.corba.se.impl.protocol.giopmsgheaders.ReferenceAddr;
import com.sun.corba.se.impl.transport.CorbaContactInfoListIteratorImpl;
import com.sun.corba.se.impl.util.JDKBridge;

/**
 * ClientDelegate is the RMI client-side subcontract or representation
 * It implements RMI delegate as well as our internal ClientRequestDispatcher
 * interface.
 */
public class CorbaClientRequestDispatcherImpl
    implements
	ClientRequestDispatcher
{
    // Used for locking
    private Object lock = new Object();

    public OutputObject beginRequest(Object self, String opName,
				     boolean isOneWay, ContactInfo contactInfo)
    {
      ORB orb = null;
      try {
	CorbaContactInfo corbaContactInfo = (CorbaContactInfo) contactInfo;
	orb =  (ORB)contactInfo.getBroker();

	if (orb.subcontractDebugFlag) {
	    dprint(".beginRequest->: op/" + opName);
	}

	//
        // Portable Interceptor initialization.
	//

        orb.getPIHandler().initiateClientPIRequest( false );

	//
	// Connection.
	//

	CorbaConnection connection = null;

	// This locking is done so that multiple connections are not created
	// for the same endpoint
	synchronized (lock) {
	    if (contactInfo.isConnectionBased()) {
		if (contactInfo.shouldCacheConnection()) {
		    connection = (CorbaConnection)
			orb.getTransportManager()
			.getOutboundConnectionCache(contactInfo).get(contactInfo);
		}
		if (connection != null) {
		    if (orb.subcontractDebugFlag) {
			dprint(".beginRequest: op/" + opName 
			       + ": Using cached connection: " + connection);
		    }
		} else {
		    try {
			connection = (CorbaConnection)
			    contactInfo.createConnection();
			if (orb.subcontractDebugFlag) {
			    dprint(".beginRequest: op/" + opName
				   + ": Using created connection: " + connection);
			}
		    } catch (RuntimeException e) {
			if (orb.subcontractDebugFlag) {
			    dprint(".beginRequest: op/" + opName 
				   + ": failed to create connection: " + e);
			}
			// REVISIT: this part similar to marshalingComplete below.
			boolean retry = getContactInfoListIterator(orb)
					   .reportException(contactInfo, e);
			// REVISIT: 
			// this part similar to Remarshal in this method below
			if (retry) {
			    if(getContactInfoListIterator(orb).hasNext()) {
				contactInfo = (ContactInfo)
				   getContactInfoListIterator(orb).next();
				return beginRequest(self, opName, 
						    isOneWay, contactInfo);
			    } else {
				throw e;
			    }
			} else {
			    throw e;
			}
		    }
		    if (connection.shouldRegisterReadEvent()) {
			// REVISIT: cast
			orb.getTransportManager().getSelector(0)
			    .registerForEvent(connection.getEventHandler());
			connection.setState("ESTABLISHED");
		    }
		    // Do not do connection reclaim here since the connections
		    // are marked in use by registerWaiter() call and since this
		    // call happens later do it after that.
		    if (contactInfo.shouldCacheConnection()) {
			OutboundConnectionCache connectionCache =
			 orb.getTransportManager()
			    .getOutboundConnectionCache(contactInfo);
			connectionCache.stampTime(connection);
			connectionCache.put(contactInfo, connection);
    //		    connectionCache.reclaim();
		    }
		}
	    }
	}

	CorbaMessageMediator messageMediator = (CorbaMessageMediator)
	    contactInfo.createMessageMediator(
	        orb, contactInfo, connection, opName, isOneWay);
	if (orb.subcontractDebugFlag) {
	    dprint(".beginRequest: " + opAndId(messageMediator)
		   + ": created message mediator: " +  messageMediator);
	}

        // NOTE: Thread data so we can get the mediator in release reply
	// in order to remove the waiter in CorbaConnection.
	// We cannot depend on obtaining information in releaseReply
	// via its InputStream argument since, on certain errors
	// (e.g., client marshaling errors), the stream may be null.
	// Likewise for releaseReply "self".
	// NOTE: This must be done before initializing the message since
	// that may start sending fragments which may end up in "early"
	// replies or client marshaling exceptions.

        orb.getInvocationInfo().setMessageMediator(messageMediator);

	if (connection != null && connection.getCodeSetContext() == null) {
	    performCodeSetNegotiation(messageMediator);
	}

	addServiceContexts(messageMediator);

	OutputObject outputObject =
	    contactInfo.createOutputObject(messageMediator);
	if (orb.subcontractDebugFlag) {
	    dprint(".beginRequest: " + opAndId(messageMediator)
		   + ": created output object: " + outputObject);
	}


        // NOTE: Not necessary for oneways, but useful for debugging.
	// This must be done BEFORE message initialization since fragments
	// may be sent at that time.
	registerWaiter(messageMediator);

	// Do connection reclaim now
	synchronized (lock) {
	    if (contactInfo.isConnectionBased()) {
		if (contactInfo.shouldCacheConnection()) {
		    OutboundConnectionCache connectionCache =
			     orb.getTransportManager()
				.getOutboundConnectionCache(contactInfo);
		    connectionCache.reclaim();
		}
	    }
	}

	orb.getPIHandler().setClientPIInfo(messageMediator);
	try {
	    // This MUST come before message is initialized so
	    // service contexts may be added by PI because
	    // initial fragments may be sent during message initialization.
	    orb.getPIHandler().invokeClientPIStartingPoint();
	} catch( RemarshalException e ) {
	    if (orb.subcontractDebugFlag) {
		dprint(".beginRequest: " + opAndId(messageMediator)
		       + ": Remarshal");
	    }

	    // NOTE: We get here because an interceptor raised ForwardRequest
	    // and updated the IOR/Iterator.  Since we have a fresh iterator
	    // hasNext should succeed.

	    // REVISIT: We should feed ALL interceptor exceptions to 
	    // iterator.reportException so it can determine if it wants
	    // to retry.  Right now, SystemExceptions will flow to the
	    // client code.

	    // REVISIT:
	    // This assumes that interceptors update
	    // ContactInfoList outside of subcontract.
	    // Want to move that update to here.
	    if (getContactInfoListIterator(orb).hasNext()) {
		contactInfo = (ContactInfo)
		    getContactInfoListIterator(orb).next();
		return beginRequest(self, opName, isOneWay, contactInfo);
	    } else {
		ORBUtilSystemException wrapper = 
		    ORBUtilSystemException.get(orb, 
					       CORBALogDomains.RPC_PROTOCOL);
		throw wrapper.remarshalWithNowhereToGo();
	    }
	}

	messageMediator.initializeMessage();
	if (orb.subcontractDebugFlag) {
	    dprint(".beginRequest: " + opAndId(messageMediator)
		   + ": initialized message");
	}

	return outputObject;

      } finally {
	if (orb.subcontractDebugFlag) {
	    dprint(".beginRequest<-: op/" + opName);
	}
      }
    }

    public InputObject marshalingComplete(java.lang.Object self, 
					  OutputObject outputObject)
	throws 
	    ApplicationException, 
	    org.omg.CORBA.portable.RemarshalException
    {
	ORB orb = null;
	CorbaMessageMediator messageMediator = null;
	try {
	    messageMediator = (CorbaMessageMediator)
		outputObject.getMessageMediator();

	    orb = (ORB) messageMediator.getBroker();

	    if (orb.subcontractDebugFlag) {
		dprint(".marshalingComplete->: " + opAndId(messageMediator));
	    }

	    InputObject inputObject = 
		marshalingComplete1(orb, messageMediator);

	    return processResponse(orb, messageMediator, inputObject);

	} finally {
	    if (orb.subcontractDebugFlag) {
		dprint(".marshalingComplete<-: " + opAndId(messageMediator));
	    }
	}
    }

    public InputObject marshalingComplete1(
            ORB orb, CorbaMessageMediator messageMediator)
	throws
	    ApplicationException, 
	    org.omg.CORBA.portable.RemarshalException
    {
	try {
	    messageMediator.finishSendingRequest();

	    if (orb.subcontractDebugFlag) {
		dprint(".marshalingComplete: " + opAndId(messageMediator)
		       + ": finished sending request");
	    }

	    return messageMediator.waitForResponse();

	} catch (RuntimeException e) {

	    if (orb.subcontractDebugFlag) {
		dprint(".marshalingComplete: " + opAndId(messageMediator)
		       + ": exception: " + e.toString());
	    }

	    boolean retry  =
		getContactInfoListIterator(orb)
	            .reportException(messageMediator.getContactInfo(), e);
	    if (retry) {
		// Must run interceptor end point before retrying.
		Exception newException = 
		    orb.getPIHandler().invokeClientPIEndingPoint(
                        ReplyMessage.SYSTEM_EXCEPTION, e);
		if (newException == e) {
		    continueOrThrowSystemOrRemarshal(messageMediator,
						     new RemarshalException());
		} else {
		    continueOrThrowSystemOrRemarshal(messageMediator,
						     newException);
		}
	    } else {
		// NOTE: Interceptor ending point will run in releaseReply.
		throw e;
	    }
	    return null; // for compiler
	}
    }

    protected InputObject processResponse(ORB orb, 
					  CorbaMessageMediator messageMediator,
					  InputObject inputObject)
	throws 
	    ApplicationException, 
	    org.omg.CORBA.portable.RemarshalException
    {
	ORBUtilSystemException wrapper = 
	    ORBUtilSystemException.get( orb, 
		CORBALogDomains.RPC_PROTOCOL ) ;

	if (orb.subcontractDebugFlag) {
	    dprint(".processResponse: " + opAndId(messageMediator)
		   + ": response received");
	}

        // We know for sure now that we've sent a message.
        // So OK to not send initial again.
        if (messageMediator.getConnection() != null) {
            ((CorbaConnection)messageMediator.getConnection())
		.setPostInitialContexts();
        }

        // NOTE: not necessary to set MessageMediator for PI.
	// It already has it.

	// Process the response.

        Exception exception = null;

        if (messageMediator.isOneWay()) {
	    getContactInfoListIterator(orb)
		.reportSuccess(messageMediator.getContactInfo());
            // Invoke Portable Interceptors with receive_other
            exception = orb.getPIHandler().invokeClientPIEndingPoint(
                ReplyMessage.NO_EXCEPTION, exception );
            continueOrThrowSystemOrRemarshal(messageMediator, exception);
            return null;
        }

	consumeServiceContexts(orb, messageMediator);

	// Now that we have the service contexts processed and the
	// correct ORBVersion set, we must finish initializing the stream.
	// REVISIT - need interface for this operation.
	((CDRInputObject)inputObject).performORBVersionSpecificInit();

        if (messageMediator.isSystemExceptionReply()) {

            SystemException se = messageMediator.getSystemExceptionReply();

	    if (orb.subcontractDebugFlag) {
		dprint(".processResponse: " + opAndId(messageMediator)
		       + ": received system exception: " + se);
	    }

	    boolean doRemarshal =
	        getContactInfoListIterator(orb)
		    .reportException(messageMediator.getContactInfo(), se);

            if (doRemarshal) {
                    
		// Invoke Portable Interceptors with receive_exception:
		exception = orb.getPIHandler().invokeClientPIEndingPoint(
                    ReplyMessage.SYSTEM_EXCEPTION, se );

		// If PI did not change the exception, throw a
		// Remarshal.
		if( se == exception ) {
		    // exception = null is to maintain symmetry with
		    // GenericPOAClientSC.
		    exception = null;
		    continueOrThrowSystemOrRemarshal(messageMediator,
						     new RemarshalException());
		    throw wrapper.statementNotReachable1() ;
                } else {
		    //  Otherwise, throw the exception PI wants thrown.
                    continueOrThrowSystemOrRemarshal(messageMediator,
						     exception);
		    throw wrapper.statementNotReachable2() ;
                }
            }

	    // No retry, so see if was unknown.

            ServiceContexts contexts = 
		messageMediator.getReplyServiceContexts();
            if (contexts != null) {
		UEInfoServiceContext usc =
		    (UEInfoServiceContext)
		    contexts.get(UEInfoServiceContext.SERVICE_CONTEXT_ID);

		if (usc != null) {
		    Throwable unknown = usc.getUE() ;
		    UnknownException ue = new UnknownException(unknown);

		    // Invoke Portable Interceptors with receive_exception:
		    exception = orb.getPIHandler().invokeClientPIEndingPoint(
			ReplyMessage.SYSTEM_EXCEPTION, ue );

		    continueOrThrowSystemOrRemarshal(messageMediator, exception);
		    throw wrapper.statementNotReachable3() ;
		}
            }

	    // It was not a comm failure nor unknown.
	    // This is the general case.

            // Invoke Portable Interceptors with receive_exception:
            exception = orb.getPIHandler().invokeClientPIEndingPoint(
                ReplyMessage.SYSTEM_EXCEPTION, se );

            continueOrThrowSystemOrRemarshal(messageMediator, exception);

            // Note: We should never need to execute this line, but
            // we should assert in case exception is null somehow.
	    throw wrapper.statementNotReachable4() ;
        } else if (messageMediator.isUserExceptionReply()) {

	    if (orb.subcontractDebugFlag) {
		dprint(".processResponse: " + opAndId(messageMediator)
		       + ": received user exception");
	    }

	    getContactInfoListIterator(orb)
		.reportSuccess(messageMediator.getContactInfo());

	    String exceptionRepoId = peekUserExceptionId(inputObject);
	    Exception newException = null;

	    if (messageMediator.isDIIRequest()) {
		exception = messageMediator.unmarshalDIIUserException(
                                exceptionRepoId, (InputStream)inputObject);
		newException = orb.getPIHandler().invokeClientPIEndingPoint(
			           ReplyMessage.USER_EXCEPTION, exception );
		messageMediator.setDIIException(newException);
		
	    } else {
		ApplicationException appException =
		    new ApplicationException(
                        exceptionRepoId,
			(org.omg.CORBA.portable.InputStream)inputObject);
		exception = appException;
		newException = orb.getPIHandler().invokeClientPIEndingPoint(
                                   ReplyMessage.USER_EXCEPTION, appException );
	    }

            if (newException != exception) {
                continueOrThrowSystemOrRemarshal(messageMediator,newException);
            }

	    if (newException instanceof ApplicationException) {
		throw (ApplicationException)newException;
	    }
	    // For DII: 
	    // This return will be ignored - already unmarshaled above.
	    return inputObject;

        } else if (messageMediator.isLocationForwardReply()) {

	    if (orb.subcontractDebugFlag) {
		dprint(".processResponse: " + opAndId(messageMediator)
		       + ": received location forward");
	    }
	    
	    // NOTE: Expects iterator to update target IOR
	    getContactInfoListIterator(orb).reportRedirect(
	        (CorbaContactInfo)messageMediator.getContactInfo(),
	        messageMediator.getForwardedIOR());

            // Invoke Portable Interceptors with receive_other:
	    Exception newException = orb.getPIHandler().invokeClientPIEndingPoint(
		ReplyMessage.LOCATION_FORWARD, null );

	    if( !(newException instanceof RemarshalException) ) {
		exception = newException;
	    }

            // If PI did not change exception, throw Remarshal, else
            // throw the exception PI wants thrown.
	    // KMC: GenericPOAClientSC did not check exception != null
            if( exception != null ) {
                continueOrThrowSystemOrRemarshal(messageMediator, exception);
            }
	    continueOrThrowSystemOrRemarshal(messageMediator,
					     new RemarshalException());
	    throw wrapper.statementNotReachable5() ;

        } else if (messageMediator.isDifferentAddrDispositionRequestedReply()){

	    if (orb.subcontractDebugFlag) {
		dprint(".processResponse: " + opAndId(messageMediator)
		       + ": received different addressing dispostion request");
	    }

            // Set the desired target addressing disposition.
	    getContactInfoListIterator(orb).reportAddrDispositionRetry(
	        (CorbaContactInfo)messageMediator.getContactInfo(),
                messageMediator.getAddrDispositionReply());

            // Invoke Portable Interceptors with receive_other:
	    Exception newException = orb.getPIHandler().invokeClientPIEndingPoint(
		ReplyMessage.NEEDS_ADDRESSING_MODE, null);

            // For consistency with corresponding code in GenericPOAClientSC:
	    if( !(newException instanceof RemarshalException) ) {
		exception = newException;
	    }

            // If PI did not change exception, throw Remarshal, else
            // throw the exception PI wants thrown.
	    // KMC: GenericPOAClientSC did not include exception != null check
            if( exception != null ) {
                continueOrThrowSystemOrRemarshal(messageMediator, exception);
            }
	    continueOrThrowSystemOrRemarshal(messageMediator,
					     new RemarshalException());
	    throw wrapper.statementNotReachable6() ;
        } else /* normal response */ {

	    if (orb.subcontractDebugFlag) {
		dprint(".processResponse: " + opAndId(messageMediator)
		       + ": received normal response");
	    }

	    getContactInfoListIterator(orb)
		.reportSuccess(messageMediator.getContactInfo());

	    messageMediator.handleDIIReply((InputStream)inputObject);

            // Invoke Portable Interceptors with receive_reply:
            exception = orb.getPIHandler().invokeClientPIEndingPoint(
                ReplyMessage.NO_EXCEPTION, null );

            // Remember: not thrown if exception is null.
            continueOrThrowSystemOrRemarshal(messageMediator, exception);

            return inputObject;
        }
    }

    // Filters the given exception into a SystemException or a
    // RemarshalException and throws it.  Assumes the given exception is
    // of one of these two types.  This is a utility method for
    // the above invoke code which must do this numerous times.
    // If the exception is null, no exception is thrown.
    //
    // Note that this code is duplicated in GenericPOAClientSC.java
    protected void continueOrThrowSystemOrRemarshal(
        CorbaMessageMediator messageMediator, Exception exception)
        throws 
	    SystemException, RemarshalException
    {

	ORB orb = (ORB) messageMediator.getBroker();

        if( exception == null ) {

            // do nothing.

        } else if( exception instanceof RemarshalException ) {

	    // REVISIT - unify with PI handling
	    orb.getInvocationInfo().setIsRetryInvocation(true);

	    // NOTE - We must unregister the waiter NOW for this request
	    // since the retry will result in a new request id.  Therefore
	    // the old request id would be lost and we would have a memory
	    // leak in the responseWaitingRoom.
	    unregisterWaiter(orb);

	    if (orb.subcontractDebugFlag) {
		dprint(".continueOrThrowSystemOrRemarshal: "
		       + opAndId(messageMediator)
		       + ": throwing Remarshal");
	    }

            throw (RemarshalException)exception;

        } else {

	    if (orb.subcontractDebugFlag) {
		dprint(".continueOrThrowSystemOrRemarshal: "
		       + opAndId(messageMediator)
		       + ": throwing sex:" 
		       + exception);
	    }

            throw (SystemException)exception;
        }
    }

    protected CorbaContactInfoListIterator  getContactInfoListIterator(ORB orb)
    {
	return (CorbaContactInfoListIterator)
	    ((CorbaInvocationInfo)orb.getInvocationInfo())
	        .getContactInfoListIterator();
    }

    protected void registerWaiter(CorbaMessageMediator messageMediator)
    {
	if (messageMediator.getConnection() != null) {
	    messageMediator.getConnection().registerWaiter(messageMediator);
	}
    }

    protected void unregisterWaiter(ORB orb)
    {
	MessageMediator messageMediator =
	    orb.getInvocationInfo().getMessageMediator();
	if (messageMediator!=null && messageMediator.getConnection() != null) {
	    // REVISIT:
	    // The messageMediator may be null if COMM_FAILURE before
	    // it is created.
	    messageMediator.getConnection().unregisterWaiter(messageMediator);
	}
    }

    protected void addServiceContexts(CorbaMessageMediator messageMediator)
    {
	ORB orb = (ORB)messageMediator.getBroker();
	CorbaConnection c = (CorbaConnection) messageMediator.getConnection();
	GIOPVersion giopVersion = messageMediator.getGIOPVersion();

	ServiceContexts contexts = messageMediator.getRequestServiceContexts();

        addCodeSetServiceContext(c, contexts, giopVersion);

        // Add the RMI-IIOP max stream format version
        // service context to every request.  Once we have GIOP 1.3,
        // we could skip it since we now support version 2, but
        // probably safer to always send it.
	contexts.put(MaxStreamFormatVersionServiceContext.singleton);

	// ORBVersion servicecontext needs to be sent
	ORBVersionServiceContext ovsc = new ORBVersionServiceContext(
	                ORBVersionFactory.getORBVersion() ) ;
	contexts.put( ovsc ) ;

	// NOTE : We only want to send the runtime context the first time
	if ((c != null) && !c.isPostInitialContexts()) {
            // Do not do c.setPostInitialContexts() here.
            // If a client interceptor send_request does a ForwardRequest
            // which ends up using the same connection then the service
            // context would not be sent.
	    SendingContextServiceContext scsc =
		new SendingContextServiceContext( orb.getFVDCodeBaseIOR() ) ; //d11638
	    contexts.put( scsc ) ;
	}
    }

    protected void consumeServiceContexts(ORB orb, 
					CorbaMessageMediator messageMediator)
    {
	ServiceContexts ctxts = messageMediator.getReplyServiceContexts();
	ServiceContext sc ;
	ORBUtilSystemException wrapper = ORBUtilSystemException.get( orb, 
		CORBALogDomains.RPC_PROTOCOL ) ;

        if (ctxts == null) {
            return; // no service context available, return gracefully.
        }

	sc = ctxts.get( SendingContextServiceContext.SERVICE_CONTEXT_ID ) ;

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

	    try {
		// set the codebase returned by the server
		if (messageMediator.getConnection() != null) {
		    ((CorbaConnection)messageMediator.getConnection()).setCodeBaseIOR(ior);
		}
	    } catch (ThreadDeath td) {
		throw td ;
	    } catch (Throwable t) {
		throw wrapper.badStringifiedIor( t ) ;
	    }
	} 

	// see if the version subcontract is present, if yes, then set
	// the ORBversion
	sc = ctxts.get( ORBVersionServiceContext.SERVICE_CONTEXT_ID ) ;

	if (sc != null) {
	    ORBVersionServiceContext ovsc =
	       (ORBVersionServiceContext) sc;

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

	getExceptionDetailMessage(messageMediator, wrapper);
    }

    protected void getExceptionDetailMessage(
        CorbaMessageMediator  messageMediator,
	ORBUtilSystemException wrapper)
    {
	ServiceContext sc = messageMediator.getReplyServiceContexts()
	    .get(ExceptionDetailMessage.value);
	if (sc == null)
	    return ;

	if (! (sc instanceof UnknownServiceContext)) {
	    throw wrapper.badExceptionDetailMessageServiceContextType();
	}
	byte[] data = ((UnknownServiceContext)sc).getData();
	EncapsInputStream in = 
	    new EncapsInputStream((ORB)messageMediator.getBroker(),
				  data, data.length);
	in.consumeEndian();

	String msg =
	      "----------BEGIN server-side stack trace----------\n"
	    + in.read_wstring() + "\n"
	    + "----------END server-side stack trace----------";

	messageMediator.setReplyExceptionDetailMessage(msg);
    }

    public void endRequest(Broker broker, Object self, InputObject inputObject)
    {
	ORB orb = (ORB)broker ;

	try {
	    if (orb.subcontractDebugFlag) {
		dprint(".endRequest->");
	    }

	    // Note: the inputObject may be null if an error occurs
	    //       in request or before _invoke returns.
	    // Note: self may be null also (e.g., compiler generates null in stub).

	    MessageMediator messageMediator =
		orb.getInvocationInfo().getMessageMediator();
	    if (messageMediator != null)
            {
                if (messageMediator.getConnection() != null) 
                {
                    ((CorbaMessageMediator)messageMediator)
                              .sendCancelRequestIfFinalFragmentNotSent();
                }

                // Release any outstanding NIO ByteBuffers to the ByteBufferPool

                InputObject inputObj = messageMediator.getInputObject();
                if (inputObj != null) {
                    inputObj.close();
                }

                OutputObject outputObj = messageMediator.getOutputObject();
                if (outputObj != null) {
                    outputObj.close();
                }

            }

	    // XREVISIT NOTE - Assumes unregistering the waiter for
	    // location forwards has already happened somewhere else.
	    // The code below is only going to unregister the final successful
	    // request. 

	    // NOTE: In the case of a recursive stack of endRequests in a
	    // finally block (because of Remarshal) only the first call to
	    // unregisterWaiter will remove the waiter.  The rest will be
	    // noops.
	    unregisterWaiter(orb);

	    // Invoke Portable Interceptors cleanup.  This is done to handle
	    // exceptions during stream marshaling.  More generally, exceptions
	    // that occur in the ORB after send_request (which includes
	    // after returning from _request) before _invoke:
	    orb.getPIHandler().cleanupClientPIRequest();

	    // REVISIT: Early replies?
	} catch (IOException ex) { 
            // See CDRInput/OutputObject.close() for more info.
            // This won't result in a Corba error if an IOException happens.
	    if (orb.subcontractDebugFlag)
            {
	        dprint(".endRequest: ignoring IOException - " + ex.toString());
            }
	} finally {
	    if (orb.subcontractDebugFlag) {
		dprint(".endRequest<-");
	    }
	}
    }


    protected void performCodeSetNegotiation(CorbaMessageMediator messageMediator)
    {
	CorbaConnection conn = 
	    (CorbaConnection) messageMediator.getConnection();
	IOR ior =
	    ((CorbaContactInfo)messageMediator.getContactInfo())
	    .getEffectiveTargetIOR();
	GIOPVersion giopVersion = messageMediator.getGIOPVersion();

	// XXX This seems to be a broken double checked locking idiom: FIX IT!

        // conn.getCodeSetContext() is null when no other requests have
        // been made on this connection to trigger code set negotation.
        if (conn != null &&
            conn.getCodeSetContext() == null &&
            !giopVersion.equals(GIOPVersion.V1_0)) {
                        
            synchronized(conn) {
                // Double checking.  Don't let any other
                // threads use this connection until the
                // code sets are straight.
                if (conn.getCodeSetContext() != null)
                    return;
                
                // This only looks at the first code set component.  If
                // there can be multiple locations with multiple code sets,
                // this requires more work.
                IIOPProfileTemplate temp = 
		    (IIOPProfileTemplate)ior.getProfile().
		    getTaggedProfileTemplate();
                Iterator iter = temp.iteratorById(TAG_CODE_SETS.value);
                if (!iter.hasNext()) {
                    // Didn't have a code set component.  The default will
                    // be to use ISO8859-1 for char data and throw an
                    // exception if wchar data is used.
                    return;
                }

                // Get the native and conversion code sets the
                // server specified in its IOR
                CodeSetComponentInfo serverCodeSets
                    = ((CodeSetsComponent)iter.next()).getCodeSetComponentInfo();

                // Perform the negotiation between this ORB's code sets and
                // the ones from the IOR
                CodeSetComponentInfo.CodeSetContext result
                    = CodeSetConversion.impl().negotiate(
                          conn.getBroker().getORBData().getCodeSetComponentInfo(),
			  serverCodeSets);
                
                conn.setCodeSetContext(result);
            }
        }
    }

    protected void addCodeSetServiceContext(CorbaConnection conn,
                                          ServiceContexts ctxs,
                                          GIOPVersion giopVersion) {

        // REVISIT.  OMG issue 3318 concerning sending the code set
        // service context more than once was deemed too much for the
        // RTF.  Here's our strategy for the moment:
        //
        // Send it on every request (necessary in cases of fragmentation
        // with multithreaded clients or when the first thing on a
        // connection is a LocateRequest).  Provide an ORB property
        // to disable multiple sends.
        //
        // Note that the connection is null in the local case and no
        // service context is included.  We use the ORB provided
        // encapsulation streams.
        //
        // Also, there will be no negotiation or service context
        // in GIOP 1.0.  ISO8859-1 is used for char/string, and
        // wchar/wstring are illegal.
        //
        if (giopVersion.equals(GIOPVersion.V1_0) || conn == null)
            return;
        
        CodeSetComponentInfo.CodeSetContext codeSetCtx = null;

        if (conn.getBroker().getORBData().alwaysSendCodeSetServiceContext() ||
            !conn.isPostInitialContexts()) {

            // Get the negotiated code sets (if any) out of the connection
            codeSetCtx = conn.getCodeSetContext();
        }

        // Either we shouldn't send the code set service context, or
        // for some reason, the connection doesn't have its code sets.
        // Perhaps the server didn't include them in the IOR.  Uses
        // ISO8859-1 for char and makes wchar/wstring illegal.
        if (codeSetCtx == null)
            return;

        CodeSetServiceContext cssc = new CodeSetServiceContext(codeSetCtx);
	ctxs.put(cssc);
    }    

    protected String peekUserExceptionId(InputObject inputObject)
    {
	CDRInputObject cdrInputObject = (CDRInputObject) inputObject;
	// REVISIT - need interface for mark/reset
        cdrInputObject.mark(Integer.MAX_VALUE);
        String result = cdrInputObject.read_string();
	cdrInputObject.reset();
        return result;
    }                     

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

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

// End of file.