Class 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.
    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void close()
      Sends a 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()  
      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 java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
    • Field Detail

      • netInBuffer

        protected java.nio.ByteBuffer netInBuffer
      • netOutBuffer

        protected java.nio.ByteBuffer netOutBuffer
      • sslEngine

        protected javax.net.ssl.SSLEngine sslEngine
      • sniComplete

        protected boolean sniComplete
      • closed

        protected boolean closed
      • closing

        protected boolean closing
    • 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
      • 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.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
      • getSslEngine

        public javax.net.ssl.SSLEngine getSslEngine()
      • getEmptyBuf

        public java.nio.ByteBuffer getEmptyBuf()