PlainSocket

java.lang.Object
- ch.dermitza.securenio.socket.PlainSocket

All Implemented Interfaces:

SocketIF
```
public final class PlainSocket
extends java.lang.Object
implements SocketIF
```
A plain socket implementation of SocketIF. As a plain socket behaves no different than a SocketChannel, this class can also be seen as a wrapper with no additional functionality. Note that this class is declared as final as it should NOT be extended.
All required methods from SocketIF that deal with the secure implementation (SecureSocket) have no effect in this implementation.

Constructor Summary

Constructors
Constructor and Description

PlainSocket(java.nio.channels.SocketChannel channel)
Create a plain socket (i.e.

Constructors
Constructor and Description
`PlainSocket(java.nio.channels.SocketChannel channel)` Create a plain socket (i.e.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`close()` Pass-through implementation of `AbstractInterruptibleChannel.close()`
`java.nio.channels.SelectableChannel`	`configureBlocking(boolean block)` Pass-through implementation of `AbstractSelectableChannel.configureBlocking(boolean block)`
`boolean`	`connect(java.net.SocketAddress remote)` Pass-through implementation of `SocketChannel.connect(SocketAddress remote)`
`boolean`	`finishConnect()` Pass-through implementation of `SocketChannel.finishConnect()`
`java.nio.channels.SocketChannel`	`getSocket()` Returns the underlying `SocketChannel`.
`boolean`	`handshakePending()` Empty implementation satisfying `SocketIF.handshakePending()`.
`void`	`initHandshake()` Empty implementation satisfying `SocketIF.initHandshake()`.
`void`	`invalidateSession()` Empty implementation satisfying `SocketIF.invalidateSession()`.
`void`	`processHandshake()` Empty implementation satisfying `SocketIF.processHandshake()`.
`int`	`read(java.nio.ByteBuffer buffer)` Pass-through implementation of `SocketChannel.read(ByteBuffer buffer)`
`java.nio.channels.SelectionKey`	`register(java.nio.channels.Selector sel, int ops)` Pass-through implementation of `SelectableChannel.register(Selector sel, int ops)`
`void`	`setTaskPending(boolean taskPending)` Empty implementation satisfying `SocketIF.setTaskPending(boolean taskPending)`.
`void`	`updateResult()` Empty implementation satisfying `SocketIF.updateResult()`.
`int`	`write(java.nio.ByteBuffer buffer)` Pass-through implementation of `SocketChannel.write(ByteBuffer buffer)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - PlainSocket
```
public PlainSocket(java.nio.channels.SocketChannel channel)
```
    Create a plain socket (i.e. no encryption) instance of the SocketIF interface. This instance has empty placeholder methods for the SSL/TLS-related methods.
    
    Parameters:
    channel - The associated underlying SocketChannel.
- Method Detail
  - configureBlocking
```
public java.nio.channels.SelectableChannel configureBlocking(boolean block)
                                                      throws java.io.IOException
```
    Pass-through implementation of AbstractSelectableChannel.configureBlocking(boolean block)
    
    Specified by:
    
    configureBlocking in interface SocketIF
    
    Parameters:
    block - If true then this channel will be placed in blocking mode; if false then it will be placed in non-blocking mode
    
    Returns:
    This selectable channel
    
    Throws:
    
    java.io.IOException - Propagated exceptions from the underlying AbstractSelectableChannel.configureBlocking(boolean block) implementation.
  - read
```
public int read(java.nio.ByteBuffer buffer)
         throws java.io.IOException
```
    Pass-through implementation of SocketChannel.read(ByteBuffer buffer)
    
    Specified by:
    
    read in interface SocketIF
    
    Parameters:
    buffer - 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.io.IOException - Propagated exceptions from the underlying SocketChannel.read(ByteBuffer buffer) implementation.
  - write
```
public int write(java.nio.ByteBuffer buffer)
          throws java.io.IOException
```
    Pass-through implementation of SocketChannel.write(ByteBuffer buffer)
    
    Specified by:
    
    write in interface SocketIF
    
    Parameters:
    buffer -
    
    Returns:
    The number of bytes written, possibly zero
    
    Throws:
    
    java.io.IOException - Propagated exceptions from the underlying SocketChannel.write(ByteBuffer buffer) implementation.
  - connect
```
public boolean connect(java.net.SocketAddress remote)
                throws java.io.IOException
```
    Pass-through implementation of SocketChannel.connect(SocketAddress remote)
    
    Specified by:
    
    connect in interface SocketIF
    
    Parameters:
    remote - The remote address to which this channel is to be connected
    
    Returns:
    true if a connection was established, false if this channel is in non-blocking mode and the connection operation is in progress
    
    Throws:
    
    java.io.IOException - Propagated exceptions from the underlying SocketChannel.connect(SocketAddress remote) implementation.
  - register
```
public java.nio.channels.SelectionKey register(java.nio.channels.Selector sel,
                                      int ops)
                                        throws java.nio.channels.ClosedChannelException
```
    Pass-through implementation of SelectableChannel.register(Selector sel, int ops)
    
    Specified by:
    
    register in interface SocketIF
    
    Parameters:
    sel - The selector with which this channel is to be registered
    ops - The interest set for the resulting key
    
    Returns:
    A key representing the registration of this channel with the given selector
    
    Throws:
    
    java.nio.channels.ClosedChannelException - Propagated exceptions from the underlying SelectableChannel.register(Selector sel, int ops) implementation.
  - getSocket
```
public java.nio.channels.SocketChannel getSocket()
```
    Returns the underlying SocketChannel. This is done in order to register the current socket with a Selector, as only the SocketChannel implementation is allowed to be associated with a Selector.
    
    Specified by:
    
    getSocket in interface SocketIF
    
    Returns:
    the underlying SocketChannel
  - close
```
public void close()
           throws java.io.IOException
```
    Pass-through implementation of AbstractInterruptibleChannel.close()
    
    Specified by:
    
    close in interface SocketIF
    
    Throws:
    
    java.io.IOException - Propagated exceptions from the underlying SocketChannel.close() implementation.
  - finishConnect
```
public boolean finishConnect()
                      throws java.io.IOException
```
    Pass-through implementation of SocketChannel.finishConnect()
    
    Specified by:
    
    finishConnect in interface SocketIF
    
    Returns:
    true if, and only if, this channel's socket is now connected
    
    Throws:
    
    java.io.IOException - Propagated exceptions from the underlying SocketChannel.finishConnect() implementation.
  - processHandshake
```
public void processHandshake()
```
    Empty implementation satisfying SocketIF.processHandshake(). No handshaking is present on a PlainSocket. This method has NO effect.
    
    Specified by:
    
    processHandshake in interface SocketIF
    
    See Also:
    SecureSocket.processHandshake()
  - handshakePending
```
public boolean handshakePending()
```
    Empty implementation satisfying SocketIF.handshakePending(). No handshaking is present on a PlainSocket. This method has NO effect.
    
    Specified by:
    
    handshakePending in interface SocketIF
    
    Returns:
    Always false, no handshake is pending on a PlainSocket
    See Also:
    SecureSocket.handshakePending()
  - updateResult
```
public void updateResult()
```
    Empty implementation satisfying SocketIF.updateResult(). No SSLEngineResult is present on a PlainSocket. This method has NO effect.
    
    Specified by:
    
    updateResult in interface SocketIF
    
    See Also:
    SecureSocket.updateResult()
  - setTaskPending
```
public void setTaskPending(boolean taskPending)
```
    Empty implementation satisfying SocketIF.setTaskPending(boolean taskPending). No task is pending on a PlainSocket. This method has NO effect.
    
    Specified by:
    
    setTaskPending in interface SocketIF
    
    Parameters:
    taskPending - unused
    See Also:
    SecureSocket.setTaskPending(boolean)
  - invalidateSession
```
public void invalidateSession()
```
    Empty implementation satisfying SocketIF.invalidateSession(). No SSLSession is present on a PlainSocket. This method has NO effect.
    
    Specified by:
    
    invalidateSession in interface SocketIF
  - initHandshake
```
public void initHandshake()
                   throws java.io.IOException
```
    Empty implementation satisfying SocketIF.initHandshake(). No handshaking is present on a PlainSocket. This method has NO effect.
    
    Specified by:
    
    initHandshake in interface SocketIF
    
    Throws:
    
    java.io.IOException - Never thrown.
    See Also:
    SecureSocket.initHandshake()

Class PlainSocket

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

PlainSocket

Method Detail

configureBlocking

read

write

connect

register

getSocket

close

finishConnect

processHandshake

handshakePending

updateResult

setTaskPending

invalidateSession

initHandshake