# Class NioChannel

java.lang.Object
org.apache.tomcat.util.net.NioChannel

All Implemented Interfaces:
  `Closeable, AutoCloseable, ByteChannel, Channel, GatheringByteChannel, ReadableByteChannel, ScatteringByteChannel, WritableByteChannel`

Direct Known Subclasses:
  `SecureNioChannel`

public class NioChannel extends Object implements ByteChannel, ScatteringByteChannel, GatheringByteChannel
Base class for a SocketChannel wrapper used by the endpoint. This way, logic for an SSL socket channel remains the same as for a non SSL, making sure we don't need to code for any exception cases.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected final SocketBufferHandler`
  `bufHandler`
  `protected static final ByteBuffer`
  `emptyBuf`
  `protected SocketChannel`
  `sc`
  `protected static final StringManager`
  `sm`
  `protected NioEndpoint.NioSocketWrapper`
  `socketWrapper`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `NioChannel(SocketBufferHandler bufHandler)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `protected void`
  `checkInterruptStatus()`
  This method should be used to check the interrupt status before attempting a write.
  `void`
  `close()`
  Closes this channel.
  `void`
  `close(boolean force)`
  Close the connection.
  `boolean`
  `flushOutbound()`
  Return true if the buffer wrote data.
  `void`
  `free()`
  Free the channel memory
  `protected ApplicationBufferHandler`
  `getAppReadBufHandler()`
  `SocketBufferHandler`
  `getBufHandler()`
  `SocketChannel`
  `getIOChannel()`
  `int`
  `getOutboundRemaining()`
  `int`
  `handshake(boolean read, boolean write)`
  Performs SSL handshake hence is a no-op for the non-secure implementation.
  `boolean`
  `isClosing()`
  `boolean`
  `isHandshakeComplete()`
  `boolean`
  `isOpen()`
  Tells whether or not this channel is open.
  `int`
  `read(ByteBuffer dst)`
  Reads a sequence of bytes from this channel into the given buffer.
  `long`
  `read(ByteBuffer[] dsts)`
  `long`
  `read(ByteBuffer[] dsts, int offset, int length)`
  `void`
  `reset(SocketChannel channel, NioEndpoint.NioSocketWrapper socketWrapper)`
  Reset the channel
  `void`
  `setAppReadBufHandler(ApplicationBufferHandler handler)`
  `String`
  `toString()`
  `int`
  `write(ByteBuffer src)`
  Writes a sequence of bytes to this channel from the given buffer.
  `long`
  `write(ByteBuffer[] srcs)`
  `long`
  `write(ByteBuffer[] srcs, int offset, int length)`

  ### Methods inherited from class Object

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

- ## Field Details

  - ### sm

    protected static final StringManager sm

  - ### emptyBuf

    protected static final ByteBuffer emptyBuf

  - ### bufHandler

    protected final SocketBufferHandler bufHandler

  - ### sc

    protected SocketChannel sc

  - ### socketWrapper

    protected NioEndpoint.NioSocketWrapper socketWrapper

- ## Constructor Details

  - ### NioChannel

    public NioChannel(SocketBufferHandler bufHandler)

- ## Method Details

  - ### reset

    public void reset(SocketChannel channel, NioEndpoint.NioSocketWrapper socketWrapper) throws IOException
    Reset the channel
    Parameters:
      `channel` - the socket channel
      `socketWrapper` - the socket wrapper
    Throws:
      `IOException` - If a problem was encountered resetting the channel

  - ### free

    public void free()
    Free the channel memory

  - ### close

    public void close() throws IOException
    Closes this channel.
    Specified by:
      `close` in interface `AutoCloseable`
    Specified by:
      `close` in interface `Channel`
    Specified by:
      `close` in interface `Closeable`
    Throws:
      `IOException` - If an I/O error occurs

  - ### close

    public void close(boolean force) throws IOException
    Close the connection.
    Parameters:
      `force` - Should the underlying socket be forcibly closed?
    Throws:
      `IOException` - If closing the secure channel fails.

  - ### isOpen

    public boolean isOpen()
    Tells whether or not this channel is open.
    Specified by:
      `isOpen` in interface `Channel`
    Returns:
      `true` if, and only if, this channel is open

  - ### write

    public int write(ByteBuffer src) throws IOException
    Writes a sequence of bytes to this channel from the given buffer.
    Specified by:
      `write` in interface `WritableByteChannel`
    Parameters:
      `src` - The buffer from which bytes are to be retrieved
    Returns:
      The number of bytes written, possibly zero
    Throws:
      `IOException` - If some other I/O error occurs

  - ### write

    public long write(ByteBuffer[] srcs) throws IOException
    Specified by:
      `write` in interface `GatheringByteChannel`
    Throws:
      `IOException`

  - ### write

    public long write(ByteBuffer[] srcs, int offset, int length) throws IOException
    Specified by:
      `write` in interface `GatheringByteChannel`
    Throws:
      `IOException`

  - ### read

    public int read(ByteBuffer dst) throws IOException
    Reads a sequence of bytes from this channel into the given buffer.
    Specified by:
      `read` in interface `ReadableByteChannel`
    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:
      `IOException` - If some other I/O error occurs

  - ### read

    public long read(ByteBuffer[] dsts) throws IOException
    Specified by:
      `read` in interface `ScatteringByteChannel`
    Throws:
      `IOException`

  - ### read

    public long read(ByteBuffer[] dsts, int offset, int length) throws IOException
    Specified by:
      `read` in interface `ScatteringByteChannel`
    Throws:
      `IOException`

  - ### getBufHandler

    public SocketBufferHandler getBufHandler()

  - ### getIOChannel

    public SocketChannel getIOChannel()

  - ### isClosing

    public boolean isClosing()

  - ### isHandshakeComplete

    public boolean isHandshakeComplete()

  - ### handshake

    public int handshake(boolean read, boolean write) throws IOException
    Performs SSL handshake hence is a no-op for the non-secure implementation.
    Parameters:
      `read` - Unused in non-secure implementation
      `write` - Unused in non-secure implementation
    Returns:
      Always returns zero
    Throws:
      `IOException` - Never for non-secure channel

  - ### toString

    public String toString()
    Overrides:
      `toString` in class `Object`

  - ### getOutboundRemaining

    public int getOutboundRemaining()

  - ### flushOutbound

    public boolean flushOutbound() throws IOException
    Return true if the buffer wrote data. NO-OP for non-secure channel.
    Returns:
      Always returns `false` for non-secure channel
    Throws:
      `IOException` - Never for non-secure channel

  - ### checkInterruptStatus

    protected void checkInterruptStatus() throws IOException
    This method should be used to check the interrupt status before attempting a write. If a thread has been interrupted and the interrupt has not been cleared then an attempt to write to the socket will fail. When this happens the socket is removed from the poller without the socket being selected. This results in a connection limit leak for NIO as the endpoint expects the socket to be selected even in error conditions.
    Throws:
      `IOException` - If the current thread was interrupted

  - ### setAppReadBufHandler

    public void setAppReadBufHandler(ApplicationBufferHandler handler)

  - ### getAppReadBufHandler

    protected ApplicationBufferHandler getAppReadBufHandler()