SecureNioChannel (Apache Tomcat 7.0.103 API Documentation)

org.apache.tomcat.util.net

## Class SecureNioChannel

- java.lang.Object
- - org.apache.tomcat.util.net.NioChannel
  - - org.apache.tomcat.util.net.SecureNioChannel

- All Implemented Interfaces:
    Closeable, AutoCloseable, ByteChannel, Channel, ReadableByteChannel, WritableByteChannel

      public class SecureNioChannel
      extends NioChannel

  Implementation of a secure socket channel

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static interface` | `SecureNioChannel.ApplicationBufferHandler` Callback interface to be able to expand buffers when buffer overflow exceptions happen

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected boolean` | `closed`
    `protected boolean` | `closing`
    `protected boolean` | `handshakeComplete`
    `protected SSLEngineResult.HandshakeStatus` | `handshakeStatus`
    `protected static Log` | `log`
    `protected ByteBuffer` | `netInBuffer`
    `protected ByteBuffer` | `netOutBuffer`
    `protected NioSelectorPool` | `pool`
    `protected SSLEngine` | `sslEngine`

    - ### Fields inherited from class org.apache.tomcat.util.net.NioChannel

      `bufHandler, emptyBuf, poller, sc, sm`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `SecureNioChannel(SocketChannel channel, SSLEngine engine, SecureNioChannel.ApplicationBufferHandler bufHandler, NioSelectorPool pool)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `close()` Sends an SSL close message, will not physically close the connection here.
    `void` | `close(boolean force)`
    `boolean` | `flush(boolean block, Selector s, long timeout)` Flush the channel.
    `protected boolean` | `flush(ByteBuffer buf)` Flushes the buffer to the network, non blocking
    `boolean` | `flushOutbound()` Return true if the buffer wrote data
    `int` | `getBufferSize()`
    `SecureNioChannel.ApplicationBufferHandler` | `getBufHandler()` getBufHandler
    `ByteBuffer` | `getEmptyBuf()`
    `int` | `getOutboundRemaining()`
    `SSLEngine` | `getSslEngine()`
    `int` | `handshake(boolean read, boolean write)` Performs SSL handshake, non blocking, but performs NEED_TASK on the same thread.
    `protected SSLEngineResult` | `handshakeUnwrap(boolean doread)` Perform handshake unwrap
    `protected SSLEngineResult` | `handshakeWrap(boolean doWrite)` Performs the WRAP function
    `boolean` | `isClosing()` isClosing
    `boolean` | `isHandshakeComplete()` isInitHandshakeComplete
    `int` | `read(ByteBuffer dst)` Reads a sequence of bytes from this channel into the given buffer.
    `void` | `rehandshake(long timeout)` Force a blocking handshake to take place for this key.
    `void` | `reset()`
    `void` | `reset(SSLEngine engine)`
    `void` | `setBufHandler(SecureNioChannel.ApplicationBufferHandler bufHandler)`
    `protected SSLEngineResult.HandshakeStatus` | `tasks()` Executes all the tasks needed on the same thread.
    `int` | `write(ByteBuffer src)` Writes a sequence of bytes to this channel from the given buffer.

    - ### Methods inherited from class org.apache.tomcat.util.net.NioChannel

      `checkInterruptStatus, getAttachment, getIOChannel, getPoller, isOpen, setIOChannel, setPoller, toString`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### log

          protected static final Log log

    - #### netInBuffer

          protected ByteBuffer netInBuffer

    - #### netOutBuffer

          protected ByteBuffer netOutBuffer

    - #### sslEngine

          protected SSLEngine sslEngine

    - #### handshakeComplete

          protected boolean handshakeComplete

    - #### handshakeStatus

          protected SSLEngineResult.HandshakeStatus handshakeStatus

    - #### closed

          protected boolean closed

    - #### closing

          protected boolean closing

    - #### pool

          protected NioSelectorPool pool

  - ### Constructor Detail

    - #### SecureNioChannel

          public SecureNioChannel(SocketChannel channel,
                          SSLEngine engine,
                          SecureNioChannel.ApplicationBufferHandler bufHandler,
                          NioSelectorPool pool)
                           throws IOException

      Throws:
        `IOException`

  - ### Method Detail

    - #### reset

          public void reset(SSLEngine engine)
                     throws IOException

      Throws:
        `IOException`

    - #### reset

          public void reset()
                     throws IOException

      Overrides:
        `reset` in class `NioChannel`
      Throws:
        `IOException`

    - #### getBufferSize

          public int getBufferSize()

      Overrides:
        `getBufferSize` in class `NioChannel`

    - #### flush

          public boolean flush(boolean block,
                      Selector s,
                      long timeout)
                        throws IOException

      Flush the channel.
      Overrides:
        `flush` in class `NioChannel`
      Parameters:
        `block` - Should a blocking write be used?
        `s` - The selector to use for blocking, if null then a busy write will be initiated
        `timeout` - The timeout for this write operation in milliseconds, -1 means no timeout
      Returns:
        `true` if the network buffer has been flushed out and is empty else `false`
      Throws:
        `IOException` - If an I/O error occurs during the operation

    - #### flush

          protected boolean flush(ByteBuffer buf)
                           throws IOException

      Flushes the buffer to the network, non blocking
      Parameters:
        `buf` - ByteBuffer
      Returns:
        boolean true if the buffer has been emptied out, false otherwise
      Throws:
        `IOException` - An IO error occurred writing data

    - #### handshake

          public int handshake(boolean read,
                      boolean write)
                        throws IOException

      Performs SSL handshake, non blocking, but performs NEED_TASK on the same thread. Hence, you should never call this method using your Acceptor thread, as you would slow down your system significantly. If the return value from this method is positive, the selection key should be registered interestOps given by the return value.
      Overrides:
        `handshake` in class `NioChannel`
      Parameters:
        `read` - boolean - true if the underlying channel is readable
        `write` - boolean - true if the underlying channel is writable
      Returns:
        0 if hand shake is complete, -1 if an error (other than an IOException) occurred, otherwise it returns a SelectionKey interestOps value
      Throws:
        `IOException` - If an I/O error occurs during the handshake or if the handshake fails during wrapping or unwrapping

    - #### rehandshake

          public void rehandshake(long timeout)
                           throws IOException

      Force a blocking handshake to take place for this key. This requires that both network and application buffers have been emptied out prior to this call taking place, or a IOException will be thrown.
      Parameters:
        `timeout` - - timeout in milliseconds for each socket operation
      Throws:
        `IOException` - - if an IO exception occurs or if application or network buffers contain data
        `SocketTimeoutException` - - if a socket operation timed out

    - #### tasks

          protected SSLEngineResult.HandshakeStatus tasks()

      Executes all the tasks needed on the same thread.
      Returns:
        the status

    - #### handshakeWrap

          protected SSLEngineResult handshakeWrap(boolean doWrite)
                                           throws IOException

      Performs the WRAP function
      Parameters:
        `doWrite` - boolean
      Returns:
        the result
      Throws:
        `IOException` - An IO error occurred

    - #### handshakeUnwrap

          protected SSLEngineResult handshakeUnwrap(boolean doread)
                                             throws IOException

      Perform handshake unwrap
      Parameters:
        `doread` - boolean
      Returns:
        the result
      Throws:
        `IOException` - An IO error occurred

    - #### close

          public void close()
                     throws IOException

      Sends an SSL close message, will not physically close the connection here.
      To close the connection, you could do something like

             close();
             while (isOpen() && !myTimeoutFunction()) Thread.sleep(25);
             if ( isOpen() ) close(true); //forces a close if you timed out

      Specified by:
        `close` in interface `Closeable`
      Specified by:
        `close` in interface `AutoCloseable`
      Specified by:
        `close` in interface `Channel`
      Overrides:
        `close` in class `NioChannel`
      Throws:
        `IOException` - if an I/O error occurs
        `IOException` - if there is data on the outgoing network buffer and we are unable to flush it

    - #### close

          public void close(boolean force)
                     throws IOException

      Overrides:
        `close` in class `NioChannel`
      Throws:
        `IOException`

    - #### read

          public int read(ByteBuffer dst)
                   throws IOException

      Reads a sequence of bytes from this channel into the given buffer.
      Specified by:
        `read` in interface `ReadableByteChannel`
      Overrides:
        `read` in class `NioChannel`
      Parameters:
        `dst` - The buffer into which bytes are to be transferred
      Returns:
        The number of bytes read, possibly zero, or `-1` if the channel has reached end-of-stream
      Throws:
        `IOException` - If some other I/O error occurs
        `IllegalArgumentException` - if the destination buffer is different than getBufHandler().getReadBuffer()

    - #### write

          public int write(ByteBuffer src)
                    throws IOException

      Writes a sequence of bytes to this channel from the given buffer.
      Specified by:
        `write` in interface `WritableByteChannel`
      Overrides:
        `write` in class `NioChannel`
      Parameters:
        `src` - The buffer from which bytes are to be retrieved
      Returns:
        The number of bytes written, possibly zero
      Throws:
        `IOException` - If some other I/O error occurs

    - #### getOutboundRemaining

          public int getOutboundRemaining()

      Overrides:
        `getOutboundRemaining` in class `NioChannel`

    - #### flushOutbound

          public boolean flushOutbound()
                                throws IOException

      Description copied from class: `NioChannel`
      Return true if the buffer wrote data
      Overrides:
        `flushOutbound` in class `NioChannel`
      Throws:
        `IOException`

    - #### getBufHandler

          public SecureNioChannel.ApplicationBufferHandler getBufHandler()

      Description copied from class: `NioChannel`
      getBufHandler
      Overrides:
        `getBufHandler` in class `NioChannel`
      Returns:
        ApplicationBufferHandler

    - #### isHandshakeComplete

          public boolean isHandshakeComplete()

      Description copied from class: `NioChannel`
      isInitHandshakeComplete
      Overrides:
        `isHandshakeComplete` in class `NioChannel`
      Returns:
        boolean

    - #### isClosing

          public boolean isClosing()

      Description copied from class: `NioChannel`
      isClosing
      Overrides:
        `isClosing` in class `NioChannel`
      Returns:
        boolean

    - #### getSslEngine

          public SSLEngine getSslEngine()

    - #### getEmptyBuf

          public ByteBuffer getEmptyBuf()

    - #### setBufHandler

          public void setBufHandler(SecureNioChannel.ApplicationBufferHandler bufHandler)

Copyright © 2000-2020 Apache Software Foundation. All Rights Reserved.