Package org.apache.tomcat.util.net

## Class SecureNio2Channel

- java.lang.Object
- - org.apache.tomcat.util.net.Nio2Channel
  - - org.apache.tomcat.util.net.SecureNio2Channel

All Implemented Interfaces:
  `java.io.Closeable`, `java.lang.AutoCloseable`, `java.nio.channels.AsynchronousByteChannel`, `java.nio.channels.AsynchronousChannel`, `java.nio.channels.Channel`

    public class SecureNio2Channel
    extends Nio2Channel

Implementation of a secure socket channel for NIO2.

### Field Summary

Fields
`protected boolean` `closed`
`protected boolean` `closing`
`protected Nio2Endpoint` `endpoint`
`protected java.nio.ByteBuffer` `netInBuffer`
`protected java.nio.ByteBuffer` `netOutBuffer`
`protected boolean` `sniComplete`
`protected javax.net.ssl.SSLEngine` `sslEngine`

### Fields inherited from class org.apache.tomcat.util.net.Nio2Channel

`bufHandler, emptyBuf, sc, socketWrapper`

### Constructor Summary

Constructors
`SecureNio2Channel​(SocketBufferHandler bufHandler, Nio2Endpoint endpoint)`

### Method Summary

All Methods Instance Methods Concrete Methods
`void` `close()` Sends an SSL close message, will not physically close the connection here. To close the connection, you could do something like
`void` `close​(boolean force)` Close the connection.
`java.util.concurrent.Future<java.lang.Boolean>` `flush()` Flush the channel.
`void` `free()` Free the channel memory
`java.nio.ByteBuffer` `getEmptyBuf()`
`javax.net.ssl.SSLEngine` `getSslEngine()`
`SSLSupport` `getSSLSupport()`
`int` `handshake()` Performs SSL handshake, non blocking, but performs NEED_TASK on the same thread.
`protected int` `handshakeInternal​(boolean async)`
`protected javax.net.ssl.SSLEngineResult` `handshakeUnwrap()` Perform handshake unwrap
`protected javax.net.ssl.SSLEngineResult` `handshakeWrap()` Performs the WRAP function
`boolean` `isClosing()`
`boolean` `isHandshakeComplete()`
`java.util.concurrent.Future<java.lang.Integer>` `read​(java.nio.ByteBuffer dst)` Reads a sequence of bytes from this channel into the given buffer.
`<A> void` `read​(java.nio.ByteBuffer[] dsts, int offset, int length, long timeout, java.util.concurrent.TimeUnit unit, A attachment, java.nio.channels.CompletionHandler<java.lang.Long,​? super A> handler)`
`<A> void` `read​(java.nio.ByteBuffer dst, long timeout, java.util.concurrent.TimeUnit unit, A attachment, java.nio.channels.CompletionHandler<java.lang.Integer,​? super A> handler)`
`void` `rehandshake()` Force a blocking handshake to take place for this key.
`void` `reset​(java.nio.channels.AsynchronousSocketChannel channel, SocketWrapperBase<Nio2Channel> socket)` Reset the channel.
`protected javax.net.ssl.SSLEngineResult.HandshakeStatus` `tasks()` Executes all the tasks needed on the same thread.
`java.util.concurrent.Future<java.lang.Integer>` `write​(java.nio.ByteBuffer src)` Writes a sequence of bytes to this channel from the given buffer.
`<A> void` `write​(java.nio.ByteBuffer[] srcs, int offset, int length, long timeout, java.util.concurrent.TimeUnit unit, A attachment, java.nio.channels.CompletionHandler<java.lang.Long,​? super A> handler)`
`<A> void` `write​(java.nio.ByteBuffer src, long timeout, java.util.concurrent.TimeUnit unit, A attachment, java.nio.channels.CompletionHandler<java.lang.Integer,​? super A> handler)`

### Methods inherited from class org.apache.tomcat.util.net.Nio2Channel

`getAppReadBufHandler, getBufHandler, getIOChannel, isOpen, read, setAppReadBufHandler, toString, write`

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

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

### Field Detail

#### endpoint

    protected final Nio2Endpoint endpoint

#### netInBuffer

    protected java.nio.ByteBuffer netInBuffer

#### netOutBuffer

    protected java.nio.ByteBuffer netOutBuffer

#### sslEngine

    protected javax.net.ssl.SSLEngine sslEngine

#### sniComplete

    protected volatile boolean sniComplete

#### closed

    protected boolean closed

#### closing

    protected boolean closing

### Constructor Detail

#### SecureNio2Channel

    public SecureNio2Channel​(SocketBufferHandler bufHandler,
                             Nio2Endpoint endpoint)

### Method Detail

#### reset

    public void reset​(java.nio.channels.AsynchronousSocketChannel channel,
                      SocketWrapperBase<Nio2Channel> socket)
               throws java.io.IOException

Description copied from class: `Nio2Channel`
Reset the channel.

Overrides:
  `reset` in class `Nio2Channel`
Parameters:
  `channel` - The new async channel to associate with this NIO2 channel
  `socket` - The new socket to associate with this NIO2 channel
Throws:
  `java.io.IOException` - If a problem was encountered resetting the channel

#### free

    public void free()

Description copied from class: `Nio2Channel`
Free the channel memory

Overrides:
  `free` in class `Nio2Channel`

#### flush

    public java.util.concurrent.Future<java.lang.Boolean> flush()

Flush the channel.

Overrides:
  `flush` in class `Nio2Channel`
Returns:
  `true` if the network buffer has been flushed out and is empty else `false` (as a future)

#### handshake

    public int handshake()
                  throws java.io.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.

The return for this operation is 0 if the handshake is complete and a positive value if it is not complete. In the event of a positive value coming back, the appropriate read/write will already have been called with an appropriate CompletionHandler.

Overrides:
  `handshake` in class `Nio2Channel`
Returns:
  0 if hand shake is complete, negative if the socket needs to close and positive if the handshake is incomplete
Throws:
  `java.io.IOException` - if an error occurs during the handshake

#### handshakeInternal

    protected int handshakeInternal​(boolean async)
                             throws java.io.IOException

Throws:
  `java.io.IOException`

#### rehandshake

    public void rehandshake()
                     throws java.io.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.

Throws:
  `java.io.IOException` - - if an IO exception occurs or if application or network buffers contain data
  `java.net.SocketTimeoutException` - - if a socket operation timed out

#### tasks

    protected javax.net.ssl.SSLEngineResult.HandshakeStatus tasks()

Executes all the tasks needed on the same thread.

Returns:
  the status

#### handshakeWrap

    protected javax.net.ssl.SSLEngineResult handshakeWrap()
                                                   throws java.io.IOException

Performs the WRAP function

Returns:
  the result
Throws:
  `java.io.IOException` - An IO error occurred

#### handshakeUnwrap

    protected javax.net.ssl.SSLEngineResult handshakeUnwrap()
                                                     throws java.io.IOException

Perform handshake unwrap

Returns:
  the result
Throws:
  `java.io.IOException` - An IO error occurred

#### getSSLSupport

    public SSLSupport getSSLSupport()

#### close

    public void close()
               throws java.io.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 `java.nio.channels.AsynchronousChannel`
Specified by:
  `close` in interface `java.lang.AutoCloseable`
Specified by:
  `close` in interface `java.nio.channels.Channel`
Specified by:
  `close` in interface `java.io.Closeable`
Overrides:
  `close` in class `Nio2Channel`
Throws:
  `java.io.IOException` - if an I/O error occurs
  `java.io.IOException` - if there is data on the outgoing network buffer and we are unable to flush it

#### close

    public void close​(boolean force)
               throws java.io.IOException

Description copied from class: `Nio2Channel`
Close the connection.

Overrides:
  `close` in class `Nio2Channel`
Parameters:
  `force` - Should the underlying socket be forcibly closed?
Throws:
  `java.io.IOException` - If closing the secure channel fails.

#### read

    public java.util.concurrent.Future<java.lang.Integer> read​(java.nio.ByteBuffer dst)

Reads a sequence of bytes from this channel into the given buffer.

Specified by:
  `read` in interface `java.nio.channels.AsynchronousByteChannel`
Overrides:
  `read` in class `Nio2Channel`
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:
  `java.lang.IllegalStateException` - if the handshake was not completed

#### write

    public java.util.concurrent.Future<java.lang.Integer> write​(java.nio.ByteBuffer src)

Writes a sequence of bytes to this channel from the given buffer.

Specified by:
  `write` in interface `java.nio.channels.AsynchronousByteChannel`
Overrides:
  `write` in class `Nio2Channel`
Parameters:
  `src` - The buffer from which bytes are to be retrieved
Returns:
  The number of bytes written, possibly zero

#### read

    public <A> void read​(java.nio.ByteBuffer dst,
                         long timeout,
                         java.util.concurrent.TimeUnit unit,
                         A attachment,
                         java.nio.channels.CompletionHandler<java.lang.Integer,​? super A> handler)

Overrides:
  `read` in class `Nio2Channel`

#### read

    public <A> void read​(java.nio.ByteBuffer[] dsts,
                         int offset,
                         int length,
                         long timeout,
                         java.util.concurrent.TimeUnit unit,
                         A attachment,
                         java.nio.channels.CompletionHandler<java.lang.Long,​? super A> handler)

Overrides:
  `read` in class `Nio2Channel`

#### write

    public <A> void write​(java.nio.ByteBuffer src,
                          long timeout,
                          java.util.concurrent.TimeUnit unit,
                          A attachment,
                          java.nio.channels.CompletionHandler<java.lang.Integer,​? super A> handler)

Overrides:
  `write` in class `Nio2Channel`

#### write

    public <A> void write​(java.nio.ByteBuffer[] srcs,
                          int offset,
                          int length,
                          long timeout,
                          java.util.concurrent.TimeUnit unit,
                          A attachment,
                          java.nio.channels.CompletionHandler<java.lang.Long,​? super A> handler)

Overrides:
  `write` in class `Nio2Channel`

#### isHandshakeComplete

    public boolean isHandshakeComplete()

Overrides:
  `isHandshakeComplete` in class `Nio2Channel`

#### isClosing

    public boolean isClosing()

Overrides:
  `isClosing` in class `Nio2Channel`

#### getSslEngine

    public javax.net.ssl.SSLEngine getSslEngine()

#### getEmptyBuf

    public java.nio.ByteBuffer getEmptyBuf()