jdk8-mips64-public/corba: src/share/classes/com/sun/corba/se/impl/protocol/CorbaMessageMediatorImpl.java@6845b95cba6b (annotated)

src/share/classes/com/sun/corba/se/impl/protocol/CorbaMessageMediatorImpl.java@6845b95cba6b (annotated)

src/share/classes/com/sun/corba/se/impl/protocol/CorbaMessageMediatorImpl.java

Thu, 31 Aug 2017 18:10:36 +0800

author: aoqi
date: Thu, 31 Aug 2017 18:10:36 +0800
changeset 748: 6845b95cba6b
parent 478: 80161c61aa68
parent 0: 7ef37b2cdcad
permissions: -rw-r--r--

merge

 /*
  * Copyright (c) 2001, 2013, 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.protocol;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.nio.ByteBuffer;
 import java.nio.channels.SelectionKey;
 import java.util.EmptyStackException;
 import java.util.Iterator;
 import org.omg.CORBA.Any;
 import org.omg.CORBA.CompletionStatus;
 import org.omg.CORBA.ExceptionList;
 import org.omg.CORBA.INTERNAL;
 import org.omg.CORBA.Principal;
 import org.omg.CORBA.SystemException;
 import org.omg.CORBA.TypeCode;
 import org.omg.CORBA.UnknownUserException;
 import org.omg.CORBA.UNKNOWN;
 import org.omg.CORBA.portable.ResponseHandler;
 import org.omg.CORBA.portable.UnknownException;
 import org.omg.CORBA_2_3.portable.InputStream;
 import org.omg.CORBA_2_3.portable.OutputStream;
 import org.omg.IOP.ExceptionDetailMessage;
 import org.omg.IOP.TAG_RMI_CUSTOM_MAX_STREAM_FORMAT;
 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.MessageMediator;
 import com.sun.corba.se.pept.protocol.ProtocolHandler;
 import com.sun.corba.se.pept.transport.ByteBufferPool;
 import com.sun.corba.se.pept.transport.Connection;
 import com.sun.corba.se.pept.transport.ContactInfo;
 import com.sun.corba.se.pept.transport.EventHandler;
 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.iiop.GIOPVersion;
 import com.sun.corba.se.spi.ior.iiop.IIOPProfileTemplate;
 import com.sun.corba.se.spi.ior.iiop.IIOPProfile;
 import com.sun.corba.se.spi.ior.iiop.MaxStreamFormatVersionComponent;
 import com.sun.corba.se.spi.oa.OAInvocationInfo;
 import com.sun.corba.se.spi.oa.ObjectAdapter;
 import com.sun.corba.se.spi.orb.ORB;
 import com.sun.corba.se.spi.orb.ORBVersionFactory;
 import com.sun.corba.se.spi.protocol.CorbaMessageMediator;
 import com.sun.corba.se.spi.protocol.CorbaProtocolHandler;
 import com.sun.corba.se.spi.protocol.CorbaServerRequestDispatcher;
 import com.sun.corba.se.spi.protocol.ForwardException;
 import com.sun.corba.se.spi.transport.CorbaConnection;
 import com.sun.corba.se.spi.transport.CorbaContactInfo;
 import com.sun.corba.se.spi.transport.CorbaResponseWaitingRoom;
 import com.sun.corba.se.spi.logging.CORBALogDomains;
 import com.sun.corba.se.spi.servicecontext.ORBVersionServiceContext;
 import com.sun.corba.se.spi.servicecontext.ServiceContexts;
 import com.sun.corba.se.spi.servicecontext.UEInfoServiceContext;
 import com.sun.corba.se.spi.servicecontext.MaxStreamFormatVersionServiceContext;
 import com.sun.corba.se.spi.servicecontext.SendingContextServiceContext;
 import com.sun.corba.se.spi.servicecontext.UnknownServiceContext;
 import com.sun.corba.se.impl.corba.RequestImpl;
 import com.sun.corba.se.impl.encoding.BufferManagerFactory;
 import com.sun.corba.se.impl.encoding.BufferManagerReadStream;
 import com.sun.corba.se.impl.encoding.CDRInputObject;
 import com.sun.corba.se.impl.encoding.CDROutputObject;
 import com.sun.corba.se.impl.encoding.EncapsOutputStream;
 import com.sun.corba.se.impl.logging.ORBUtilSystemException;
 import com.sun.corba.se.impl.logging.InterceptorsSystemException;
 import com.sun.corba.se.impl.orbutil.ORBConstants;
 import com.sun.corba.se.impl.orbutil.ORBUtility;
 import com.sun.corba.se.impl.ior.iiop.JavaSerializationComponent;
 import com.sun.corba.se.impl.protocol.AddressingDispositionException;
 import com.sun.corba.se.impl.protocol.RequestCanceledException;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.AddressingDispositionHelper;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.CancelRequestMessage;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.FragmentMessage_1_1;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.FragmentMessage_1_2;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.LocateRequestMessage;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.LocateRequestMessage_1_0;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.LocateRequestMessage_1_1;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.LocateRequestMessage_1_2;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.LocateReplyOrReplyMessage;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.LocateReplyMessage;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.LocateReplyMessage_1_0;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.LocateReplyMessage_1_1;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.LocateReplyMessage_1_2;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.Message;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.MessageBase;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.MessageHandler;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.ReplyMessage;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.ReplyMessage_1_0;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.ReplyMessage_1_1;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.ReplyMessage_1_2;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.RequestMessage;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.RequestMessage_1_0 ;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.RequestMessage_1_1 ;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.RequestMessage_1_2 ;
 // REVISIT: make sure no memory leaks in client/server request/reply maps.
 // REVISIT: normalize requestHeader, replyHeader, messageHeader.
 /**
  * @author Harold Carr
  */
 public class CorbaMessageMediatorImpl
     implements
         CorbaMessageMediator,
         CorbaProtocolHandler,
         MessageHandler
 {
     protected ORB orb;
     protected ORBUtilSystemException wrapper ;
     protected InterceptorsSystemException interceptorWrapper ;
     protected CorbaContactInfo contactInfo;
     protected CorbaConnection connection;
     protected short addrDisposition;
     protected CDROutputObject outputObject;
     protected CDRInputObject inputObject;
     protected Message messageHeader;
     protected RequestMessage requestHeader;
     protected LocateReplyOrReplyMessage replyHeader;
     protected String replyExceptionDetailMessage;
     protected IOR replyIOR;
     protected Integer requestIdInteger;
     protected Message dispatchHeader;
     protected ByteBuffer dispatchByteBuffer;
     protected byte streamFormatVersion;
     protected boolean streamFormatVersionSet = false;
     protected org.omg.CORBA.Request diiRequest;
     protected boolean cancelRequestAlreadySent = false;
     protected ProtocolHandler protocolHandler;
     protected boolean _executeReturnServantInResponseConstructor = false;
     protected boolean _executeRemoveThreadInfoInResponseConstructor = false;
     protected boolean _executePIInResponseConstructor = false;
     //
     // Client-side constructor.
     //
     public CorbaMessageMediatorImpl(ORB orb,
                                     ContactInfo contactInfo,
                                     Connection connection,
                                     GIOPVersion giopVersion,
                                     IOR ior,
                                     int requestId,
                                     short addrDisposition,
                                     String operationName,
                                     boolean isOneWay)
     {
         this( orb, connection ) ;
         this.contactInfo = (CorbaContactInfo) contactInfo;
         this.addrDisposition = addrDisposition;
         streamFormatVersion =
             getStreamFormatVersionForThisRequest(
                 ((CorbaContactInfo)this.contactInfo).getEffectiveTargetIOR(),
                 giopVersion);
         streamFormatVersionSet = true;
         requestHeader = (RequestMessage) MessageBase.createRequest(
             this.orb,
             giopVersion,
             ORBUtility.getEncodingVersion(orb, ior),
             requestId,
             !isOneWay,
             ((CorbaContactInfo)this.contactInfo).getEffectiveTargetIOR(),
             this.addrDisposition,
             operationName,
             new ServiceContexts(orb),
             null);
     }
     //
     // Acceptor constructor.
     //
     public CorbaMessageMediatorImpl(ORB orb,
                                     Connection connection)
     {
         this.orb = orb;
         this.connection = (CorbaConnection)connection;
         this.wrapper = ORBUtilSystemException.get( orb,
             CORBALogDomains.RPC_PROTOCOL ) ;
         this.interceptorWrapper = InterceptorsSystemException.get( orb,
             CORBALogDomains.RPC_PROTOCOL ) ;
     }
     //
     // Dispatcher constructor.
     //
     // Note: in some cases (e.g., a reply message) this message
     // mediator will only be used for dispatch.  Then the original
     // request side mediator will take over.
     public CorbaMessageMediatorImpl(ORB orb,
                                     CorbaConnection connection,
                                     Message dispatchHeader,
                                     ByteBuffer byteBuffer)
     {
         this( orb, connection ) ;
         this.dispatchHeader = dispatchHeader;
         this.dispatchByteBuffer = byteBuffer;
     }
     ////////////////////////////////////////////////////
     //
     // MessageMediator
     //
     public Broker getBroker()
     {
         return orb;
     }
     public ContactInfo getContactInfo()
     {
         return contactInfo;
     }
     public Connection getConnection()
     {
         return connection;
     }
     public void initializeMessage()
     {
         getRequestHeader().write(outputObject);
     }
     public void finishSendingRequest()
     {
         // REVISIT: probably move logic in outputObject to here.
         outputObject.finishSendingMessage();
     }
     public InputObject waitForResponse()
     {
         if (getRequestHeader().isResponseExpected()) {
             return connection.waitForResponse(this);
         }
         return null;
     }
     public void setOutputObject(OutputObject outputObject)
     {
         this.outputObject = (CDROutputObject) outputObject;
     }
     public OutputObject getOutputObject()
     {
         return outputObject;
     }
     public void setInputObject(InputObject inputObject)
     {
         this.inputObject = (CDRInputObject) inputObject;
     }
     public InputObject getInputObject()
     {
         return inputObject;
     }
     ////////////////////////////////////////////////////
     //
     // CorbaMessageMediator
     //
     public void setReplyHeader(LocateReplyOrReplyMessage header)
     {
         this.replyHeader = header;
         this.replyIOR = header.getIOR(); // REVISIT - need separate field?
     }
     public LocateReplyMessage getLocateReplyHeader()
     {
         return (LocateReplyMessage) replyHeader;
     }
     public ReplyMessage getReplyHeader()
     {
         return (ReplyMessage) replyHeader;
     }
     public void setReplyExceptionDetailMessage(String message)
     {
         replyExceptionDetailMessage = message;
     }
     public RequestMessage getRequestHeader()
     {
         return requestHeader;
     }
     public GIOPVersion getGIOPVersion()
     {
         if (messageHeader != null) {
             return messageHeader.getGIOPVersion();
         }
         return getRequestHeader().getGIOPVersion();
     }
     public byte getEncodingVersion() {
         if (messageHeader != null) {
             return messageHeader.getEncodingVersion();
         }
         return getRequestHeader().getEncodingVersion();
     }
     public int getRequestId()
     {
         return getRequestHeader().getRequestId();
     }
     public Integer getRequestIdInteger()
     {
         if (requestIdInteger == null) {
             requestIdInteger = new Integer(getRequestHeader().getRequestId());
         }
         return requestIdInteger;
     }
     public boolean isOneWay()
     {
         return ! getRequestHeader().isResponseExpected();
     }
     public short getAddrDisposition()
     {
         return addrDisposition;
     }
     public String getOperationName()
     {
         return getRequestHeader().getOperation();
     }
     public ServiceContexts getRequestServiceContexts()
     {
         return getRequestHeader().getServiceContexts();
     }
     public ServiceContexts getReplyServiceContexts()
     {
         return getReplyHeader().getServiceContexts();
     }
     public void sendCancelRequestIfFinalFragmentNotSent()
     {
         if ((!sentFullMessage()) && sentFragment() &&
             (!cancelRequestAlreadySent))
         {
             try {
                 if (orb.subcontractDebugFlag) {
                     dprint(".sendCancelRequestIfFinalFragmentNotSent->: "
                            + opAndId(this));
                 }
                 connection.sendCancelRequestWithLock(getGIOPVersion(),
                                                      getRequestId());
                 // Case: first a location forward, then a marshaling
                 // exception (e.g., non-serializable object).  Only
                 // send cancel once.
                 cancelRequestAlreadySent = true;
             } catch (IOException e) {
                 if (orb.subcontractDebugFlag) {
                     dprint(".sendCancelRequestIfFinalFragmentNotSent: !ERROR : " + opAndId(this),
                            e);
                 }
                 // REVISIT: we could attempt to send a final incomplete
                 // fragment in this case.
                 throw interceptorWrapper.ioexceptionDuringCancelRequest(
                     CompletionStatus.COMPLETED_MAYBE, e );
             } finally {
                 if (orb.subcontractDebugFlag) {
                     dprint(".sendCancelRequestIfFinalFragmentNotSent<-: "
                            + opAndId(this));
                 }
             }
         }
     }
     public boolean sentFullMessage()
     {
         return outputObject.getBufferManager().sentFullMessage();
     }
     public boolean sentFragment()
     {
         return outputObject.getBufferManager().sentFragment();
     }
     public void setDIIInfo(org.omg.CORBA.Request diiRequest)
     {
         this.diiRequest = diiRequest;
     }
     public boolean isDIIRequest()
     {
         return diiRequest != null;
     }
     public Exception unmarshalDIIUserException(String repoId, InputStream is)
     {
         if (! isDIIRequest()) {
             return null;
         }
         ExceptionList _exceptions = diiRequest.exceptions();
         try {
             // Find the typecode for the exception
             for (int i=0; i<_exceptions.count() ; i++) {
                 TypeCode tc = _exceptions.item(i);
                 if ( tc.id().equals(repoId) ) {
                     // Since we dont have the actual user exception
                     // class, the spec says we have to create an
                     // UnknownUserException and put it in the
                     // environment.
                     Any eany = orb.create_any();
                     eany.read_value(is, (TypeCode)tc);
                     return new UnknownUserException(eany);
                 }
             }
         } catch (Exception b) {
             throw wrapper.unexpectedDiiException(b);
         }
         // must be a truly unknown exception
         return wrapper.unknownCorbaExc( CompletionStatus.COMPLETED_MAYBE);
     }
     public void setDIIException(Exception exception)
     {
         diiRequest.env().exception(exception);
     }
     public void handleDIIReply(InputStream inputStream)
     {
         if (! isDIIRequest()) {
             return;
         }
         ((RequestImpl)diiRequest).unmarshalReply(inputStream);
     }
     public Message getDispatchHeader()
     {
         return dispatchHeader;
     }
     public void setDispatchHeader(Message msg)
     {
         dispatchHeader = msg;
     }
     public ByteBuffer getDispatchBuffer()
     {
         return dispatchByteBuffer;
     }
     public void setDispatchBuffer(ByteBuffer byteBuffer)
     {
         dispatchByteBuffer = byteBuffer;
     }
     public int getThreadPoolToUse() {
         int poolToUse = 0;
         Message msg = getDispatchHeader();
         // A null msg should never happen. But, we'll be
         // defensive just in case.
         if (msg != null) {
             poolToUse = msg.getThreadPoolToUse();
         }
         return poolToUse;
     }
     public byte getStreamFormatVersion()
     {
         // REVISIT: ContactInfo/Acceptor output object factories
         // just use this.  Maybe need to distinguish:
         //    createOutputObjectForRequest
         //    createOutputObjectForReply
         // then do getStreamFormatVersionForRequest/ForReply here.
         if (streamFormatVersionSet) {
             return streamFormatVersion;
         }
         return getStreamFormatVersionForReply();
     }
     /**
      * If the RMI-IIOP maximum stream format version service context
      * is present, it indicates the maximum stream format version we
      * could use for the reply.  If it isn't present, the default is
      * 2 for GIOP 1.3 or greater, 1 for lower.
      *
      * This is only sent on requests.  Clients can find out the
      * server's maximum by looking for a tagged component in the IOR.
      */
     public byte getStreamFormatVersionForReply() {
         // NOTE: The request service contexts may indicate the max.
         ServiceContexts svc = getRequestServiceContexts();
         MaxStreamFormatVersionServiceContext msfvsc
             = (MaxStreamFormatVersionServiceContext)svc.get(
                 MaxStreamFormatVersionServiceContext.SERVICE_CONTEXT_ID);
         if (msfvsc != null) {
             byte localMaxVersion = ORBUtility.getMaxStreamFormatVersion();
             byte remoteMaxVersion = msfvsc.getMaximumStreamFormatVersion();
             return (byte)Math.min(localMaxVersion, remoteMaxVersion);
         } else {
             // Defaults to 1 for GIOP 1.2 or less, 2 for
             // GIOP 1.3 or higher.
             if (getGIOPVersion().lessThan(GIOPVersion.V1_3))
                 return ORBConstants.STREAM_FORMAT_VERSION_1;
             else
                 return ORBConstants.STREAM_FORMAT_VERSION_2;
         }
     }
     public boolean isSystemExceptionReply()
     {
         return replyHeader.getReplyStatus() == ReplyMessage.SYSTEM_EXCEPTION;
     }
     public boolean isUserExceptionReply()
     {
         return replyHeader.getReplyStatus() == ReplyMessage.USER_EXCEPTION;
     }
     public boolean isLocationForwardReply()
     {
         return ( (replyHeader.getReplyStatus() == ReplyMessage.LOCATION_FORWARD) ||
                  (replyHeader.getReplyStatus() == ReplyMessage.LOCATION_FORWARD_PERM) );
         //return replyHeader.getReplyStatus() == ReplyMessage.LOCATION_FORWARD;
     }
     public boolean isDifferentAddrDispositionRequestedReply()
     {
         return replyHeader.getReplyStatus() == ReplyMessage.NEEDS_ADDRESSING_MODE;
     }
     public short getAddrDispositionReply()
     {
         return replyHeader.getAddrDisposition();
     }
     public IOR getForwardedIOR()
     {
         return replyHeader.getIOR();
     }
     public SystemException getSystemExceptionReply()
     {
         return replyHeader.getSystemException(replyExceptionDetailMessage);
     }
     ////////////////////////////////////////////////////
     //
     // Used by server side.
     //
     public ObjectKey getObjectKey()
     {
         return getRequestHeader().getObjectKey();
     }
     public void setProtocolHandler(CorbaProtocolHandler protocolHandler)
     {
         throw wrapper.methodShouldNotBeCalled() ;
     }
     public CorbaProtocolHandler getProtocolHandler()
     {
         // REVISIT: should look up in orb registry.
         return this;
     }
     ////////////////////////////////////////////////////
     //
     // ResponseHandler
     //
     public org.omg.CORBA.portable.OutputStream createReply()
     {
         // Note: relies on side-effect of setting mediator output field.
         // REVISIT - cast - need interface
         getProtocolHandler().createResponse(this, (ServiceContexts) null);
         return (OutputStream) getOutputObject();
     }
     public org.omg.CORBA.portable.OutputStream createExceptionReply()
     {
         // Note: relies on side-effect of setting mediator output field.
         // REVISIT - cast - need interface
         getProtocolHandler().createUserExceptionResponse(this, (ServiceContexts) null);
         return (OutputStream) getOutputObject();
     }
     public boolean executeReturnServantInResponseConstructor()
     {
         return _executeReturnServantInResponseConstructor;
     }
     public void setExecuteReturnServantInResponseConstructor(boolean b)
     {
         _executeReturnServantInResponseConstructor = b;
     }
     public boolean executeRemoveThreadInfoInResponseConstructor()
     {
         return _executeRemoveThreadInfoInResponseConstructor;
     }
     public void setExecuteRemoveThreadInfoInResponseConstructor(boolean b)
     {
         _executeRemoveThreadInfoInResponseConstructor = b;
     }
     public boolean executePIInResponseConstructor()
     {
         return _executePIInResponseConstructor;
     }
     public void setExecutePIInResponseConstructor( boolean b )
     {
         _executePIInResponseConstructor = b;
     }
     private byte getStreamFormatVersionForThisRequest(IOR ior,
                                                       GIOPVersion giopVersion)
     {
         byte localMaxVersion
             = ORBUtility.getMaxStreamFormatVersion();
         IOR effectiveTargetIOR =
             ((CorbaContactInfo)this.contactInfo).getEffectiveTargetIOR();
         IIOPProfileTemplate temp =
             (IIOPProfileTemplate)effectiveTargetIOR.getProfile().getTaggedProfileTemplate();
         Iterator iter = temp.iteratorById(TAG_RMI_CUSTOM_MAX_STREAM_FORMAT.value);
         if (!iter.hasNext()) {
             // Didn't have the max stream format version tagged
             // component.
             if (giopVersion.lessThan(GIOPVersion.V1_3))
                 return ORBConstants.STREAM_FORMAT_VERSION_1;
             else
                 return ORBConstants.STREAM_FORMAT_VERSION_2;
         }
         byte remoteMaxVersion
             = ((MaxStreamFormatVersionComponent)iter.next()).getMaxStreamFormatVersion();
         return (byte)Math.min(localMaxVersion, remoteMaxVersion);
     }
     ////////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////////////////////////////////
     // REVISIT - This could be a separate implementation object looked
     // up in a registry.  However it needs some state in the message
     // mediator so combine for now.
     protected boolean isThreadDone = false;
     ////////////////////////////////////////////////////
     //
     // pept.protocol.ProtocolHandler
     //
     public boolean handleRequest(MessageMediator messageMediator)
     {
         try {
             dispatchHeader.callback(this);
         } catch (IOException e) {
             // REVISIT - this should be handled internally.
             ;
         }
         return isThreadDone;
     }
     ////////////////////////////////////////////////////
     //
     // iiop.messages.MessageHandler
     //
     private void setWorkThenPoolOrResumeSelect(Message header)
     {
         if (getConnection().getEventHandler().shouldUseSelectThreadToWait()) {
             resumeSelect(header);
         } else {
             // Leader/Follower when using reader thread.
             // When this thread is done working it will go back in pool.
             isThreadDone = true;
             // First unregister current registration.
             orb.getTransportManager().getSelector(0)
                 .unregisterForEvent(getConnection().getEventHandler());
             // Have another thread become the reader.
             orb.getTransportManager().getSelector(0)
                 .registerForEvent(getConnection().getEventHandler());
         }
     }
     private void setWorkThenReadOrResumeSelect(Message header)
     {
         if (getConnection().getEventHandler().shouldUseSelectThreadToWait()) {
             resumeSelect(header);
         } else {
             // When using reader thread then wen this thread is
             // done working it will continue reading.
             isThreadDone = false;
         }
     }
     private void resumeSelect(Message header)
     {
         // NOTE: VERY IMPORTANT:
         // Only participate in select after getting to the point
         // that proper serialization of fragments is ensured.
         if (transportDebug()) {
             dprint(".resumeSelect:->");
             // REVISIT: not-OO:
             String requestId = "?";
             if (header instanceof RequestMessage) {
                 requestId =
                     new Integer(((RequestMessage)header)
                                 .getRequestId()).toString();
             } else if (header instanceof ReplyMessage) {
                 requestId =
                     new Integer(((ReplyMessage)header)
                                 .getRequestId()).toString();
             } else if (header instanceof FragmentMessage_1_2) {
                 requestId =
                     new Integer(((FragmentMessage_1_2)header)
                                 .getRequestId()).toString();
             }
             dprint(".resumeSelect: id/"
                    + requestId
                    + " " + getConnection()
                    );
         }
         // IMPORTANT: To avoid bug (4953599), we force the Thread that does the NIO select
         // to also do the enable/disable of Ops using SelectionKey.interestOps(Ops of Interest).
         // Otherwise, the SelectionKey.interestOps(Ops of Interest) may block indefinitely in
         // this thread.
         EventHandler eventHandler = getConnection().getEventHandler();
         orb.getTransportManager().getSelector(0).registerInterestOps(eventHandler);
         if (transportDebug()) {
             dprint(".resumeSelect:<-");
         }
     }
     private void setInputObject()
     {
         // REVISIT: refactor createInputObject (and createMessageMediator)
         // into base PlugInFactory.  Get via connection (either ContactInfo
         // or Acceptor).
         if (getConnection().getContactInfo() != null) {
             inputObject = (CDRInputObject)
                 getConnection().getContactInfo()
                 .createInputObject(orb, this);
         } else if (getConnection().getAcceptor() != null) {
             inputObject = (CDRInputObject)
                 getConnection().getAcceptor()
                 .createInputObject(orb, this);
         } else {
             throw new RuntimeException("CorbaMessageMediatorImpl.setInputObject");
         }
         inputObject.setMessageMediator(this);
         setInputObject(inputObject);
     }
     private void signalResponseReceived()
     {
         // This will end up using the MessageMediator associated with
         // the original request instead of the current mediator (which
         // need to be constructed to hold the dispatchBuffer and connection).
         connection.getResponseWaitingRoom()
             .responseReceived((InputObject)inputObject);
     }
     // This handles message types for which we don't create classes.
     public void handleInput(Message header) throws IOException
     {
         try {
             messageHeader = header;
             if (transportDebug())
                 dprint(".handleInput->: "
                        + MessageBase.typeToString(header.getType()));
             setWorkThenReadOrResumeSelect(header);
             switch(header.getType())
             {
             case Message.GIOPCloseConnection:
                 if (transportDebug()) {
                     dprint(".handleInput: CloseConnection: purging");
                 }
                 connection.purgeCalls(wrapper.connectionRebind(), true, false);
                 break;
             case Message.GIOPMessageError:
                 if (transportDebug()) {
                     dprint(".handleInput: MessageError: purging");
                 }
                 connection.purgeCalls(wrapper.recvMsgError(), true, false);
                 break;
             default:
                 if (transportDebug()) {
                     dprint(".handleInput: ERROR: "
                            + MessageBase.typeToString(header.getType()));
                 }
                 throw wrapper.badGiopRequestType() ;
             }
             releaseByteBufferToPool();
         } finally {
             if (transportDebug()) {
                 dprint(".handleInput<-: "
                        + MessageBase.typeToString(header.getType()));
             }
         }
     }
     public void handleInput(RequestMessage_1_0 header) throws IOException
     {
         try {
             if (transportDebug()) dprint(".REQUEST 1.0->: " + header);
             try {
                 messageHeader = requestHeader = (RequestMessage) header;
                 setInputObject();
             } finally {
                 setWorkThenPoolOrResumeSelect(header);
             }
             getProtocolHandler().handleRequest(header, this);
         } catch (Throwable t) {
             if (transportDebug())
                 dprint(".REQUEST 1.0: !!ERROR!!: " + header, t);
             // Mask the exception from thread.;
         } finally {
             if (transportDebug()) dprint(".REQUEST 1.0<-: " + header);
         }
     }
     public void handleInput(RequestMessage_1_1 header) throws IOException
     {
         try {
             if (transportDebug()) dprint(".REQUEST 1.1->: " + header);
             try {
                 messageHeader = requestHeader = (RequestMessage) header;
                 setInputObject();
                 connection.serverRequest_1_1_Put(this);
             } finally {
                 setWorkThenPoolOrResumeSelect(header);
             }
             getProtocolHandler().handleRequest(header, this);
         } catch (Throwable t) {
             if (transportDebug())
                 dprint(".REQUEST 1.1: !!ERROR!!: " + header, t);
             // Mask the exception from thread.;
         } finally {
             if (transportDebug()) dprint(".REQUEST 1.1<-: " + header);
         }
     }
     // REVISIT: this is identical to 1_0 except for fragment part.
     public void handleInput(RequestMessage_1_2 header) throws IOException
     {
         try {
             try {
                 messageHeader = requestHeader = (RequestMessage) header;
                 header.unmarshalRequestID(dispatchByteBuffer);
                 setInputObject();
                 if (transportDebug()) dprint(".REQUEST 1.2->: id/"
                                              + header.getRequestId()
                                              + ": "
                                              + header);
                 // NOTE: in the old code this used to be done conditionally:
                 // if (header.moreFragmentsToFollow()).
                 // Now we always put it in. We take it out when
                 // the response is done.
                 // This must happen now so if a header is fragmented the stream
                 // may be found.
                 connection.serverRequestMapPut(header.getRequestId(), this);
             } finally {
                 // Leader/Follower.
                 // Note: This *MUST* come after putting stream in above map
                 // since the header may be fragmented and you do not want to
                 // start reading again until the map above is set.
                 setWorkThenPoolOrResumeSelect(header);
             }
             //inputObject.unmarshalHeader(); // done in subcontract.
             getProtocolHandler().handleRequest(header, this);
         } catch (Throwable t) {
             if (transportDebug()) dprint(".REQUEST 1.2: id/"
                                          + header.getRequestId()
                                          + ": !!ERROR!!: "
                                          + header,
                                          t);
             // Mask the exception from thread.;
         } finally {
             connection.serverRequestMapRemove(header.getRequestId());
             if (transportDebug()) dprint(".REQUEST 1.2<-: id/"
                                          + header.getRequestId()
                                          + ": "
                                          + header);
         }
     }
     public void handleInput(ReplyMessage_1_0 header) throws IOException
     {
         try {
             try {
                 if (transportDebug()) dprint(".REPLY 1.0->: " + header);
                 messageHeader = replyHeader = (ReplyMessage) header;
                 setInputObject();
                 // REVISIT: this should be done by waiting thread.
                 inputObject.unmarshalHeader();
                 signalResponseReceived();
             } finally{
                 setWorkThenReadOrResumeSelect(header);
             }
         } catch (Throwable t) {
             if (transportDebug())dprint(".REPLY 1.0: !!ERROR!!: " + header, t);
             // Mask the exception from thread.;
         } finally {
             if (transportDebug()) dprint(".REPLY 1.0<-: " + header);
         }
     }
     public void handleInput(ReplyMessage_1_1 header) throws IOException
     {
         try {
             if (transportDebug()) dprint(".REPLY 1.1->: " + header);
             messageHeader = replyHeader = (ReplyMessage) header;
             setInputObject();
             if (header.moreFragmentsToFollow()) {
                 // More fragments are coming to complete this reply, so keep
                 // a reference to the InputStream so we can add the fragments
                 connection.clientReply_1_1_Put(this);
                 // In 1.1, we can't assume that we have the request ID in the
                 // first fragment.  Thus, another thread is used
                 // to be the reader while this thread unmarshals
                 // the extended header and wakes up the client thread.
                 setWorkThenPoolOrResumeSelect(header);
                 // REVISIT - error handling.
                 // This must be done now.
                 inputObject.unmarshalHeader();
                 signalResponseReceived();
             } else {
                 // Not fragmented, therefore we know the request
                 // ID is here.  Thus, we can unmarshal the extended header
                 // and wake up the client thread without using a third
                 // thread as above.
                 // REVISIT - error handling during unmarshal.
                 // This must be done now to get the request id.
                 inputObject.unmarshalHeader();
                 signalResponseReceived();
                 setWorkThenReadOrResumeSelect(header);
             }
         } catch (Throwable t) {
             if (transportDebug()) dprint(".REPLY 1.1: !!ERROR!!: " + header);
             // Mask the exception from thread.;
         } finally {
             if (transportDebug()) dprint(".REPLY 1.1<-: " + header);
         }
     }
     public void handleInput(ReplyMessage_1_2 header) throws IOException
     {
         try {
             try {
                 messageHeader = replyHeader = (ReplyMessage) header;
                 // We know that the request ID is in the first fragment
                 header.unmarshalRequestID(dispatchByteBuffer);
                 if (transportDebug()) {
                     dprint(".REPLY 1.2->: id/"
                            + + header.getRequestId()
                            + ": more?: " + header.moreFragmentsToFollow()
                            + ": " + header);
                 }
                 setInputObject();
                 signalResponseReceived();
             } finally {
                 setWorkThenReadOrResumeSelect(header);
             }
         } catch (Throwable t) {
             if (transportDebug()) dprint(".REPLY 1.2: id/"
                                          + header.getRequestId()
                                          + ": !!ERROR!!: "
                                          + header, t);
             // Mask the exception from thread.;
         } finally {
             if (transportDebug()) dprint(".REPLY 1.2<-: id/"
                                          + header.getRequestId()
                                          + ": "
                                          + header);
         }
     }
     public void handleInput(LocateRequestMessage_1_0 header) throws IOException
     {
         try {
             if (transportDebug())
                 dprint(".LOCATE_REQUEST 1.0->: " + header);
             try {
                 messageHeader = header;
                 setInputObject();
             } finally {
                 setWorkThenPoolOrResumeSelect(header);
             }
             getProtocolHandler().handleRequest(header, this);
         } catch (Throwable t) {
             if (transportDebug())
                 dprint(".LOCATE_REQUEST 1.0: !!ERROR!!: " + header, t);
             // Mask the exception from thread.;
         } finally {
             if (transportDebug())
                 dprint(".LOCATE_REQUEST 1.0<-: " + header);
         }
     }
     public void handleInput(LocateRequestMessage_1_1 header) throws IOException
     {
         try {
             if (transportDebug())
                 dprint(".LOCATE_REQUEST 1.1->: " + header);
             try {
                 messageHeader = header;
                 setInputObject();
             } finally {
                 setWorkThenPoolOrResumeSelect(header);
             }
             getProtocolHandler().handleRequest(header, this);
         } catch (Throwable t) {
             if (transportDebug())
                 dprint(".LOCATE_REQUEST 1.1: !!ERROR!!: " + header, t);
             // Mask the exception from thread.;
         } finally {
             if (transportDebug())
                 dprint(".LOCATE_REQUEST 1.1<-:" + header);
         }
     }
     public void handleInput(LocateRequestMessage_1_2 header) throws IOException
     {
         try {
             try {
                 messageHeader = header;
                 header.unmarshalRequestID(dispatchByteBuffer);
                 setInputObject();
                 if (transportDebug())
                     dprint(".LOCATE_REQUEST 1.2->: id/"
                            + header.getRequestId()
                            + ": "
                            + header);
                 if (header.moreFragmentsToFollow()) {
                     connection.serverRequestMapPut(header.getRequestId(),this);
                 }
             } finally {
                 setWorkThenPoolOrResumeSelect(header);
             }
             getProtocolHandler().handleRequest(header, this);
         } catch (Throwable t) {
             if (transportDebug())
                 dprint(".LOCATE_REQUEST 1.2: id/"
                        + header.getRequestId()
                        + ": !!ERROR!!: "
                        + header, t);
             // Mask the exception from thread.;
         } finally {
             if (transportDebug())
                 dprint(".LOCATE_REQUEST 1.2<-: id/"
                        + header.getRequestId()
                        + ": "
                        + header);
         }
     }
     public void handleInput(LocateReplyMessage_1_0 header) throws IOException
     {
         try {
             if (transportDebug())
                 dprint(".LOCATE_REPLY 1.0->:" + header);
             try {
                 messageHeader = header;
                 setInputObject();
                 inputObject.unmarshalHeader(); // REVISIT Put in subcontract.
                 signalResponseReceived();
             } finally {
                 setWorkThenReadOrResumeSelect(header);
             }
         } catch (Throwable t) {
             if (transportDebug())
                 dprint(".LOCATE_REPLY 1.0: !!ERROR!!: " + header, t);
             // Mask the exception from thread.;
         } finally {
             if (transportDebug())
                 dprint(".LOCATE_REPLY 1.0<-: " + header);
         }
     }
     public void handleInput(LocateReplyMessage_1_1 header) throws IOException
     {
         try {
             if (transportDebug()) dprint(".LOCATE_REPLY 1.1->: " + header);
             try {
                 messageHeader = header;
                 setInputObject();
                 // Fragmented LocateReplies are not allowed in 1.1.
                 inputObject.unmarshalHeader();
                 signalResponseReceived();
             } finally {
                 setWorkThenReadOrResumeSelect(header);
             }
         } catch (Throwable t) {
             if (transportDebug())
                 dprint(".LOCATE_REPLY 1.1: !!ERROR!!: " + header, t);
             // Mask the exception from thread.;
         } finally {
             if (transportDebug()) dprint(".LOCATE_REPLY 1.1<-: " + header);
         }
     }
     public void handleInput(LocateReplyMessage_1_2 header) throws IOException
     {
         try {
             try {
                 messageHeader = header;
                 // No need to put in client reply map - already there.
                 header.unmarshalRequestID(dispatchByteBuffer);
                 setInputObject();
                 if (transportDebug()) dprint(".LOCATE_REPLY 1.2->: id/"
                                              + header.getRequestId()
                                              + ": "
                                              + header);
                 signalResponseReceived();
             } finally {
                 setWorkThenPoolOrResumeSelect(header); // REVISIT
             }
         } catch (Throwable t) {
             if (transportDebug())
                 dprint(".LOCATE_REPLY 1.2: id/"
                        + header.getRequestId()
                        + ": !!ERROR!!: "
                        + header, t);
             // Mask the exception from thread.;
         } finally {
             if (transportDebug()) dprint(".LOCATE_REPLY 1.2<-: id/"
                                          + header.getRequestId()
                                          + ": "
                                          + header);
         }
     }
     public void handleInput(FragmentMessage_1_1 header) throws IOException
     {
         try {
             if (transportDebug()) {
                 dprint(".FRAGMENT 1.1->: "
                        + "more?: " + header.moreFragmentsToFollow()
                        + ": " + header);
             }
             try {
                 messageHeader = header;
                 MessageMediator mediator = null;
                 CDRInputObject inputObject = null;
                 if (connection.isServer()) {
                     mediator = connection.serverRequest_1_1_Get();
                 } else {
                     mediator = connection.clientReply_1_1_Get();
                 }
                 if (mediator != null) {
                     inputObject = (CDRInputObject) mediator.getInputObject();
                 }
                 // If no input stream available, then discard the fragment.
                 // This can happen:
                 // 1. if a fragment message is received prior to receiving
                 //    the original request/reply message. Very unlikely.
                 // 2. if a fragment message is received after the
                 //    reply has been sent (early replies)
                 // Note: In the case of early replies, the fragments received
                 // during the request processing (which are never unmarshaled),
                 // will eventually be discarded by the GC.
                 if (inputObject == null) {
                     if (transportDebug())
                         dprint(".FRAGMENT 1.1: ++++DISCARDING++++: " + header);
                     // need to release dispatchByteBuffer to pool if
                     // we are discarding
                     releaseByteBufferToPool();
                     return;
                 }
                 inputObject.getBufferManager()
                     .processFragment(dispatchByteBuffer, header);
                 if (! header.moreFragmentsToFollow()) {
                     if (connection.isServer()) {
                         connection.serverRequest_1_1_Remove();
                     } else {
                         connection.clientReply_1_1_Remove();
                     }
                 }
             } finally {
                 // NOTE: This *must* come after queing the fragment
                 // when using the selector to ensure fragments stay in order.
                 setWorkThenReadOrResumeSelect(header);
             }
         } catch (Throwable t) {
             if (transportDebug())
                 dprint(".FRAGMENT 1.1: !!ERROR!!: " + header, t);
             // Mask the exception from thread.;
         } finally {
             if (transportDebug()) dprint(".FRAGMENT 1.1<-: " + header);
         }
     }
     public void handleInput(FragmentMessage_1_2 header) throws IOException
     {
         try {
             try {
                 messageHeader = header;
                 // Note:  We know it's a 1.2 fragment, we have the data, but
                 // we need the IIOPInputStream instance to unmarshal the
                 // request ID... but we need the request ID to get the
                 // IIOPInputStream instance. So we peek at the raw bytes.
                 header.unmarshalRequestID(dispatchByteBuffer);
                 if (transportDebug()) {
                     dprint(".FRAGMENT 1.2->: id/"
                            + header.getRequestId()
                            + ": more?: " + header.moreFragmentsToFollow()
                            + ": " + header);
                 }
                 MessageMediator mediator = null;
                 InputObject inputObject = null;
                 if (connection.isServer()) {
                     mediator =
                         connection.serverRequestMapGet(header.getRequestId());
                 } else {
                     mediator =
                         connection.clientRequestMapGet(header.getRequestId());
                 }
                 if (mediator != null) {
                     inputObject = mediator.getInputObject();
                 }
                 // See 1.1 comments.
                 if (inputObject == null) {
                     if (transportDebug()) {
                         dprint(".FRAGMENT 1.2: id/"
                                + header.getRequestId()
                                + ": ++++DISCARDING++++: "
                                + header);
                     }
                     // need to release dispatchByteBuffer to pool if
                     // we are discarding
                     releaseByteBufferToPool();
                     return;
                 }
                 ((CDRInputObject)inputObject)
                     .getBufferManager().processFragment(
                                      dispatchByteBuffer, header);
                 // REVISIT: but if it is a server don't you have to remove the
                 // stream from the map?
                 if (! connection.isServer()) {
                     /* REVISIT
                      * No need to do anything.
                      * Should we mark that last was received?
                      if (! header.moreFragmentsToFollow()) {
                      // Last fragment.
                      }
                     */
                 }
             } finally {
                 // NOTE: This *must* come after queing the fragment
                 // when using the selector to ensure fragments stay in order.
                 setWorkThenReadOrResumeSelect(header);
             }
         } catch (Throwable t) {
             if (transportDebug())
                 dprint(".FRAGMENT 1.2: id/"
                        + header.getRequestId()
                        + ": !!ERROR!!: "
                        + header, t);
             // Mask the exception from thread.;
         } finally {
             if (transportDebug()) dprint(".FRAGMENT 1.2<-: id/"
                                          + header.getRequestId()
                                          + ": "
                                          + header);
         }
     }
     public void handleInput(CancelRequestMessage header) throws IOException
     {
         try {
             try {
                 messageHeader = header;
                 setInputObject();
                 // REVISIT: Move these two to subcontract.
                 inputObject.unmarshalHeader();
                 if (transportDebug()) dprint(".CANCEL->: id/"
                                              + header.getRequestId() + ": "
                                              + header.getGIOPVersion() + ": "
                                              + header);
                 processCancelRequest(header.getRequestId());
                 releaseByteBufferToPool();
             } finally {
                 setWorkThenReadOrResumeSelect(header);
             }
         } catch (Throwable t) {
             if (transportDebug()) dprint(".CANCEL: id/"
                                          + header.getRequestId()
                                          + ": !!ERROR!!: "
                                          + header, t);
             // Mask the exception from thread.;
         } finally {
             if (transportDebug()) dprint(".CANCEL<-: id/"
                                          + header.getRequestId() + ": "
                                          + header.getGIOPVersion() + ": "
                                          + header);
         }
     }
     private void throwNotImplemented()
     {
         isThreadDone = false;
         throwNotImplemented("");
     }
     private void throwNotImplemented(String msg)
     {
         throw new RuntimeException("CorbaMessageMediatorImpl: not implemented " + msg);
     }
     private void dprint(String msg, Throwable t)
     {
         dprint(msg);
         t.printStackTrace(System.out);
     }
     private void dprint(String msg)
     {
         ORBUtility.dprint("CorbaMessageMediatorImpl", msg);
     }
     protected String opAndId(CorbaMessageMediator mediator)
     {
         return ORBUtility.operationNameAndRequestId(mediator);
     }
     private boolean transportDebug()
     {
         return orb.transportDebugFlag;
     }
     // REVISIT: move this to subcontract (but both client and server need it).
     private final void processCancelRequest(int cancelReqId) {
         // The GIOP version of CancelRequest does not matter, since
         // CancelRequest_1_0 could be sent to cancel a request which
         // has a different GIOP version.
         /*
          * CancelRequest processing logic :
          *
          *  - find the request with matching requestId
          *
          *  - call cancelProcessing() in BufferManagerRead [BMR]
          *
          *  - the hope is that worker thread would call BMR.underflow()
          *    to wait for more fragments to come in. When BMR.underflow() is
          *    called, if a CancelRequest had already arrived,
          *    the worker thread would throw ThreadDeath,
          *    else the thread would wait to be notified of the
          *    arrival of a new fragment or CancelRequest. Upon notification,
          *    the woken up thread would check to see if a CancelRequest had
          *    arrived and if so throw a ThreadDeath or it will continue to
          *    process the received fragment.
          *
          *  - if all the fragments had been received prior to CancelRequest
          *    then the worker thread would never block in BMR.underflow().
          *    So, setting the abort flag in BMR has no effect. The request
          *    processing will complete normally.
          *
          *  - in the case where the server has received enough fragments to
          *    start processing the request and the server sends out
          *    an early reply. In such a case if the CancelRequest arrives
          *    after the reply has been sent, it has no effect.
          */
         if (!connection.isServer()) {
             return; // we do not support bi-directional giop yet, ignore.
         }
         // Try to get hold of the InputStream buffer.
         // In the case of 1.0 requests there is no way to get hold of
         // InputStream. Try out the 1.1 and 1.2 cases.
         // was the request 1.2 ?
         MessageMediator mediator = connection.serverRequestMapGet(cancelReqId);
         int requestId ;
         if (mediator == null) {
             // was the request 1.1 ?
             mediator = connection.serverRequest_1_1_Get();
             if (mediator == null) {
                 // XXX log this!
                 // either the request was 1.0
                 // or an early reply has already been sent
                 // or request processing is over
                 // or its a spurious CancelRequest
                 return; // do nothing.
             }
             requestId = ((CorbaMessageMediator) mediator).getRequestId();
             if (requestId != cancelReqId) {
                 // A spurious 1.1 CancelRequest has been received.
                 // XXX log this!
                 return; // do nothing
             }
             if (requestId == 0) { // special case
                 // XXX log this
                 // this means that
                 // 1. the 1.1 requests' requestId has not been received
                 //    i.e., a CancelRequest was received even before the
                 //    1.1 request was received. The spec disallows this.
                 // 2. or the 1.1 request has a requestId 0.
                 //
                 // It is a little tricky to distinguish these two. So, be
                 // conservative and do not cancel the request. Downside is that
                 // 1.1 requests with requestId of 0 will never be cancelled.
                 return; // do nothing
             }
         } else {
             requestId = ((CorbaMessageMediator) mediator).getRequestId();
         }
         Message msg = ((CorbaMessageMediator)mediator).getRequestHeader();
         if (msg.getType() != Message.GIOPRequest) {
             // Any mediator obtained here should only ever be for a GIOP
             // request.
             wrapper.badMessageTypeForCancel() ;
         }
         // At this point we have a valid message mediator that contains
         // a valid requestId.
         // at this point we have chosen a request to be cancelled. But we
         // do not know if the target object's method has been invoked or not.
         // Request input stream being available simply means that the request
         // processing is not over yet. simply set the abort flag in the
         // BMRS and hope that the worker thread would notice it (this can
         // happen only if the request stream is being unmarshalled and the
         // target's method has not been invoked yet). This guarantees
         // that the requests which have been dispatched to the
         // target's method will never be cancelled.
         BufferManagerReadStream bufferManager = (BufferManagerReadStream)
             ((CDRInputObject)mediator.getInputObject()).getBufferManager();
         bufferManager.cancelProcessing(cancelReqId);
     }
     ////////////////////////////////////////////////////
     //
     // spi.protocol.CorbaProtocolHandler
     //
     public void handleRequest(RequestMessage msg,
                               CorbaMessageMediator messageMediator)
     {
         try {
             beginRequest(messageMediator);
             try {
                 handleRequestRequest(messageMediator);
                 if (messageMediator.isOneWay()) {
                     return;
                 }
             } catch (Throwable t) {
                 if (messageMediator.isOneWay()) {
                     return;
                 }
                 handleThrowableDuringServerDispatch(
                     messageMediator, t, CompletionStatus.COMPLETED_MAYBE);
             }
             sendResponse(messageMediator);
         } catch (Throwable t) {
             dispatchError(messageMediator, "RequestMessage", t);
         } finally {
             endRequest(messageMediator);
         }
     }
     public void handleRequest(LocateRequestMessage msg,
                               CorbaMessageMediator messageMediator)
     {
         try {
             beginRequest(messageMediator);
             try {
                 handleLocateRequest(messageMediator);
             } catch (Throwable t) {
                 handleThrowableDuringServerDispatch(
                     messageMediator, t, CompletionStatus.COMPLETED_MAYBE);
             }
             sendResponse(messageMediator);
         } catch (Throwable t) {
             dispatchError(messageMediator, "LocateRequestMessage", t);
         } finally {
             endRequest(messageMediator);
         }
     }
     private void beginRequest(CorbaMessageMediator messageMediator)
     {
         ORB orb = (ORB) messageMediator.getBroker();
         if (orb.subcontractDebugFlag) {
             dprint(".handleRequest->:");
         }
         connection.serverRequestProcessingBegins();
     }
     private void dispatchError(CorbaMessageMediator messageMediator,
                                String msg, Throwable t)
     {
         if (orb.subcontractDebugFlag) {
             dprint(".handleRequest: " + opAndId(messageMediator)
                    + ": !!ERROR!!: "
                    + msg,
                    t);
         }
         // REVISIT - this makes hcks sendTwoObjects fail
         // messageMediator.getConnection().close();
     }
     private void sendResponse(CorbaMessageMediator messageMediator)
     {
         if (orb.subcontractDebugFlag) {
             dprint(".handleRequest: " + opAndId(messageMediator)
                    + ": sending response");
         }
         // REVISIT - type and location
         CDROutputObject outputObject = (CDROutputObject)
             messageMediator.getOutputObject();
         if (outputObject != null) {
             // REVISIT - can be null for TRANSIENT below.
             outputObject.finishSendingMessage();
         }
     }
     private void endRequest(CorbaMessageMediator messageMediator)
     {
         ORB orb = (ORB) messageMediator.getBroker();
         if (orb.subcontractDebugFlag) {
             dprint(".handleRequest<-: " + opAndId(messageMediator));
         }
         // release NIO ByteBuffers to ByteBufferPool
         try {
             OutputObject outputObj = messageMediator.getOutputObject();
             if (outputObj != null) {
                 outputObj.close();
             }
             InputObject inputObj = messageMediator.getInputObject();
             if (inputObj != null) {
                 inputObj.close();
             }
         } catch (IOException ex) {
             // Given what close() does, this catch shouldn't ever happen.
             // See CDRInput/OutputObject.close() for more info.
             // It also won't result in a Corba error if an IOException happens.
             if (orb.subcontractDebugFlag) {
                 dprint(".endRequest: IOException:" + ex.getMessage(), ex);
             }
         } finally {
             ((CorbaConnection)messageMediator.getConnection()).serverRequestProcessingEnds();
         }
     }
     protected void handleRequestRequest(CorbaMessageMediator messageMediator)
     {
         // Does nothing if already unmarshaled.
         ((CDRInputObject)messageMediator.getInputObject()).unmarshalHeader();
         ORB orb = (ORB)messageMediator.getBroker();
         synchronized (orb) {
             orb.checkShutdownState();
         }
         ObjectKey okey = messageMediator.getObjectKey();
         if (orb.subcontractDebugFlag) {
             ObjectKeyTemplate oktemp = okey.getTemplate() ;
             dprint( ".handleRequest: " + opAndId(messageMediator)
                     + ": dispatching to scid: " + oktemp.getSubcontractId());
         }
         CorbaServerRequestDispatcher sc = okey.getServerRequestDispatcher(orb);
         if (orb.subcontractDebugFlag) {
             dprint(".handleRequest: " + opAndId(messageMediator)
                    + ": dispatching to sc: " + sc);
         }
         if (sc == null) {
             throw wrapper.noServerScInDispatch() ;
         }
         // NOTE:
         // This is necessary so mediator can act as ResponseHandler
         // and pass necessary info to response constructors located
         // in the subcontract.
         // REVISIT - same class right now.
         //messageMediator.setProtocolHandler(this);
         try {
             orb.startingDispatch();
             sc.dispatch(messageMediator);
         } finally {
             orb.finishedDispatch();
         }
     }
     protected void handleLocateRequest(CorbaMessageMediator messageMediator)
     {
         ORB orb = (ORB)messageMediator.getBroker();
         LocateRequestMessage msg = (LocateRequestMessage)
             messageMediator.getDispatchHeader();
         IOR ior = null;
         LocateReplyMessage reply = null;
         short addrDisp = -1;
         try {
             ((CDRInputObject)messageMediator.getInputObject()).unmarshalHeader();
             CorbaServerRequestDispatcher sc =
                 msg.getObjectKey().getServerRequestDispatcher( orb ) ;
             if (sc == null) {
                 return;
             }
             ior = sc.locate(msg.getObjectKey());
             if ( ior == null ) {
                 reply = MessageBase.createLocateReply(
                             orb, msg.getGIOPVersion(),
                             msg.getEncodingVersion(),
                             msg.getRequestId(),
                             LocateReplyMessage.OBJECT_HERE, null);
             } else {
                 reply = MessageBase.createLocateReply(
                             orb, msg.getGIOPVersion(),
                             msg.getEncodingVersion(),
                             msg.getRequestId(),
                             LocateReplyMessage.OBJECT_FORWARD, ior);
             }
             // REVISIT: Should we catch SystemExceptions?
         } catch (AddressingDispositionException ex) {
             // create a response containing the expected target
             // addressing disposition.
             reply = MessageBase.createLocateReply(
                         orb, msg.getGIOPVersion(),
                         msg.getEncodingVersion(),
                         msg.getRequestId(),
                         LocateReplyMessage.LOC_NEEDS_ADDRESSING_MODE, null);
             addrDisp = ex.expectedAddrDisp();
         } catch (RequestCanceledException ex) {
             return; // no need to send reply
         } catch ( Exception ex ) {
             // REVISIT If exception is not OBJECT_NOT_EXIST, it should
             // have a different reply
             // This handles OBJECT_NOT_EXIST exceptions thrown in
             // the subcontract or obj manager. Send back UNKNOWN_OBJECT.
             reply = MessageBase.createLocateReply(
                         orb, msg.getGIOPVersion(),
                         msg.getEncodingVersion(),
                         msg.getRequestId(),
                         LocateReplyMessage.UNKNOWN_OBJECT, null);
         }
         CDROutputObject outputObject =
             createAppropriateOutputObject(messageMediator,
                                           msg, reply);
         messageMediator.setOutputObject(outputObject);
         outputObject.setMessageMediator(messageMediator);
         reply.write(outputObject);
         // outputObject.setMessage(reply); // REVISIT - not necessary
         if (ior != null) {
             ior.write(outputObject);
         }
         if (addrDisp != -1) {
             AddressingDispositionHelper.write(outputObject, addrDisp);
         }
     }
     private CDROutputObject createAppropriateOutputObject(
         CorbaMessageMediator messageMediator,
         Message msg, LocateReplyMessage reply)
     {
         CDROutputObject outputObject;
         if (msg.getGIOPVersion().lessThan(GIOPVersion.V1_2)) {
             // locate msgs 1.0 & 1.1 :=> grow,
             outputObject = sun.corba.OutputStreamFactory.newCDROutputObject(
                              (ORB) messageMediator.getBroker(),
                              this,
                              GIOPVersion.V1_0,
                              (CorbaConnection) messageMediator.getConnection(),
                              reply,
                              ORBConstants.STREAM_FORMAT_VERSION_1);
         } else {
             // 1.2 :=> stream
             outputObject = sun.corba.OutputStreamFactory.newCDROutputObject(
                              (ORB) messageMediator.getBroker(),
                              messageMediator,
                              reply,
                              ORBConstants.STREAM_FORMAT_VERSION_1);
         }
         return outputObject;
     }
     public void handleThrowableDuringServerDispatch(
         CorbaMessageMediator messageMediator,
         Throwable throwable,
         CompletionStatus completionStatus)
     {
         if (((ORB)messageMediator.getBroker()).subcontractDebugFlag) {
             dprint(".handleThrowableDuringServerDispatch: "
                    + opAndId(messageMediator) + ": "
                    + throwable);
         }
         // If we haven't unmarshaled the header, we probably don't
         // have enough information to even send back a reply.
         // REVISIT
         // Cannot do this check.  When target addressing disposition does
         // not match (during header unmarshaling) it throws an exception
         // to be handled here.
         /*
         if (! ((CDRInputObject)messageMediator.getInputObject())
             .unmarshaledHeader()) {
             return;
         }
         */
         handleThrowableDuringServerDispatch(messageMediator,
                                             throwable,
                                             completionStatus,
 );
     }
     // REVISIT - catch and ignore RequestCanceledException.
     protected void handleThrowableDuringServerDispatch(
         CorbaMessageMediator messageMediator,
         Throwable throwable,
         CompletionStatus completionStatus,
         int iteration)
     {
         if (iteration > 10) {
             if (((ORB)messageMediator.getBroker()).subcontractDebugFlag) {
                 dprint(".handleThrowableDuringServerDispatch: "
                        + opAndId(messageMediator)
                        + ": cannot handle: "
                        + throwable);
             }
             // REVISIT - should we close connection?
             RuntimeException rte =
                 new RuntimeException("handleThrowableDuringServerDispatch: " +
                                      "cannot create response.");
             rte.initCause(throwable);
             throw rte;
         }
         try {
             if (throwable instanceof ForwardException) {
                 ForwardException fex = (ForwardException)throwable ;
                 createLocationForward( messageMediator, fex.getIOR(), null ) ;
                 return;
             }
             if (throwable instanceof AddressingDispositionException) {
                 handleAddressingDisposition(
                     messageMediator,
                     (AddressingDispositionException)throwable);
                 return;
             }
             // Else.
             SystemException sex =
                 convertThrowableToSystemException(throwable, completionStatus);
             createSystemExceptionResponse(messageMediator, sex, null);
             return;
         } catch (Throwable throwable2) {
             // User code (e.g., postinvoke, interceptors) may change
             // the exception, so we end up back here.
             // Report the changed exception.
             handleThrowableDuringServerDispatch(messageMediator,
                                                 throwable2,
                                                 completionStatus,
                                                 iteration + 1);
             return;
         }
     }
     protected SystemException convertThrowableToSystemException(
         Throwable throwable,
         CompletionStatus completionStatus)
     {
         if (throwable instanceof SystemException) {
             return (SystemException)throwable;
         }
         if (throwable instanceof RequestCanceledException) {
             // Reporting an exception response causes the
             // poa current stack, the interceptor stacks, etc.
             // to be balanced.  It also notifies interceptors
             // that the request was cancelled.
             return wrapper.requestCanceled( throwable ) ;
         }
         // NOTE: We do not trap ThreadDeath above Throwable.
         // There is no reason to stop the thread.  It is
         // just a worker thread.  The ORB never throws
         // ThreadDeath.  Client code may (e.g., in ServantManagers,
         // interceptors, or servants) but that should not
         // effect the ORB threads.  So it is just handled
         // generically.
         //
         // Last resort.
         // If user code throws a non-SystemException report it generically.
         //
         return wrapper.runtimeexception( CompletionStatus.COMPLETED_MAYBE, throwable ) ;
     }
     protected void handleAddressingDisposition(
         CorbaMessageMediator messageMediator,
         AddressingDispositionException ex)
     {
         short addrDisp = -1;
         // from iiop.RequestProcessor.
         // Respond with expected target addressing disposition.
         switch (messageMediator.getRequestHeader().getType()) {
         case Message.GIOPRequest :
             ReplyMessage replyHeader = MessageBase.createReply(
                           (ORB)messageMediator.getBroker(),
                           messageMediator.getGIOPVersion(),
                           messageMediator.getEncodingVersion(),
                           messageMediator.getRequestId(),
                           ReplyMessage.NEEDS_ADDRESSING_MODE,
                           null, null);
             // REVISIT: via acceptor factory.
             CDROutputObject outputObject =
                 sun.corba.OutputStreamFactory.newCDROutputObject(
                 (ORB)messageMediator.getBroker(),
                 this,
                 messageMediator.getGIOPVersion(),
                 (CorbaConnection)messageMediator.getConnection(),
                 replyHeader,
                 ORBConstants.STREAM_FORMAT_VERSION_1);
             messageMediator.setOutputObject(outputObject);
             outputObject.setMessageMediator(messageMediator);
             replyHeader.write(outputObject);
             AddressingDispositionHelper.write(outputObject,
                                               ex.expectedAddrDisp());
             return;
         case Message.GIOPLocateRequest :
             LocateReplyMessage locateReplyHeader = MessageBase.createLocateReply(
                 (ORB)messageMediator.getBroker(),
                 messageMediator.getGIOPVersion(),
                 messageMediator.getEncodingVersion(),
                 messageMediator.getRequestId(),
                 LocateReplyMessage.LOC_NEEDS_ADDRESSING_MODE,
                 null);
             addrDisp = ex.expectedAddrDisp();
             // REVISIT: via acceptor factory.
             outputObject =
                 createAppropriateOutputObject(messageMediator,
                                               messageMediator.getRequestHeader(),
                                               locateReplyHeader);
             messageMediator.setOutputObject(outputObject);
             outputObject.setMessageMediator(messageMediator);
             locateReplyHeader.write(outputObject);
             IOR ior = null;
             if (ior != null) {
                 ior.write(outputObject);
             }
             if (addrDisp != -1) {
                 AddressingDispositionHelper.write(outputObject, addrDisp);
             }
             return;
         }
     }
     public CorbaMessageMediator createResponse(
         CorbaMessageMediator messageMediator,
         ServiceContexts svc)
     {
         // REVISIT: ignore service contexts during framework transition.
         // They are set in SubcontractResponseHandler to the wrong connection.
         // Then they would be set again here and a duplicate contexts
         // exception occurs.
         return createResponseHelper(
             messageMediator,
             getServiceContextsForReply(messageMediator, null));
     }
     public CorbaMessageMediator createUserExceptionResponse(
         CorbaMessageMediator messageMediator, ServiceContexts svc)
     {
         // REVISIT - same as above
         return createResponseHelper(
             messageMediator,
             getServiceContextsForReply(messageMediator, null),
             true);
     }
     public CorbaMessageMediator createUnknownExceptionResponse(
         CorbaMessageMediator messageMediator, UnknownException ex)
     {
         // NOTE: This service context container gets augmented in
         // tail call.
         ServiceContexts contexts = null;
         SystemException sys = new UNKNOWN( 0,
             CompletionStatus.COMPLETED_MAYBE);
         contexts = new ServiceContexts( (ORB)messageMediator.getBroker() );
         UEInfoServiceContext uei = new UEInfoServiceContext(sys);
         contexts.put( uei ) ;
         return createSystemExceptionResponse(messageMediator, sys, contexts);
     }
     public CorbaMessageMediator createSystemExceptionResponse(
         CorbaMessageMediator messageMediator,
         SystemException ex,
         ServiceContexts svc)
     {
         if (messageMediator.getConnection() != null) {
             // It is possible that fragments of response have already been
             // sent.  Then an error may occur (e.g. marshaling error like
             // non serializable object).  In that case it is too late
             // to send the exception.  We just return the existing fragmented
             // stream here.  This will cause an incomplete last fragment
             // to be sent.  Then the other side will get a marshaling error
             // when attempting to unmarshal.
             // REVISIT: Impl - make interface method to do the following.
             CorbaMessageMediatorImpl mediator = (CorbaMessageMediatorImpl)
                 ((CorbaConnection)messageMediator.getConnection())
                 .serverRequestMapGet(messageMediator.getRequestId());
             OutputObject existingOutputObject = null;
             if (mediator != null) {
                 existingOutputObject = mediator.getOutputObject();
             }
             // REVISIT: need to think about messageMediator containing correct
             // pointer to output object.
             if (existingOutputObject != null &&
                 mediator.sentFragment() &&
                 ! mediator.sentFullMessage())
             {
                 return mediator;
             }
         }
         // Only do this if interceptors have been initialized on this request
         // and have not completed their lifecycle (otherwise the info stack
         // may be empty or have a different request's entry on top).
         if (messageMediator.executePIInResponseConstructor()) {
             // REVISIT: not necessary in framework now?
             // Inform Portable Interceptors of the SystemException.  This is
             // required to be done here because the ending interception point
             // is called in the when creating the response below
             // but we do not currently write the SystemException into the
             // response until after the ending point is called.
             ((ORB)messageMediator.getBroker()).getPIHandler().setServerPIInfo( ex );
         }
         if (((ORB)messageMediator.getBroker()).subcontractDebugFlag &&
             ex != null)
         {
             dprint(".createSystemExceptionResponse: "
                    + opAndId(messageMediator),
                    ex);
         }
         ServiceContexts serviceContexts =
             getServiceContextsForReply(messageMediator, svc);
         // NOTE: We MUST add the service context before creating
         // the response since service contexts are written to the
         // stream when the response object is created.
         addExceptionDetailMessage(messageMediator, ex, serviceContexts);
         CorbaMessageMediator response =
             createResponseHelper(messageMediator, serviceContexts, false);
         // NOTE: From here on, it is too late to add more service contexts.
         // They have already been serialized to the stream (and maybe fragments
         // sent).
         ORBUtility.writeSystemException(
             ex, (OutputStream)response.getOutputObject());
         return response;
     }
     private void addExceptionDetailMessage(CorbaMessageMediator mediator,
                                            SystemException ex,
                                            ServiceContexts serviceContexts)
     {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         PrintWriter pw = new PrintWriter(baos);
         ex.printStackTrace(pw);
         pw.flush(); // NOTE: you must flush or baos will be empty.
         EncapsOutputStream encapsOutputStream =
             sun.corba.OutputStreamFactory.newEncapsOutputStream((ORB)mediator.getBroker());
         encapsOutputStream.putEndian();
         encapsOutputStream.write_wstring(baos.toString());
         UnknownServiceContext serviceContext =
             new UnknownServiceContext(ExceptionDetailMessage.value,
                                       encapsOutputStream.toByteArray());
         serviceContexts.put(serviceContext);
     }
     public CorbaMessageMediator createLocationForward(
         CorbaMessageMediator messageMediator, IOR ior, ServiceContexts svc)
     {
         ReplyMessage reply
             = MessageBase.createReply(
                   (ORB)messageMediator.getBroker(),
                   messageMediator.getGIOPVersion(),
                   messageMediator.getEncodingVersion(),
                   messageMediator.getRequestId(),
                   ReplyMessage.LOCATION_FORWARD,
                   getServiceContextsForReply(messageMediator, svc),
                   ior);
         return createResponseHelper(messageMediator, reply, ior);
     }
     protected CorbaMessageMediator createResponseHelper(
         CorbaMessageMediator messageMediator, ServiceContexts svc)
     {
         ReplyMessage message =
             MessageBase.createReply(
                 (ORB)messageMediator.getBroker(),
                 messageMediator.getGIOPVersion(),
                 messageMediator.getEncodingVersion(),
                 messageMediator.getRequestId(),
                 ReplyMessage.NO_EXCEPTION,
                 svc,
                 null);
         return createResponseHelper(messageMediator, message, null);
     }
     protected CorbaMessageMediator createResponseHelper(
         CorbaMessageMediator messageMediator, ServiceContexts svc,boolean user)
     {
         ReplyMessage message =
             MessageBase.createReply(
                 (ORB)messageMediator.getBroker(),
                 messageMediator.getGIOPVersion(),
                 messageMediator.getEncodingVersion(),
                 messageMediator.getRequestId(),
                 user ? ReplyMessage.USER_EXCEPTION :
                        ReplyMessage.SYSTEM_EXCEPTION,
                 svc,
                 null);
         return createResponseHelper(messageMediator, message, null);
     }
     // REVISIT - IOR arg is ignored.
     protected CorbaMessageMediator createResponseHelper(
         CorbaMessageMediator messageMediator, ReplyMessage reply, IOR ior)
     {
         // REVISIT - these should be invoked from subcontract.
         runServantPostInvoke(messageMediator);
         runInterceptors(messageMediator, reply);
         runRemoveThreadInfo(messageMediator);
         if (((ORB)messageMediator.getBroker()).subcontractDebugFlag) {
             dprint(".createResponseHelper: "
                    + opAndId(messageMediator) + ": "
                    + reply);
         }
         messageMediator.setReplyHeader(reply);
         OutputObject replyOutputObject;
         // REVISIT = do not use null.
         //
         if (messageMediator.getConnection() == null) {
             replyOutputObject =
                 sun.corba.OutputStreamFactory.newCDROutputObject(orb,
                             messageMediator, messageMediator.getReplyHeader(),
                             messageMediator.getStreamFormatVersion(),
                             BufferManagerFactory.GROW);
         } else {
             replyOutputObject = messageMediator.getConnection().getAcceptor()
              .createOutputObject(messageMediator.getBroker(), messageMediator);
         }
         messageMediator.setOutputObject(replyOutputObject);
         messageMediator.getOutputObject().setMessageMediator(messageMediator);
         reply.write((OutputStream) messageMediator.getOutputObject());
         if (reply.getIOR() != null) {
             reply.getIOR().write((OutputStream) messageMediator.getOutputObject());
         }
         // REVISIT - not necessary?
         //messageMediator.this.replyIOR = reply.getIOR();
         // NOTE: The mediator holds onto output object so return value
         // not really necessary.
         return messageMediator;
     }
     protected void runServantPostInvoke(CorbaMessageMediator messageMediator)
     {
         // Run ServantLocator::postinvoke.  This may cause a SystemException
         // which will throw out of the constructor and return later
         // to construct a reply for that exception.  The internal logic
         // of returnServant makes sure that postinvoke is only called once.
         // REVISIT: instead of instanceof, put method on all orbs.
         ORB orb = null;
         // This flag is to deal with BootstrapServer use of reply streams,
         // with ServerRequestDispatcher's use of reply streams, etc.
         if (messageMediator.executeReturnServantInResponseConstructor()) {
             // It is possible to get marshaling errors in the skeleton after
             // postinvoke has completed.  We must set this to false so that
             // when the error exception reply is constructed we don't try
             // to incorrectly access poa current (which will be the wrong
             // one or an empty stack.
             messageMediator.setExecuteReturnServantInResponseConstructor(false);
             messageMediator.setExecuteRemoveThreadInfoInResponseConstructor(true);
             try {
                 orb = (ORB)messageMediator.getBroker();
                 OAInvocationInfo info = orb.peekInvocationInfo() ;
                 ObjectAdapter oa = info.oa();
                 try {
                     oa.returnServant() ;
                 } catch (Throwable thr) {
                     wrapper.unexpectedException( thr ) ;
                     if (thr instanceof Error)
                         throw (Error)thr ;
                     else if (thr instanceof RuntimeException)
                         throw (RuntimeException)thr ;
                 } finally {
                     oa.exit();
                 }
             } catch (EmptyStackException ese) {
                 throw wrapper.emptyStackRunServantPostInvoke( ese ) ;
             }
         }
     }
     protected void runInterceptors(CorbaMessageMediator messageMediator,
                                    ReplyMessage reply)
     {
         if( messageMediator.executePIInResponseConstructor() ) {
             // Invoke server request ending interception points (send_*):
             // Note: this may end up with a SystemException or an internal
             // Runtime ForwardRequest
             ((ORB)messageMediator.getBroker()).getPIHandler().
                 invokeServerPIEndingPoint( reply );
             // Note this will be executed even if a ForwardRequest or
             // SystemException is thrown by a Portable Interceptors ending
             // point since we end up in this constructor again anyway.
             ((ORB)messageMediator.getBroker()).getPIHandler().
                 cleanupServerPIRequest();
             // See createSystemExceptionResponse for why this is necesary.
             messageMediator.setExecutePIInResponseConstructor(false);
         }
     }
     protected void runRemoveThreadInfo(CorbaMessageMediator messageMediator)
     {
         // Once you get here then the final reply is available (i.e.,
         // postinvoke and interceptors have completed.
         if (messageMediator.executeRemoveThreadInfoInResponseConstructor()) {
             messageMediator.setExecuteRemoveThreadInfoInResponseConstructor(false);
             ((ORB)messageMediator.getBroker()).popInvocationInfo() ;
         }
     }
     protected ServiceContexts getServiceContextsForReply(
         CorbaMessageMediator messageMediator, ServiceContexts contexts)
     {
         CorbaConnection c = (CorbaConnection) messageMediator.getConnection();
         if (((ORB)messageMediator.getBroker()).subcontractDebugFlag) {
             dprint(".getServiceContextsForReply: "
                    + opAndId(messageMediator)
                    + ": " + c);
         }
         if (contexts == null) {
             contexts = new ServiceContexts(((ORB)messageMediator.getBroker()));
         }
         // NOTE : We only want to send the runtime context the first time
         if (c != null && !c.isPostInitialContexts()) {
             c.setPostInitialContexts();
             SendingContextServiceContext scsc =
                 new SendingContextServiceContext(
                     ((ORB)messageMediator.getBroker()).getFVDCodeBaseIOR()) ;
             if (contexts.get( scsc.getId() ) != null)
                 throw wrapper.duplicateSendingContextServiceContext() ;
             contexts.put( scsc ) ;
             if ( ((ORB)messageMediator.getBroker()).subcontractDebugFlag)
                 dprint(".getServiceContextsForReply: "
                        + opAndId(messageMediator)
                        + ": added SendingContextServiceContext" ) ;
         }
         // send ORBVersion servicecontext as part of the Reply
         ORBVersionServiceContext ovsc
             = new ORBVersionServiceContext(ORBVersionFactory.getORBVersion());
         if (contexts.get( ovsc.getId() ) != null)
             throw wrapper.duplicateOrbVersionServiceContext() ;
         contexts.put( ovsc ) ;
         if ( ((ORB)messageMediator.getBroker()).subcontractDebugFlag)
             dprint(".getServiceContextsForReply: "
                    + opAndId(messageMediator)
                    + ": added ORB version service context");
         return contexts;
     }
     // REVISIT - this method should be migrated to orbutil.ORBUtility
     //           since all locations that release ByteBuffers use
     //           very similar logic and debug information.
     private void releaseByteBufferToPool() {
         if (dispatchByteBuffer != null) {
             orb.getByteBufferPool().releaseByteBuffer(dispatchByteBuffer);
             if (transportDebug()) {
                 int bbId = System.identityHashCode(dispatchByteBuffer);
                 StringBuffer sb = new StringBuffer();
                 sb.append(".handleInput: releasing ByteBuffer (" + bbId +
                           ") to ByteBufferPool");
                 dprint(sb.toString());
              }
         }
     }
 }
 // End of file.

Mercurial > jdk8-mips64-public > corba / annotate

src/share/classes/com/sun/corba/se/impl/protocol/CorbaMessageMediatorImpl.java@6845b95cba6b (annotated)

src/share/classes/com/sun/corba/se/impl/protocol/CorbaMessageMediatorImpl.java