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 Details

    • endpoint

      protected final Nio2Endpoint endpoint

    • netInBuffer

      protected ByteBuffer netInBuffer

    • netOutBuffer

      protected ByteBuffer netOutBuffer

    • sslEngine

      protected SSLEngine sslEngine

    • sniComplete

      protected volatile boolean sniComplete

    • closed

      protected boolean closed

    • closing

      protected boolean closing

  • Constructor Details

  • Method Details

    • createSSLEngine

      protected void createSSLEngine(String hostName, List<Cipher> clientRequestedCiphers, List<String> clientRequestedApplicationProtocols)

    • 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

    • processSNI

      protected int processSNI() 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

    • getSSLSupport

      public SSLSupport getSSLSupport()

    • 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 AsynchronousChannel
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Channel
      Specified by:
      close in interface Closeable
      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()