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:

Closeable, AutoCloseable, AsynchronousByteChannel, AsynchronousChannel, Channel

public class SecureNio2Channel
extends Nio2Channel

Implementation of a secure socket channel for NIO2.

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	closed
protected boolean	closing
protected Nio2Endpoint	endpoint
protected ByteBuffer	netInBuffer
protected ByteBuffer	netOutBuffer
protected boolean	sniComplete
protected SSLEngine	sslEngine

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

bufHandler, emptyBuf, sc, socket

Constructor Summary

Constructors

Constructor and Description
SecureNio2Channel(SocketBufferHandler bufHandler, Nio2Endpoint endpoint)

Method Summary

Modifier and Type	Method and Description
void	close() Sends a SSL close message, will not physically close the connection here.
void	close(boolean force) Close the connection.
Future<Boolean>	flush() Flush the channel.
void	free() Free the channel memory
ByteBuffer	getEmptyBuf()
AsynchronousSocketChannel	getIOChannel()
SSLEngine	getSslEngine()
int	handshake() Performs SSL handshake, non blocking, but performs NEED_TASK on the same thread.
protected int	handshakeInternal(boolean async)
protected SSLEngineResult	handshakeUnwrap() Perform handshake unwrap
protected SSLEngineResult	handshakeWrap() Performs the WRAP function
boolean	isClosing()
boolean	isHandshakeComplete()
Future<Integer>	read(ByteBuffer dst) Reads a sequence of bytes from this channel into the given buffer.
<A> void	read(ByteBuffer[] dsts, int offset, int length, long timeout, TimeUnit unit, A attachment, CompletionHandler<Long,? super A> handler)
<A> void	read(ByteBuffer dst, long timeout, TimeUnit unit, A attachment, CompletionHandler<Integer,? super A> handler)
void	rehandshake() Force a blocking handshake to take place for this key.
void	reset(AsynchronousSocketChannel channel, SocketWrapperBase<Nio2Channel> socket) Reset the channel.
protected SSLEngineResult.HandshakeStatus	tasks() Executes all the tasks needed on the same thread.
Future<Integer>	write(ByteBuffer src) Writes a sequence of bytes to this channel from the given buffer.
<A> void	write(ByteBuffer[] srcs, int offset, int length, long timeout, TimeUnit unit, A attachment, CompletionHandler<Long,? super A> handler)
<A> void	write(ByteBuffer src, long timeout, TimeUnit unit, A attachment, CompletionHandler<Integer,? super A> handler)

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

getBufHandler, getSocket, isOpen, read, toString, write

Methods inherited from class java.lang.Object

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

Field Detail

netInBuffer

protected ByteBuffer netInBuffer

netOutBuffer

protected ByteBuffer netOutBuffer

sslEngine

protected SSLEngine sslEngine

endpoint

protected final Nio2Endpoint endpoint

sniComplete

protected 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(AsynchronousSocketChannel channel,
                  SocketWrapperBase<Nio2Channel> socket)
           throws 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:

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 Future<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 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:

IOException - if an error occurs during the handshake

handshakeInternal

protected int handshakeInternal(boolean async)
                         throws IOException

Throws:

IOException

rehandshake

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

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()
                                 throws IOException

Performs the WRAP function

Returns:

the result

Throws:

IOException - An IO error occurred

handshakeUnwrap

protected SSLEngineResult handshakeUnwrap()
                                   throws IOException

Perform handshake unwrap

Returns:

the result

Throws:

IOException - An IO error occurred

close

public void close()
           throws 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 Closeable

Specified by:

close in interface AutoCloseable

Specified by:

close in interface AsynchronousChannel

Specified by:

close in interface Channel

Overrides:

close in class Nio2Channel

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

Description copied from class: Nio2Channel

Close the connection.

Overrides:

close in class Nio2Channel

Parameters:

force - Should the underlying socket be forcibly closed?

Throws:

IOException - If closing the secure channel fails.

read

public Future<Integer> read(ByteBuffer dst)

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

Specified by:

read in interface 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:

IllegalStateException - if the handshake was not completed

write

public Future<Integer> write(ByteBuffer src)

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

Specified by:

write in interface 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(ByteBuffer dst,
                     long timeout,
                     TimeUnit unit,
                     A attachment,
                     CompletionHandler<Integer,? super A> handler)

Overrides:

read in class Nio2Channel

read

public <A> void read(ByteBuffer[] dsts,
                     int offset,
                     int length,
                     long timeout,
                     TimeUnit unit,
                     A attachment,
                     CompletionHandler<Long,? super A> handler)

Overrides:

read in class Nio2Channel

write

public <A> void write(ByteBuffer src,
                      long timeout,
                      TimeUnit unit,
                      A attachment,
                      CompletionHandler<Integer,? super A> handler)

Overrides:

write in class Nio2Channel

write

public <A> void write(ByteBuffer[] srcs,
                      int offset,
                      int length,
                      long timeout,
                      TimeUnit unit,
                      A attachment,
                      CompletionHandler<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 SSLEngine getSslEngine()

getEmptyBuf

public ByteBuffer getEmptyBuf()

getIOChannel

public AsynchronousSocketChannel getIOChannel()

Overrides:

getIOChannel in class Nio2Channel