SecureNio2Channel (Apache Tomcat 8.0.53 API Documentation)

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.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`SecureNio2Channel.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 Nio2Endpoint`	`endpoint`
`protected static Log`	`log`
`protected java.nio.ByteBuffer`	`netInBuffer`
`protected java.nio.ByteBuffer`	`netOutBuffer`
`protected boolean`	`readPending`
`protected static StringManager`	`sm`
`protected javax.net.ssl.SSLEngine`	`sslEngine`
`protected boolean`	`writePending`

Fields inherited from class org.apache.tomcat.util.net.Nio2Channel
bufHandler, emptyBuf, sc, socket

Constructor Summary

Constructors
Constructor and Description
`SecureNio2Channel(javax.net.ssl.SSLEngine engine, SecureNio2Channel.ApplicationBufferHandler bufHandler, Nio2Endpoint endpoint0)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`close()` Sends a SSL close message, will not physically close the connection here.
`void`	`close(boolean force)` Force a close, can throw an IOException
`java.util.concurrent.Future<java.lang.Boolean>`	`flush()` Flush the channel.
`int`	`getBufferSize()`
`SecureNio2Channel.ApplicationBufferHandler`	`getBufHandler()`
`java.nio.ByteBuffer`	`getEmptyBuf()`
`javax.net.ssl.SSLEngine`	`getSslEngine()`
`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 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, SocketWrapper<Nio2Channel> socket)` Reset the channel
`void`	`setBufHandler(SecureNio2Channel.ApplicationBufferHandler bufHandler)`
`void`	`setSSLEngine(javax.net.ssl.SSLEngine engine)`
`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
getIOChannel, getSocket, isOpen, read, toString, write

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
```
  - sm
```
protected static final StringManager sm
```
  - netInBuffer
```
protected java.nio.ByteBuffer netInBuffer
```
  - netOutBuffer
```
protected java.nio.ByteBuffer netOutBuffer
```
  - sslEngine
```
protected javax.net.ssl.SSLEngine sslEngine
```
  - endpoint
```
protected final Nio2Endpoint endpoint
```
  - closed
```
protected boolean closed
```
  - closing
```
protected boolean closing
```
  - readPending
```
protected volatile boolean readPending
```
  - writePending
```
protected volatile boolean writePending
```
- Constructor Detail
  - SecureNio2Channel
```
public SecureNio2Channel(javax.net.ssl.SSLEngine engine,
                 SecureNio2Channel.ApplicationBufferHandler bufHandler,
                 Nio2Endpoint endpoint0)
```
- Method Detail
  - setSSLEngine
```
public void setSSLEngine(javax.net.ssl.SSLEngine engine)
```
  - reset
```
public void reset(java.nio.channels.AsynchronousSocketChannel channel,
         SocketWrapper<Nio2Channel> socket)
           throws java.io.IOException
```
    Description copied from class: Nio2Channel
    
    Reset the channel
    
    Overrides:
    
    reset in class Nio2Channel
    
    Throws:
    
    java.io.IOException - If a problem was encountered resetting the channel
  - getBufferSize
```
public int getBufferSize()
```
    Overrides:
    
    getBufferSize 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
  - 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:
    HandshakeStatus
  - handshakeWrap
```
protected javax.net.ssl.SSLEngineResult handshakeWrap()
                                               throws java.io.IOException
```
    Performs the WRAP function
    
    Returns:
    SSLEngineResult
    
    Throws:
    
    java.io.IOException
  - handshakeUnwrap
```
protected javax.net.ssl.SSLEngineResult handshakeUnwrap()
                                                 throws java.io.IOException
```
    Perform handshake unwrap
    
    Returns:
    SSLEngineResult
    
    Throws:
    
    java.io.IOException
  - close
```
public void close()
           throws java.io.IOException
```
    Sends a 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.io.Closeable
    
    Specified by:
    
    close in interface java.lang.AutoCloseable
    
    Specified by:
    
    close in interface java.nio.channels.AsynchronousChannel
    
    Specified by:
    
    close in interface java.nio.channels.Channel
    
    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
```
    Force a close, can throw an IOException
    
    Overrides:
    
    close in class Nio2Channel
    
    Parameters:
    force - boolean
    
    Throws:
    
    java.io.IOException
  - 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
  - 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
  - getBufHandler
```
public SecureNio2Channel.ApplicationBufferHandler getBufHandler()
```
    Overrides:
    
    getBufHandler 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()
```
  - setBufHandler
```
public void setBufHandler(SecureNio2Channel.ApplicationBufferHandler bufHandler)
```

Class SecureNio2Channel

Nested Class Summary

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

log

sm

netInBuffer

netOutBuffer

sslEngine

endpoint

closed

closing

readPending

writePending

Constructor Detail

SecureNio2Channel

Method Detail

setSSLEngine

reset

getBufferSize

flush

handshake

handshakeInternal

rehandshake

tasks

handshakeWrap

handshakeUnwrap

close

close

read

write

read

write

write

getBufHandler

isHandshakeComplete

isClosing

getSslEngine

getEmptyBuf

setBufHandler