jdk8-mips64-public/corba: src/share/classes/com/sun/corba/se/impl/transport/SocketOrChannelConnectionImpl.java@f90b3e014e83 (annotated)

src/share/classes/com/sun/corba/se/impl/transport/SocketOrChannelConnectionImpl.java@f90b3e014e83 (annotated)

src/share/classes/com/sun/corba/se/impl/transport/SocketOrChannelConnectionImpl.java

Tue, 28 Dec 2010 15:52:36 -0800

author: ohair
date: Tue, 28 Dec 2010 15:52:36 -0800
changeset 240: f90b3e014e83
parent 226: e0f7ed041196
child 391: 18a02ad8dc73
permissions: -rw-r--r--

6962318: Update copyright year
Reviewed-by: xdono

 /*
  * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package com.sun.corba.se.impl.transport;
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.net.Socket;
 import java.nio.ByteBuffer;
 import java.nio.channels.SelectableChannel;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.SocketChannel;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.Collections;
 import java.util.Hashtable;
 import java.util.HashMap;
 import java.util.Map;
 import org.omg.CORBA.COMM_FAILURE;
 import org.omg.CORBA.CompletionStatus;
 import org.omg.CORBA.DATA_CONVERSION;
 import org.omg.CORBA.INTERNAL;
 import org.omg.CORBA.MARSHAL;
 import org.omg.CORBA.OBJECT_NOT_EXIST;
 import org.omg.CORBA.SystemException;
 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.MessageMediator;
 import com.sun.corba.se.pept.transport.Acceptor;
 import com.sun.corba.se.pept.transport.Connection;
 import com.sun.corba.se.pept.transport.ConnectionCache;
 import com.sun.corba.se.pept.transport.ContactInfo;
 import com.sun.corba.se.pept.transport.EventHandler;
 import com.sun.corba.se.pept.transport.InboundConnectionCache;
 import com.sun.corba.se.pept.transport.OutboundConnectionCache;
 import com.sun.corba.se.pept.transport.ResponseWaitingRoom;
 import com.sun.corba.se.pept.transport.Selector;
 import com.sun.corba.se.spi.ior.IOR;
 import com.sun.corba.se.spi.ior.iiop.GIOPVersion;
 import com.sun.corba.se.spi.logging.CORBALogDomains;
 import com.sun.corba.se.spi.orb.ORB ;
 import com.sun.corba.se.spi.orbutil.threadpool.NoSuchThreadPoolException;
 import com.sun.corba.se.spi.orbutil.threadpool.NoSuchWorkQueueException;
 import com.sun.corba.se.spi.orbutil.threadpool.Work;
 import com.sun.corba.se.spi.protocol.CorbaMessageMediator;
 import com.sun.corba.se.spi.transport.CorbaContactInfo;
 import com.sun.corba.se.spi.transport.CorbaConnection;
 import com.sun.corba.se.spi.transport.CorbaResponseWaitingRoom;
 import com.sun.corba.se.spi.transport.ReadTimeouts;
 import com.sun.corba.se.impl.encoding.CachedCodeBase;
 import com.sun.corba.se.impl.encoding.CDRInputStream_1_0;
 import com.sun.corba.se.impl.encoding.CDROutputObject;
 import com.sun.corba.se.impl.encoding.CDROutputStream_1_0;
 import com.sun.corba.se.impl.encoding.CodeSetComponentInfo;
 import com.sun.corba.se.impl.encoding.OSFCodeSetRegistry;
 import com.sun.corba.se.impl.logging.ORBUtilSystemException;
 import com.sun.corba.se.impl.orbutil.ORBConstants;
 import com.sun.corba.se.impl.orbutil.ORBUtility;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.Message;
 import com.sun.corba.se.impl.protocol.giopmsgheaders.MessageBase;
 import com.sun.corba.se.impl.transport.CorbaResponseWaitingRoomImpl;
 /**
  * @author Harold Carr
  */
 public class SocketOrChannelConnectionImpl
     extends
         EventHandlerBase
     implements
         CorbaConnection,
         Work
 {
     public static boolean dprintWriteLocks = false;
     //
     // New transport.
     //
     protected long enqueueTime;
     protected SocketChannel socketChannel;
     public SocketChannel getSocketChannel()
     {
         return socketChannel;
     }
     // REVISIT:
     // protected for test: genericRPCMSGFramework.IIOPConnection constructor.
     protected CorbaContactInfo contactInfo;
     protected Acceptor acceptor;
     protected ConnectionCache connectionCache;
     //
     // From iiop.Connection.java
     //
     protected Socket socket;    // The socket used for this connection.
     protected long timeStamp = 0;
     protected boolean isServer = false;
     // Start at some value other than zero since this is a magic
     // value in some protocols.
     protected int requestId = 5;
     protected CorbaResponseWaitingRoom responseWaitingRoom;
     protected int state;
     protected java.lang.Object stateEvent = new java.lang.Object();
     protected java.lang.Object writeEvent = new java.lang.Object();
     protected boolean writeLocked;
     protected int serverRequestCount = 0;
     // Server request map: used on the server side of Connection
     // Maps request ID to IIOPInputStream.
     Map serverRequestMap = null;
     // This is a flag associated per connection telling us if the
     // initial set of sending contexts were sent to the receiver
     // already...
     protected boolean postInitialContexts = false;
     // Remote reference to CodeBase server (supplies
     // FullValueDescription, among other things)
     protected IOR codeBaseServerIOR;
     // CodeBase cache for this connection.  This will cache remote operations,
     // handle connecting, and ensure we don't do any remote operations until
     // necessary.
     protected CachedCodeBase cachedCodeBase = new CachedCodeBase(this);
     protected ORBUtilSystemException wrapper ;
     // transport read timeout values
     protected ReadTimeouts readTimeouts;
     protected boolean shouldReadGiopHeaderOnly;
     // A message mediator used when shouldReadGiopHeaderOnly is
     // true to maintain request message state across execution in a
     // SelectorThread and WorkerThread.
     protected CorbaMessageMediator partialMessageMediator = null;
     // Used in genericRPCMSGFramework test.
     protected SocketOrChannelConnectionImpl(ORB orb)
     {
         this.orb = orb;
         wrapper = ORBUtilSystemException.get( orb,
             CORBALogDomains.RPC_TRANSPORT ) ;
         setWork(this);
         responseWaitingRoom = new CorbaResponseWaitingRoomImpl(orb, this);
         setReadTimeouts(orb.getORBData().getTransportTCPReadTimeouts());
     }
     // Both client and servers.
     protected SocketOrChannelConnectionImpl(ORB orb,
                                             boolean useSelectThreadToWait,
                                             boolean useWorkerThread)
     {
         this(orb) ;
         setUseSelectThreadToWait(useSelectThreadToWait);
         setUseWorkerThreadForEvent(useWorkerThread);
     }
     // Client constructor.
     public SocketOrChannelConnectionImpl(ORB orb,
                                          CorbaContactInfo contactInfo,
                                          boolean useSelectThreadToWait,
                                          boolean useWorkerThread,
                                          String socketType,
                                          String hostname,
                                          int port)
     {
         this(orb, useSelectThreadToWait, useWorkerThread);
         this.contactInfo = contactInfo;
         try {
             socket = orb.getORBData().getSocketFactory()
                 .createSocket(socketType,
                               new InetSocketAddress(hostname, port));
             socketChannel = socket.getChannel();
             if (socketChannel != null) {
                 boolean isBlocking = !useSelectThreadToWait;
                 socketChannel.configureBlocking(isBlocking);
             } else {
                 // IMPORTANT: non-channel-backed sockets must use
                 // dedicated reader threads.
                 setUseSelectThreadToWait(false);
             }
             if (orb.transportDebugFlag) {
                 dprint(".initialize: connection created: " + socket);
             }
         } catch (Throwable t) {
             throw wrapper.connectFailure(t, socketType, hostname,
                                          Integer.toString(port));
         }
         state = OPENING;
     }
     // Client-side convenience.
     public SocketOrChannelConnectionImpl(ORB orb,
                                          CorbaContactInfo contactInfo,
                                          String socketType,
                                          String hostname,
                                          int port)
     {
         this(orb, contactInfo,
              orb.getORBData().connectionSocketUseSelectThreadToWait(),
              orb.getORBData().connectionSocketUseWorkerThreadForEvent(),
              socketType, hostname, port);
     }
     // Server-side constructor.
     public SocketOrChannelConnectionImpl(ORB orb,
                                          Acceptor acceptor,
                                          Socket socket,
                                          boolean useSelectThreadToWait,
                                          boolean useWorkerThread)
     {
         this(orb, useSelectThreadToWait, useWorkerThread);
         this.socket = socket;
         socketChannel = socket.getChannel();
         if (socketChannel != null) {
             // REVISIT
             try {
                 boolean isBlocking = !useSelectThreadToWait;
                 socketChannel.configureBlocking(isBlocking);
             } catch (IOException e) {
                 RuntimeException rte = new RuntimeException();
                 rte.initCause(e);
                 throw rte;
             }
         }
         this.acceptor = acceptor;
         serverRequestMap = Collections.synchronizedMap(new HashMap());
         isServer = true;
         state = ESTABLISHED;
     }
     // Server-side convenience
     public SocketOrChannelConnectionImpl(ORB orb,
                                          Acceptor acceptor,
                                          Socket socket)
     {
         this(orb, acceptor, socket,
              (socket.getChannel() == null
               ? false
               : orb.getORBData().connectionSocketUseSelectThreadToWait()),
              (socket.getChannel() == null
               ? false
               : orb.getORBData().connectionSocketUseWorkerThreadForEvent()));
     }
     ////////////////////////////////////////////////////
     //
     // framework.transport.Connection
     //
     public boolean shouldRegisterReadEvent()
     {
         return true;
     }
     public boolean shouldRegisterServerReadEvent()
     {
         return true;
     }
     public boolean read()
     {
         try {
             if (orb.transportDebugFlag) {
                 dprint(".read->: " + this);
             }
             CorbaMessageMediator messageMediator = readBits();
             if (messageMediator != null) {
                 // Null can happen when client closes stream
                 // causing purgecalls.
                 return dispatch(messageMediator);
             }
             return true;
         } finally {
             if (orb.transportDebugFlag) {
                 dprint(".read<-: " + this);
             }
         }
     }
     protected CorbaMessageMediator readBits()
     {
         try {
             if (orb.transportDebugFlag) {
                 dprint(".readBits->: " + this);
             }
             MessageMediator messageMediator;
             // REVISIT - use common factory base class.
             if (contactInfo != null) {
                 messageMediator =
                     contactInfo.createMessageMediator(orb, this);
             } else if (acceptor != null) {
                 messageMediator = acceptor.createMessageMediator(orb, this);
             } else {
                 throw
                     new RuntimeException("SocketOrChannelConnectionImpl.readBits");
             }
             return (CorbaMessageMediator) messageMediator;
         } catch (ThreadDeath td) {
             if (orb.transportDebugFlag) {
                 dprint(".readBits: " + this + ": ThreadDeath: " + td, td);
             }
             try {
                 purgeCalls(wrapper.connectionAbort(td), false, false);
             } catch (Throwable t) {
                 if (orb.transportDebugFlag) {
                     dprint(".readBits: " + this + ": purgeCalls: Throwable: " + t, t);
                 }
             }
             throw td;
         } catch (Throwable ex) {
             if (orb.transportDebugFlag) {
                 dprint(".readBits: " + this + ": Throwable: " + ex, ex);
             }
             try {
                 if (ex instanceof INTERNAL) {
                     sendMessageError(GIOPVersion.DEFAULT_VERSION);
                 }
             } catch (IOException e) {
                 if (orb.transportDebugFlag) {
                     dprint(".readBits: " + this +
                            ": sendMessageError: IOException: " + e, e);
                 }
             }
             // REVISIT - make sure reader thread is killed.
             orb.getTransportManager().getSelector(0).unregisterForEvent(this);
             // Notify anyone waiting.
             purgeCalls(wrapper.connectionAbort(ex), true, false);
             // REVISIT
             //keepRunning = false;
             // REVISIT - if this is called after purgeCalls then
             // the state of the socket is ABORT so the writeLock
             // in close throws an exception.  It is ignored but
             // causes IBM (screen scraping) tests to fail.
             //close();
         } finally {
             if (orb.transportDebugFlag) {
                 dprint(".readBits<-: " + this);
             }
         }
         return null;
     }
     protected CorbaMessageMediator finishReadingBits(MessageMediator messageMediator)
     {
         try {
             if (orb.transportDebugFlag) {
                 dprint(".finishReadingBits->: " + this);
             }
             // REVISIT - use common factory base class.
             if (contactInfo != null) {
                 messageMediator =
                     contactInfo.finishCreatingMessageMediator(orb, this, messageMediator);
             } else if (acceptor != null) {
                 messageMediator =
                     acceptor.finishCreatingMessageMediator(orb, this, messageMediator);
             } else {
                 throw
                     new RuntimeException("SocketOrChannelConnectionImpl.finishReadingBits");
             }
             return (CorbaMessageMediator) messageMediator;
         } catch (ThreadDeath td) {
             if (orb.transportDebugFlag) {
                 dprint(".finishReadingBits: " + this + ": ThreadDeath: " + td, td);
             }
             try {
                 purgeCalls(wrapper.connectionAbort(td), false, false);
             } catch (Throwable t) {
                 if (orb.transportDebugFlag) {
                     dprint(".finishReadingBits: " + this + ": purgeCalls: Throwable: " + t, t);
                 }
             }
             throw td;
         } catch (Throwable ex) {
             if (orb.transportDebugFlag) {
                 dprint(".finishReadingBits: " + this + ": Throwable: " + ex, ex);
             }
             try {
                 if (ex instanceof INTERNAL) {
                     sendMessageError(GIOPVersion.DEFAULT_VERSION);
                 }
             } catch (IOException e) {
                 if (orb.transportDebugFlag) {
                     dprint(".finishReadingBits: " + this +
                            ": sendMessageError: IOException: " + e, e);
                 }
             }
             // REVISIT - make sure reader thread is killed.
             orb.getTransportManager().getSelector(0).unregisterForEvent(this);
             // Notify anyone waiting.
             purgeCalls(wrapper.connectionAbort(ex), true, false);
             // REVISIT
             //keepRunning = false;
             // REVISIT - if this is called after purgeCalls then
             // the state of the socket is ABORT so the writeLock
             // in close throws an exception.  It is ignored but
             // causes IBM (screen scraping) tests to fail.
             //close();
         } finally {
             if (orb.transportDebugFlag) {
                 dprint(".finishReadingBits<-: " + this);
             }
         }
         return null;
     }
     protected boolean dispatch(CorbaMessageMediator messageMediator)
     {
         try {
             if (orb.transportDebugFlag) {
                 dprint(".dispatch->: " + this);
             }
             //
             // NOTE:
             //
             // This call is the transition from the tranport block
             // to the protocol block.
             //
             boolean result =
                 messageMediator.getProtocolHandler()
                 .handleRequest(messageMediator);
             return result;
         } catch (ThreadDeath td) {
             if (orb.transportDebugFlag) {
                 dprint(".dispatch: ThreadDeath", td );
             }
             try {
                 purgeCalls(wrapper.connectionAbort(td), false, false);
             } catch (Throwable t) {
                 if (orb.transportDebugFlag) {
                     dprint(".dispatch: purgeCalls: Throwable", t);
                 }
             }
             throw td;
         } catch (Throwable ex) {
             if (orb.transportDebugFlag) {
                 dprint(".dispatch: Throwable", ex ) ;
             }
             try {
                 if (ex instanceof INTERNAL) {
                     sendMessageError(GIOPVersion.DEFAULT_VERSION);
                 }
             } catch (IOException e) {
                 if (orb.transportDebugFlag) {
                     dprint(".dispatch: sendMessageError: IOException", e);
                 }
             }
             purgeCalls(wrapper.connectionAbort(ex), false, false);
             // REVISIT
             //keepRunning = false;
         } finally {
             if (orb.transportDebugFlag) {
                 dprint(".dispatch<-: " + this);
             }
         }
         return true;
     }
     public boolean shouldUseDirectByteBuffers()
     {
         return getSocketChannel() != null;
     }
     public ByteBuffer read(int size, int offset, int length, long max_wait_time)
         throws IOException
     {
         if (shouldUseDirectByteBuffers()) {
             ByteBuffer byteBuffer =
                 orb.getByteBufferPool().getByteBuffer(size);
             if (orb.transportDebugFlag) {
                 // print address of ByteBuffer gotten from pool
                 int bbAddress = System.identityHashCode(byteBuffer);
                 StringBuffer sb = new StringBuffer(80);
                 sb.append(".read: got ByteBuffer id (");
                 sb.append(bbAddress).append(") from ByteBufferPool.");
                 String msgStr = sb.toString();
                 dprint(msgStr);
             }
             byteBuffer.position(offset);
             byteBuffer.limit(size);
             readFully(byteBuffer, length, max_wait_time);
             return byteBuffer;
         }
         byte[] buf = new byte[size];
         readFully(getSocket().getInputStream(), buf,
                   offset, length, max_wait_time);
         ByteBuffer byteBuffer = ByteBuffer.wrap(buf);
         byteBuffer.limit(size);
         return byteBuffer;
     }
     public ByteBuffer read(ByteBuffer byteBuffer, int offset,
                            int length, long max_wait_time)
         throws IOException
     {
         int size = offset + length;
         if (shouldUseDirectByteBuffers()) {
             if (! byteBuffer.isDirect()) {
                 throw wrapper.unexpectedNonDirectByteBufferWithChannelSocket();
             }
             if (size > byteBuffer.capacity()) {
                 if (orb.transportDebugFlag) {
                     // print address of ByteBuffer being released
                     int bbAddress = System.identityHashCode(byteBuffer);
                     StringBuffer bbsb = new StringBuffer(80);
                     bbsb.append(".read: releasing ByteBuffer id (")
                         .append(bbAddress).append(") to ByteBufferPool.");
                     String bbmsg = bbsb.toString();
                     dprint(bbmsg);
                 }
                 orb.getByteBufferPool().releaseByteBuffer(byteBuffer);
                 byteBuffer = orb.getByteBufferPool().getByteBuffer(size);
             }
             byteBuffer.position(offset);
             byteBuffer.limit(size);
             readFully(byteBuffer, length, max_wait_time);
             byteBuffer.position(0);
             byteBuffer.limit(size);
             return byteBuffer;
         }
         if (byteBuffer.isDirect()) {
             throw wrapper.unexpectedDirectByteBufferWithNonChannelSocket();
         }
         byte[] buf = new byte[size];
         readFully(getSocket().getInputStream(), buf,
                   offset, length, max_wait_time);
         return ByteBuffer.wrap(buf);
     }
     public void readFully(ByteBuffer byteBuffer, int size, long max_wait_time)
         throws IOException
     {
         int n = 0;
         int bytecount = 0;
         long time_to_wait = readTimeouts.get_initial_time_to_wait();
         long total_time_in_wait = 0;
         // The reading of data incorporates a strategy to detect a
         // rogue client. The strategy is implemented as follows. As
         // long as data is being read, at least 1 byte or more, we
         // assume we have a well behaved client. If no data is read,
         // then we sleep for a time to wait, re-calculate a new time to
         // wait which is lengthier than the previous time spent waiting.
         // Then, if the total time spent waiting does not exceed a
         // maximum time we are willing to wait, we attempt another
         // read. If the maximum amount of time we are willing to
         // spend waiting for more data is exceeded, we throw an
         // IOException.
         // NOTE: Reading of GIOP headers are treated with a smaller
         //       maximum time to wait threshold. Based on extensive
         //       performance testing, all GIOP headers are being
         //       read in 1 read access.
         do {
             bytecount = getSocketChannel().read(byteBuffer);
             if (bytecount < 0) {
                 throw new IOException("End-of-stream");
             }
             else if (bytecount == 0) {
                 try {
                     Thread.sleep(time_to_wait);
                     total_time_in_wait += time_to_wait;
                     time_to_wait =
                         (long)(time_to_wait*readTimeouts.get_backoff_factor());
                 }
                 catch (InterruptedException ie) {
                     // ignore exception
                     if (orb.transportDebugFlag) {
                         dprint("readFully(): unexpected exception "
                                 + ie.toString());
                     }
                 }
             }
             else {
                 n += bytecount;
             }
         }
         while (n < size && total_time_in_wait < max_wait_time);
         if (n < size && total_time_in_wait >= max_wait_time)
         {
             // failed to read entire message
             throw wrapper.transportReadTimeoutExceeded(new Integer(size),
                                       new Integer(n), new Long(max_wait_time),
                                       new Long(total_time_in_wait));
         }
         getConnectionCache().stampTime(this);
     }
     // To support non-channel connections.
     public void readFully(java.io.InputStream is, byte[] buf,
                           int offset, int size, long max_wait_time)
         throws IOException
     {
         int n = 0;
         int bytecount = 0;
         long time_to_wait = readTimeouts.get_initial_time_to_wait();
         long total_time_in_wait = 0;
         // The reading of data incorporates a strategy to detect a
         // rogue client. The strategy is implemented as follows. As
         // long as data is being read, at least 1 byte or more, we
         // assume we have a well behaved client. If no data is read,
         // then we sleep for a time to wait, re-calculate a new time to
         // wait which is lengthier than the previous time spent waiting.
         // Then, if the total time spent waiting does not exceed a
         // maximum time we are willing to wait, we attempt another
         // read. If the maximum amount of time we are willing to
         // spend waiting for more data is exceeded, we throw an
         // IOException.
         // NOTE: Reading of GIOP headers are treated with a smaller
         //       maximum time to wait threshold. Based on extensive
         //       performance testing, all GIOP headers are being
         //       read in 1 read access.
         do {
             bytecount = is.read(buf, offset + n, size - n);
             if (bytecount < 0) {
                 throw new IOException("End-of-stream");
             }
             else if (bytecount == 0) {
                 try {
                     Thread.sleep(time_to_wait);
                     total_time_in_wait += time_to_wait;
                     time_to_wait =
                         (long)(time_to_wait*readTimeouts.get_backoff_factor());
                 }
                 catch (InterruptedException ie) {
                     // ignore exception
                     if (orb.transportDebugFlag) {
                         dprint("readFully(): unexpected exception "
                                 + ie.toString());
                     }
                 }
             }
             else {
                 n += bytecount;
             }
         }
         while (n < size && total_time_in_wait < max_wait_time);
         if (n < size && total_time_in_wait >= max_wait_time)
         {
             // failed to read entire message
             throw wrapper.transportReadTimeoutExceeded(new Integer(size),
                                       new Integer(n), new Long(max_wait_time),
                                       new Long(total_time_in_wait));
         }
         getConnectionCache().stampTime(this);
     }
     public void write(ByteBuffer byteBuffer)
         throws IOException
     {
         if (shouldUseDirectByteBuffers()) {
             /* NOTE: cannot perform this test.  If one ask for a
                ByteBuffer from the pool which is bigger than the size
                of ByteBuffers managed by the pool, then the pool will
                return a HeapByteBuffer.
             if (byteBuffer.hasArray()) {
                 throw wrapper.unexpectedNonDirectByteBufferWithChannelSocket();
             }
             */
             // IMPORTANT: For non-blocking SocketChannels, there's no guarantee
             //            all bytes are written on first write attempt.
             do {
                 getSocketChannel().write(byteBuffer);
             }
             while (byteBuffer.hasRemaining());
         } else {
             if (! byteBuffer.hasArray()) {
                 throw wrapper.unexpectedDirectByteBufferWithNonChannelSocket();
             }
             byte[] tmpBuf = byteBuffer.array();
             getSocket().getOutputStream().write(tmpBuf, 0, byteBuffer.limit());
             getSocket().getOutputStream().flush();
         }
         // TimeStamp connection to indicate it has been used
         // Note granularity of connection usage is assumed for
         // now to be that of a IIOP packet.
         getConnectionCache().stampTime(this);
     }
     /**
      * Note:it is possible for this to be called more than once
      */
     public synchronized void close()
     {
         try {
             if (orb.transportDebugFlag) {
                 dprint(".close->: " + this);
             }
             writeLock();
             // REVISIT It will be good to have a read lock on the reader thread
             // before we proceed further, to avoid the reader thread (server side)
             // from processing requests. This avoids the risk that a new request
             // will be accepted by ReaderThread while the ListenerThread is
             // attempting to close this connection.
             if (isBusy()) { // we are busy!
                 writeUnlock();
                 if (orb.transportDebugFlag) {
                     dprint(".close: isBusy so no close: " + this);
                 }
                 return;
             }
             try {
                 try {
                     sendCloseConnection(GIOPVersion.V1_0);
                 } catch (Throwable t) {
                     wrapper.exceptionWhenSendingCloseConnection(t);
                 }
                 synchronized ( stateEvent ){
                     state = CLOSE_SENT;
                     stateEvent.notifyAll();
                 }
                 // stop the reader without causing it to do purgeCalls
                 //Exception ex = new Exception();
                 //reader.stop(ex); // REVISIT
                 // NOTE: !!!!!!
                 // This does writeUnlock().
                 purgeCalls(wrapper.connectionRebind(), false, true);
             } catch (Exception ex) {
                 if (orb.transportDebugFlag) {
                     dprint(".close: exception: " + this, ex);
                 }
             }
             try {
                 Selector selector = orb.getTransportManager().getSelector(0);
                 selector.unregisterForEvent(this);
                 if (socketChannel != null) {
                     socketChannel.close();
                 }
                 socket.close();
             } catch (IOException e) {
                 if (orb.transportDebugFlag) {
                     dprint(".close: " + this, e);
                 }
             }
             closeConnectionResources();
         } finally {
             if (orb.transportDebugFlag) {
                 dprint(".close<-: " + this);
             }
         }
     }
     public void closeConnectionResources() {
            if (orb.transportDebugFlag) {
                dprint(".closeConnectionResources->: " + this);
            }
            Selector selector = orb.getTransportManager().getSelector(0);
            selector.unregisterForEvent(this);
            try {
              if (socketChannel != null)
               socketChannel.close() ;
                 if (socket != null && !socket.isClosed())
                 socket.close() ;
            } catch (IOException e) {
              if (orb.transportDebugFlag) {
                  dprint( ".closeConnectionResources: " + this, e ) ;
              }
            }
            if (orb.transportDebugFlag) {
                dprint(".closeConnectionResources<-: " + this);
            }
      }
     public Acceptor getAcceptor()
     {
         return acceptor;
     }
     public ContactInfo getContactInfo()
     {
         return contactInfo;
     }
     public EventHandler getEventHandler()
     {
         return this;
     }
     public OutputObject createOutputObject(MessageMediator messageMediator)
     {
         // REVISIT - remove this method from Connection and all it subclasses.
         throw new RuntimeException("*****SocketOrChannelConnectionImpl.createOutputObject - should not be called.");
     }
     // This is used by the GIOPOutputObject in order to
     // throw the correct error when handling code sets.
     // Can we determine if we are on the server side by
     // other means?  XREVISIT
     public boolean isServer()
     {
         return isServer;
     }
     public boolean isBusy()
     {
         if (serverRequestCount > 0 ||
             getResponseWaitingRoom().numberRegistered() > 0)
         {
             return true;
         } else {
             return false;
         }
     }
     public long getTimeStamp()
     {
         return timeStamp;
     }
     public void setTimeStamp(long time)
     {
         timeStamp = time;
     }
     public void setState(String stateString)
     {
         synchronized (stateEvent) {
             if (stateString.equals("ESTABLISHED")) {
                 state =  ESTABLISHED;
                 stateEvent.notifyAll();
             } else {
                 // REVISIT: ASSERT
             }
         }
     }
     /**
      * Sets the writeLock for this connection.
      * If the writeLock is already set by someone else, block till the
      * writeLock is released and can set by us.
      * IMPORTANT: this connection's lock must be acquired before
      * setting the writeLock and must be unlocked after setting the writeLock.
      */
     public void writeLock()
     {
       try {
         if (dprintWriteLocks && orb.transportDebugFlag) {
             dprint(".writeLock->: " + this);
         }
         // Keep looping till we can set the writeLock.
         while ( true ) {
             int localState = state;
             switch ( localState ) {
             case OPENING:
                 synchronized (stateEvent) {
                     if (state != OPENING) {
                         // somebody has changed 'state' so be careful
                         break;
                     }
                     try {
                         stateEvent.wait();
                     } catch (InterruptedException ie) {
                         if (orb.transportDebugFlag) {
                             dprint(".writeLock: OPENING InterruptedException: " + this);
                         }
                     }
                 }
                 // Loop back
                 break;
             case ESTABLISHED:
                 synchronized (writeEvent) {
                     if (!writeLocked) {
                         writeLocked = true;
                         return;
                     }
                     try {
                         // do not stay here too long if state != ESTABLISHED
                         // Bug 4752117
                         while (state == ESTABLISHED && writeLocked) {
                             writeEvent.wait(100);
                         }
                     } catch (InterruptedException ie) {
                         if (orb.transportDebugFlag) {
                             dprint(".writeLock: ESTABLISHED InterruptedException: " + this);
                         }
                     }
                 }
                 // Loop back
                 break;
                 //
                 // XXX
                 // Need to distinguish between client and server roles
                 // here probably.
                 //
             case ABORT:
                 synchronized ( stateEvent ){
                     if (state != ABORT) {
                         break;
                     }
                     throw wrapper.writeErrorSend() ;
                 }
             case CLOSE_RECVD:
                 // the connection has been closed or closing
                 // ==> throw rebind exception
                 synchronized ( stateEvent ){
                     if (state != CLOSE_RECVD) {
                         break;
                     }
                     throw wrapper.connectionCloseRebind() ;
                 }
             default:
                 if (orb.transportDebugFlag) {
                     dprint(".writeLock: default: " + this);
                 }
                 // REVISIT
                 throw new RuntimeException(".writeLock: bad state");
             }
         }
       } finally {
         if (dprintWriteLocks && orb.transportDebugFlag) {
             dprint(".writeLock<-: " + this);
         }
       }
     }
     public void writeUnlock()
     {
         try {
             if (dprintWriteLocks && orb.transportDebugFlag) {
                 dprint(".writeUnlock->: " + this);
             }
             synchronized (writeEvent) {
                 writeLocked = false;
                 writeEvent.notify(); // wake up one guy waiting to write
             }
         } finally {
             if (dprintWriteLocks && orb.transportDebugFlag) {
                 dprint(".writeUnlock<-: " + this);
             }
         }
     }
     // Assumes the caller handles writeLock and writeUnlock
     public void sendWithoutLock(OutputObject outputObject)
     {
         // Don't we need to check for CloseConnection
         // here?  REVISIT
         // XREVISIT - Shouldn't the MessageMediator
         // be the one to handle writing the data here?
         try {
             // Write the fragment/message
             CDROutputObject cdrOutputObject = (CDROutputObject) outputObject;
             cdrOutputObject.writeTo(this);
             // REVISIT - no flush?
             //socket.getOutputStream().flush();
         } catch (IOException e1) {
             /*
              * ADDED(Ram J) 10/13/2000 In the event of an IOException, try
              * sending a CancelRequest for regular requests / locate requests
              */
             // Since IIOPOutputStream's msgheader is set only once, and not
             // altered during sending multiple fragments, the original
             // msgheader will always have the requestId.
             // REVISIT This could be optimized to send a CancelRequest only
             // if any fragments had been sent already.
             /* REVISIT: MOVE TO SUBCONTRACT
             Message msg = os.getMessage();
             if (msg.getType() == Message.GIOPRequest ||
                     msg.getType() == Message.GIOPLocateRequest) {
                 GIOPVersion requestVersion = msg.getGIOPVersion();
                 int requestId = MessageBase.getRequestId(msg);
                 try {
                     sendCancelRequest(requestVersion, requestId);
                 } catch (IOException e2) {
                     // most likely an abortive connection closure.
                     // ignore, since nothing more can be done.
                     if (orb.transportDebugFlag) {
                 }
             }
             */
             // REVISIT When a send failure happens, purgeCalls() need to be
             // called to ensure that the connection is properly removed from
             // further usage (ie., cancelling pending requests with COMM_FAILURE
             // with an appropriate minor_code CompletionStatus.MAY_BE).
             // Relying on the IIOPOutputStream (as noted below) is not
             // sufficient as it handles COMM_FAILURE only for the final
             // fragment (during invoke processing). Note that COMM_FAILURE could
             // happen while sending the initial fragments.
             // Also the IIOPOutputStream does not properly close the connection.
             // It simply removes the connection from the table. An orderly
             // closure is needed (ie., cancel pending requests on the connection
             // COMM_FAILURE as well.
             // IIOPOutputStream will cleanup the connection info when it
             // sees this exception.
             SystemException exc = wrapper.writeErrorSend(e1);
             purgeCalls(exc, false, true);
             throw exc;
         }
     }
     public void registerWaiter(MessageMediator messageMediator)
     {
         responseWaitingRoom.registerWaiter(messageMediator);
     }
     public void unregisterWaiter(MessageMediator messageMediator)
     {
         responseWaitingRoom.unregisterWaiter(messageMediator);
     }
     public InputObject waitForResponse(MessageMediator messageMediator)
     {
         return responseWaitingRoom.waitForResponse(messageMediator);
     }
     public void setConnectionCache(ConnectionCache connectionCache)
     {
         this.connectionCache = connectionCache;
     }
     public ConnectionCache getConnectionCache()
     {
         return connectionCache;
     }
     ////////////////////////////////////////////////////
     //
     // EventHandler methods
     //
     public void setUseSelectThreadToWait(boolean x)
     {
         useSelectThreadToWait = x;
         // REVISIT - Reading of a GIOP header only is information
         //           that should be passed into the constructor
         //           from the SocketOrChannelConnection factory.
         setReadGiopHeaderOnly(shouldUseSelectThreadToWait());
     }
     public void handleEvent()
     {
         if (orb.transportDebugFlag) {
             dprint(".handleEvent->: " + this);
         }
         getSelectionKey().interestOps(getSelectionKey().interestOps() &
                                       (~ getInterestOps()));
         if (shouldUseWorkerThreadForEvent()) {
             Throwable throwable = null;
             try {
                 int poolToUse = 0;
                 if (shouldReadGiopHeaderOnly()) {
                     partialMessageMediator = readBits();
                     poolToUse =
                         partialMessageMediator.getThreadPoolToUse();
                 }
                 if (orb.transportDebugFlag) {
                     dprint(".handleEvent: addWork to pool: " + poolToUse);
                 }
                 orb.getThreadPoolManager().getThreadPool(poolToUse)
                     .getWorkQueue(0).addWork(getWork());
             } catch (NoSuchThreadPoolException e) {
                 throwable = e;
             } catch (NoSuchWorkQueueException e) {
                 throwable = e;
             }
             // REVISIT: need to close connection.
             if (throwable != null) {
                 if (orb.transportDebugFlag) {
                     dprint(".handleEvent: " + throwable);
                 }
                 INTERNAL i = new INTERNAL("NoSuchThreadPoolException");
                 i.initCause(throwable);
                 throw i;
             }
         } else {
             if (orb.transportDebugFlag) {
                 dprint(".handleEvent: doWork");
             }
             getWork().doWork();
         }
         if (orb.transportDebugFlag) {
             dprint(".handleEvent<-: " + this);
         }
     }
     public SelectableChannel getChannel()
     {
         return socketChannel;
     }
     public int getInterestOps()
     {
         return SelectionKey.OP_READ;
     }
     //    public Acceptor getAcceptor() - already defined above.
     public Connection getConnection()
     {
         return this;
     }
     ////////////////////////////////////////////////////
     //
     // Work methods.
     //
     public String getName()
     {
         return this.toString();
     }
     public void doWork()
     {
         try {
             if (orb.transportDebugFlag) {
                 dprint(".doWork->: " + this);
             }
             // IMPORTANT: Sanity checks on SelectionKeys such as
             //            SelectorKey.isValid() should not be done
             //            here.
             //
             if (!shouldReadGiopHeaderOnly()) {
                 read();
             }
             else {
                 // get the partialMessageMediator
                 // created by SelectorThread
                 CorbaMessageMediator messageMediator =
                                          this.getPartialMessageMediator();
                 // read remaining info needed in a MessageMediator
                 messageMediator = finishReadingBits(messageMediator);
                 if (messageMediator != null) {
                     // Null can happen when client closes stream
                     // causing purgecalls.
                     dispatch(messageMediator);
                 }
             }
         } catch (Throwable t) {
             if (orb.transportDebugFlag) {
                 dprint(".doWork: ignoring Throwable: "
                        + t
                        + " " + this);
             }
         } finally {
             if (orb.transportDebugFlag) {
                 dprint(".doWork<-: " + this);
             }
         }
     }
     public void setEnqueueTime(long timeInMillis)
     {
         enqueueTime = timeInMillis;
     }
     public long getEnqueueTime()
     {
         return enqueueTime;
     }
     ////////////////////////////////////////////////////
     //
     // spi.transport.CorbaConnection.
     //
     // IMPORTANT: Reader Threads must NOT read Giop header only.
     public boolean shouldReadGiopHeaderOnly() {
         return shouldReadGiopHeaderOnly;
     }
     protected void setReadGiopHeaderOnly(boolean shouldReadHeaderOnly) {
         shouldReadGiopHeaderOnly = shouldReadHeaderOnly;
     }
     public ResponseWaitingRoom getResponseWaitingRoom()
     {
         return responseWaitingRoom;
     }
     // REVISIT - inteface defines isServer but already defined in
     // higher interface.
     public void serverRequestMapPut(int requestId,
                                     CorbaMessageMediator messageMediator)
     {
         serverRequestMap.put(new Integer(requestId), messageMediator);
     }
     public CorbaMessageMediator serverRequestMapGet(int requestId)
     {
         return (CorbaMessageMediator)
             serverRequestMap.get(new Integer(requestId));
     }
     public void serverRequestMapRemove(int requestId)
     {
         serverRequestMap.remove(new Integer(requestId));
     }
     // REVISIT: this is also defined in:
     // com.sun.corba.se.spi.legacy.connection.Connection
     public java.net.Socket getSocket()
     {
         return socket;
     }
     /** It is possible for a Close Connection to have been
      ** sent here, but we will not check for this. A "lazy"
      ** Exception will be thrown in the Worker thread after the
      ** incoming request has been processed even though the connection
      ** is closed before the request is processed. This is o.k because
      ** it is a boundary condition. To prevent it we would have to add
      ** more locks which would reduce performance in the normal case.
      **/
     public synchronized void serverRequestProcessingBegins()
     {
         serverRequestCount++;
     }
     public synchronized void serverRequestProcessingEnds()
     {
         serverRequestCount--;
     }
     //
     //
     //
     public synchronized int getNextRequestId()
     {
         return requestId++;
     }
     // Negotiated code sets for char and wchar data
     protected CodeSetComponentInfo.CodeSetContext codeSetContext = null;
     public ORB getBroker()
     {
         return orb;
     }
     public CodeSetComponentInfo.CodeSetContext getCodeSetContext() {
         // Needs to be synchronized for the following case when the client
         // doesn't send the code set context twice, and we have two threads
         // in ServerRequestDispatcher processCodeSetContext.
         //
         // Thread A checks to see if there is a context, there is none, so
         //     it calls setCodeSetContext, getting the synch lock.
         // Thread B checks to see if there is a context.  If we didn't synch,
         //     it might decide to outlaw wchar/wstring.
         if (codeSetContext == null) {
             synchronized(this) {
                 return codeSetContext;
             }
         }
         return codeSetContext;
     }
     public synchronized void setCodeSetContext(CodeSetComponentInfo.CodeSetContext csc) {
         // Double check whether or not we need to do this
         if (codeSetContext == null) {
             if (OSFCodeSetRegistry.lookupEntry(csc.getCharCodeSet()) == null ||
                 OSFCodeSetRegistry.lookupEntry(csc.getWCharCodeSet()) == null) {
                 // If the client says it's negotiated a code set that
                 // isn't a fallback and we never said we support, then
                 // it has a bug.
                 throw wrapper.badCodesetsFromClient() ;
             }
             codeSetContext = csc;
         }
     }
     //
     // from iiop.IIOPConnection.java
     //
     // Map request ID to an InputObject.
     // This is so the client thread can start unmarshaling
     // the reply and remove it from the out_calls map while the
     // ReaderThread can still obtain the input stream to give
     // new fragments.  Only the ReaderThread touches the clientReplyMap,
     // so it doesn't incur synchronization overhead.
     public MessageMediator clientRequestMapGet(int requestId)
     {
         return responseWaitingRoom.getMessageMediator(requestId);
     }
     protected MessageMediator clientReply_1_1;
     public void clientReply_1_1_Put(MessageMediator x)
     {
         clientReply_1_1 = x;
     }
     public MessageMediator clientReply_1_1_Get()
     {
         return  clientReply_1_1;
     }
     public void clientReply_1_1_Remove()
     {
         clientReply_1_1 = null;
     }
     protected MessageMediator serverRequest_1_1;
     public void serverRequest_1_1_Put(MessageMediator x)
     {
         serverRequest_1_1 = x;
     }
     public MessageMediator serverRequest_1_1_Get()
     {
         return  serverRequest_1_1;
     }
     public void serverRequest_1_1_Remove()
     {
         serverRequest_1_1 = null;
     }
     protected String getStateString( int state )
     {
         synchronized ( stateEvent ){
             switch (state) {
             case OPENING : return "OPENING" ;
             case ESTABLISHED : return "ESTABLISHED" ;
             case CLOSE_SENT : return "CLOSE_SENT" ;
             case CLOSE_RECVD : return "CLOSE_RECVD" ;
             case ABORT : return "ABORT" ;
             default : return "???" ;
             }
         }
     }
     public synchronized boolean isPostInitialContexts() {
         return postInitialContexts;
     }
     // Can never be unset...
     public synchronized void setPostInitialContexts(){
         postInitialContexts = true;
     }
     /**
      * Wake up the outstanding requests on the connection, and hand them
      * COMM_FAILURE exception with a given minor code.
      *
      * Also, delete connection from connection table and
      * stop the reader thread.
      * Note that this should only ever be called by the Reader thread for
      * this connection.
      *
      * @param minor_code The minor code for the COMM_FAILURE major code.
      * @param die Kill the reader thread (this thread) before exiting.
      */
     public void purgeCalls(SystemException systemException,
                            boolean die, boolean lockHeld)
     {
         int minor_code = systemException.minor;
         try{
             if (orb.transportDebugFlag) {
                 dprint(".purgeCalls->: "
                        + minor_code + "/" + die + "/" + lockHeld
                        + " " + this);
             }
             // If this invocation is a result of ThreadDeath caused
             // by a previous execution of this routine, just exit.
             synchronized ( stateEvent ){
                 if ((state == ABORT) || (state == CLOSE_RECVD)) {
                     if (orb.transportDebugFlag) {
                         dprint(".purgeCalls: exiting since state is: "
                                + getStateString(state)
                                + " " + this);
                     }
                     return;
                 }
             }
             // Grab the writeLock (freeze the calls)
             try {
                 if (!lockHeld) {
                     writeLock();
                 }
             } catch (SystemException ex) {
                 if (orb.transportDebugFlag)
                     dprint(".purgeCalls: SystemException" + ex
                            + "; continuing " + this);
             }
             // Mark the state of the connection
             // and determine the request status
             org.omg.CORBA.CompletionStatus completion_status;
             synchronized ( stateEvent ){
                 if (minor_code == ORBUtilSystemException.CONNECTION_REBIND) {
                     state = CLOSE_RECVD;
                     systemException.completed = CompletionStatus.COMPLETED_NO;
                 } else {
                     state = ABORT;
                     systemException.completed = CompletionStatus.COMPLETED_MAYBE;
                 }
                 stateEvent.notifyAll();
             }
             try {
                 socket.getInputStream().close();
                 socket.getOutputStream().close();
                 socket.close();
             } catch (Exception ex) {
                 if (orb.transportDebugFlag) {
                     dprint(".purgeCalls: Exception closing socket: " + ex
                            + " " + this);
                 }
             }
             // Signal all threads with outstanding requests on this
             // connection and give them the SystemException;
             responseWaitingRoom.signalExceptionToAllWaiters(systemException);
             if (contactInfo != null) {
                 ((OutboundConnectionCache)getConnectionCache()).remove(contactInfo);
             } else if (acceptor != null) {
                 ((InboundConnectionCache)getConnectionCache()).remove(this);
             }
             //
             // REVISIT: Stop the reader thread
             //
             // Signal all the waiters of the writeLock.
             // There are 4 types of writeLock waiters:
             // 1. Send waiters:
             // 2. SendReply waiters:
             // 3. cleanUp waiters:
             // 4. purge_call waiters:
             //
             writeUnlock();
         } finally {
             if (orb.transportDebugFlag) {
                 dprint(".purgeCalls<-: "
                        + minor_code + "/" + die + "/" + lockHeld
                        + " " + this);
             }
         }
     }
     /*************************************************************************
     * The following methods are for dealing with Connection cleaning for
     * better scalability of servers in high network load conditions.
     **************************************************************************/
     public void sendCloseConnection(GIOPVersion giopVersion)
         throws IOException
     {
         Message msg = MessageBase.createCloseConnection(giopVersion);
         sendHelper(giopVersion, msg);
     }
     public void sendMessageError(GIOPVersion giopVersion)
         throws IOException
     {
         Message msg = MessageBase.createMessageError(giopVersion);
         sendHelper(giopVersion, msg);
     }
     /**
      * Send a CancelRequest message. This does not lock the connection, so the
      * caller needs to ensure this method is called appropriately.
      * @exception IOException - could be due to abortive connection closure.
      */
     public void sendCancelRequest(GIOPVersion giopVersion, int requestId)
         throws IOException
     {
         Message msg = MessageBase.createCancelRequest(giopVersion, requestId);
         sendHelper(giopVersion, msg);
     }
     protected void sendHelper(GIOPVersion giopVersion, Message msg)
         throws IOException
     {
         // REVISIT: See comments in CDROutputObject constructor.
         CDROutputObject outputObject =
             new CDROutputObject((ORB)orb, null, giopVersion, this, msg,
                                 ORBConstants.STREAM_FORMAT_VERSION_1);
         msg.write(outputObject);
         outputObject.writeTo(this);
     }
     public void sendCancelRequestWithLock(GIOPVersion giopVersion,
                                           int requestId)
         throws IOException
     {
         writeLock();
         try {
             sendCancelRequest(giopVersion, requestId);
         } finally {
             writeUnlock();
         }
     }
     // Begin Code Base methods ---------------------------------------
     //
     // Set this connection's code base IOR.  The IOR comes from the
     // SendingContext.  This is an optional service context, but all
     // JavaSoft ORBs send it.
     //
     // The set and get methods don't need to be synchronized since the
     // first possible get would occur during reading a valuetype, and
     // that would be after the set.
     // Sets this connection's code base IOR.  This is done after
     // getting the IOR out of the SendingContext service context.
     // Our ORBs always send this, but it's optional in CORBA.
     public final void setCodeBaseIOR(IOR ior) {
         codeBaseServerIOR = ior;
     }
     public final IOR getCodeBaseIOR() {
         return codeBaseServerIOR;
     }
     // Get a CodeBase stub to use in unmarshaling.  The CachedCodeBase
     // won't connect to the remote codebase unless it's necessary.
     public final CodeBase getCodeBase() {
         return cachedCodeBase;
     }
     // End Code Base methods -----------------------------------------
     // set transport read thresholds
     protected void setReadTimeouts(ReadTimeouts readTimeouts) {
         this.readTimeouts = readTimeouts;
     }
     protected void setPartialMessageMediator(CorbaMessageMediator messageMediator) {
         partialMessageMediator = messageMediator;
     }
     protected CorbaMessageMediator getPartialMessageMediator() {
         return partialMessageMediator;
     }
     public String toString()
     {
         synchronized ( stateEvent ){
             return
                 "SocketOrChannelConnectionImpl[" + " "
                 + (socketChannel == null ?
                    socket.toString() : socketChannel.toString()) + " "
                 + getStateString( state ) + " "
                 + shouldUseSelectThreadToWait() + " "
                 + shouldUseWorkerThreadForEvent() + " "
                 + shouldReadGiopHeaderOnly()
                 + "]" ;
         }
     }
     // Must be public - used in encoding.
     public void dprint(String msg)
     {
         ORBUtility.dprint("SocketOrChannelConnectionImpl", msg);
     }
     protected void dprint(String msg, Throwable t)
     {
         dprint(msg);
         t.printStackTrace(System.out);
     }
 }
 // End of file.

Mercurial > jdk8-mips64-public > corba / annotate

src/share/classes/com/sun/corba/se/impl/transport/SocketOrChannelConnectionImpl.java@f90b3e014e83 (annotated)

src/share/classes/com/sun/corba/se/impl/transport/SocketOrChannelConnectionImpl.java