SAMv3StreamSession (Javadocs [I2P+ 2.13.0+]

java.lang.Object
- net.i2p.sam.SAMStreamSession
- - net.i2p.sam.SAMv3StreamSession

All Implemented Interfaces:
Closeable, AutoCloseable, SAMMessageSess, Session
Direct Known Subclasses:
MasterSession
```
class SAMv3StreamSession
extends SAMStreamSession
implements Session
```
SAMv3 STREAM session class.

Nested Class Summary
- Nested classes/interfaces inherited from class net.i2p.sam.SAMStreamSession
  SAMStreamSession.DisconnectListener, SAMStreamSession.SAMStreamSessionServer, SAMStreamSession.SAMStreamSessionSocketReader, SAMStreamSession.SAMv1StreamSessionSocketReader, SAMStreamSession.StreamSender

Field Summary
- Fields inherited from class net.i2p.sam.SAMStreamSession
  _isOwnSession, _log, canCreate, DEFAULT_FORCE_FLUSH, forceFlush, PROP_FORCE_FLUSH, recv, server, SOCKET_HANDLER_BUF_SIZE, socketMgr

Constructor Summary

Constructors
Constructor and Description
`SAMv3StreamSession(String login)` Create a new SAM STREAM session, according to information registered with the given nickname Caller MUST call start().
`SAMv3StreamSession(String login, Properties props, SAMv3Handler handler, I2PSocketManager mgr, int listenPort)` Build a Stream Session on an existing I2P session registered with the given nickname Caller MUST call start().

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`accept(SAMv3Handler handler, boolean verbose)` Accept a single incoming I2P stream and pipe data through the handler's socket.
`void`	`close()` Close the stream session TODO Why do we override?
`void`	`connectAsync(SAMv3Handler handler, String dest, Properties props)` Initiate an async STREAM CONNECT.
`static SessionsDB`	`getDB()`
`String`	`getNick()`
`protected I2PServerSocket`	`getSocketServer()`
`boolean`	`queueSocket(I2PSocket sock)` Put a socket on the accept queue.
`void`	`startForwardingIncoming(Properties props, boolean sendPorts)` Forward sockets from I2P to the host/port provided.
`void`	`stopForwardingIncoming()` stop Forwarding Incoming connection coming from I2P

Methods inherited from class net.i2p.sam.SAMStreamSession
checkSocketHandlerId, closeConnection, connect, createSocketHandler, getDestination, getListenPort, getListenProtocol, getSocketReader, isDestroyed, lookupDest, newSAMStreamSessionSocketReader, newStreamSender, removeSocketHandler, sendBytes, sendBytes, sendBytes, setReceiveLimit, start

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

Methods inherited from interface net.i2p.sam.SAMMessageSess
getDestination, getListenPort, getListenProtocol, lookupDest, sendBytes, sendBytes, start

- Constructor Detail
  - SAMv3StreamSession
```
public SAMv3StreamSession(String login)
                   throws IOException,
                          DataFormatException,
                          SAMException
```
    Create a new SAM STREAM session, according to information registered with the given nickname Caller MUST call start().
    Parameters:
    login - The nickname
    Throws:
    IOException
    DataFormatException
    SAMException
    NullPointerException - if login nickname is not registered
  - SAMv3StreamSession
```
public SAMv3StreamSession(String login,
                          Properties props,
                          SAMv3Handler handler,
                          I2PSocketManager mgr,
                          int listenPort)
```
    Build a Stream Session on an existing I2P session registered with the given nickname Caller MUST call start().
    Parameters:
    login - nickname of the session
- Method Detail
  - accept
```
public void accept(SAMv3Handler handler,
                   boolean verbose)
            throws SAMException,
                   InterruptedIOException
```
    Accept a single incoming I2P stream and pipe data through the handler's socket. Validation is synchronous; the blocking accept runs in a dedicated thread so pool workers are never blocked waiting for an incoming I2P connection. Multiple simultaneous accepts are allowed (v3.2+). Accepts and forwarding may not be done at the same time.
    Parameters:
    handler - handler whose socket becomes the I2P data pipe
    verbose - if true, send peer Destination as first line
    Throws:
    SAMException - if a forwarding server is already active
    InterruptedIOException - if session is gone
  - close
```
public void close()
```
    Close the stream session TODO Why do we override?
    Specified by:
    close in interface Closeable
    Specified by:
    close in interface AutoCloseable
    Specified by:
    close in interface SAMMessageSess
    Overrides:
    close in class SAMStreamSession
  - connectAsync
```
public void connectAsync(SAMv3Handler handler,
                         String dest,
                         Properties props)
                  throws DataFormatException
```
    Initiate an async STREAM CONNECT. Validates parameters synchronously, unregisters from the pool, then hands the blocking connect to a shared connector thread pool. Returns immediately — the caller's worker is never blocked by an I2P connection attempt. The ConnectTask handles all error reporting and pipe setup so the calling worker is free to process other commands immediately.
    Parameters:
    handler - handler whose socket becomes the I2P data pipe
    dest - Base64-encoded Destination
    props - connection options
    Throws:
    DataFormatException - if dest is invalid
  - getDB
```
public static SessionsDB getDB()
```
    Returns:
    the d b
  - getNick
```
public String getNick()
```
    Specified by:
    getNick in interface Session
    Returns:
    the nick
  - getSocketServer
```
protected I2PServerSocket getSocketServer()
```
    Returns:
    the socket server
  - queueSocket
```
public boolean queueSocket(I2PSocket sock)
```
    Put a socket on the accept queue. Only for subsession, throws IllegalStateException otherwise.
    Returns:
    success, false if full
  - startForwardingIncoming
```
public void startForwardingIncoming(Properties props,
                                    boolean sendPorts)
                             throws SAMException,
                                    InterruptedIOException
```
    Forward sockets from I2P to the host/port provided. Accepts and forwarding may not be done at the same time.
    Throws:
    SAMException
    InterruptedIOException
  - stopForwardingIncoming
```
public void stopForwardingIncoming()
                            throws SAMException,
                                   InterruptedIOException
```
    stop Forwarding Incoming connection coming from I2P
    Throws:
    SAMException
    InterruptedIOException

Class SAMv3StreamSession

Nested Class Summary

Nested classes/interfaces inherited from class net.i2p.sam.SAMStreamSession

Field Summary

Fields inherited from class net.i2p.sam.SAMStreamSession

Constructor Summary

Method Summary

Methods inherited from class net.i2p.sam.SAMStreamSession

Methods inherited from class java.lang.Object

Methods inherited from interface net.i2p.sam.SAMMessageSess

Constructor Detail

SAMv3StreamSession

SAMv3StreamSession

Method Detail

accept

close

connectAsync

getDB

getNick

getSocketServer

queueSocket

startForwardingIncoming

stopForwardingIncoming