SAMv3StreamSession

java.lang.Object

net.i2p.sam.SAMStreamSession

net.i2p.sam.SAMv3StreamSession

All Implemented Interfaces:: Closeable, AutoCloseable, SAMMessageSess, Session

Direct Known Subclasses:: MasterSession

class SAMv3StreamSessionextends SAMStreamSession implements Session

SAMv3 STREAM session class.

Manages I2P streaming connections via the SAM v3 bridge. Supports three modes: outgoing CONNECT, incoming ACCEPT (via a queue fed by MasterSession), and FORWARD (proxy to a local host:port).

For subsessions created under a MasterSession, incoming I2P sockets are placed on _acceptQueue by the master's acceptor thread and consumed by dedicated per-subsession accept threads. This decouples the I2P accept loop from the per-client SAM handler and allows multiple concurrent ACCEPT commands.

Nested Class Summary
Nested Classes
Modifier and Type
Class
Description
private class
SAMv3StreamSession.ConnectTask
Runnable that performs the blocking I2P socket connect in a connector pool thread, then sets up pipes on success or reports the error to the SAM client.
private static class
SAMv3StreamSession.Pipe
Bidirectional byte copier between a local socket and an I2P socket.
private class
SAMv3StreamSession.SocketForwarder
Forwards incoming I2P connections to a local TCP host:port.
Nested classes/interfaces inherited from class SAMStreamSession
SAMStreamSession.DisconnectListener, SAMStreamSession.SAMStreamSessionServer, SAMStreamSession.SAMStreamSessionSocketReader, SAMStreamSession.SAMv1StreamSessionSocketReader, SAMStreamSession.StreamSender
Modifier and Type
Class
Description
protected class
SAMStreamSession.DisconnectListener
Closes SAM session when the underlying I2P manager disconnects.
class
SAMStreamSession.SAMStreamSessionServer
SAM STREAM session server, running in its own thread.
static class
SAMStreamSession.SAMStreamSessionSocketReader
Reads bytes off one tunnel socket and pushes them to the SAM client.
class
SAMStreamSession.SAMv1StreamSessionSocketReader
SAMv1StreamSessionSocketReader.
protected static class
SAMStreamSession.StreamSender
Lets us push data through the stream without blocking, (even after exceeding the I2PSocket's buffer).
Field Summary
Fields
Modifier and Type
Field
Description
private final AtomicInteger
_acceptors
This is the count of active ACCEPT sockets.
private final LinkedBlockingQueue<I2PSocket>
_acceptQueue
For subsession only, null otherwise.
private static final int
ACCEPT_POLL_TIMEOUT_SECS
Seconds to wait for a queued socket before returning null.
private static final int
BUFFER_SIZE
Buffer size for the stream forwarding, in bytes.
private static final int
MAX_ACCEPT_QUEUE
Largest accept queue allowed.
private final String
nick
Nickname of the session, for the logs.
private I2PServerSocket
socketServer
This is ONLY set for FORWARD, not for ACCEPT.
private final Object
socketServerLock
Lock for the socket server state.
private static I2PSSLSocketFactory
sslSocketFactory
Shared factory for the SSL forwarder sockets.
Fields inherited from class SAMStreamSession
_isOwnSession, _log, canCreate, DEFAULT_FORCE_FLUSH, forceFlush, PROP_FORCE_FLUSH, recv, server, SOCKET_HANDLER_BUF_SIZE, socketMgr
Modifier and Type
Field
Description
protected final boolean
_isOwnSession
Whether this is our own session, as opposed to a remote peer's.
protected final Log
_log
Logger for this session's messages.
protected final boolean
canCreate
Whether this session may create outgoing connections.
static final String
DEFAULT_FORCE_FLUSH
Default for SAMStreamSession.PROP_FORCE_FLUSH.
protected final boolean
forceFlush
Should we flush every time we get a STREAM SEND, or leave that up to the streaming lib to decide?
static final String
PROP_FORCE_FLUSH
Config key for flushing on every STREAM SEND.
protected final SAMStreamReceiver
recv
The receiver that decodes incoming SAM messages.
protected final SAMStreamSession.SAMStreamSessionServer
server
The server this session belongs to.
protected static final int
SOCKET_HANDLER_BUF_SIZE
Read buffer size for each socket reader.
protected final I2PSocketManager
socketMgr
The socket manager used for outgoing connections.
Constructor Summary
Constructors
Constructor
Description
SAMv3StreamSession(String login)
Create a new SAM STREAM session, according to information registered with the given nickname
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
Method Summary
Modifier and Type
Method
Description
void
accept(SAMv3Handler handler, boolean verbose)
Accept a single incoming I2P stream and pipe data through the handler's socket.
private I2PSocket
acceptSocket()
Take a socket from the accept queue, with a timeout to avoid indefinite blocking on stale connections.
void
close()
Close the stream session.
void
connectAsync(SAMv3Handler handler, String dest, Properties props)
Initiate an async STREAM CONNECT.
private void
doAccept(SAMv3Handler handler, boolean verbose)
Blocking accept executed in a dedicated thread so pool workers are never blocked waiting for incoming I2P connections.
int
getAcceptQueueSize()
Return how many accepted sockets are waiting to be handed to the client.
static SessionsDB
getDB()
Get the global sessions database shared by all SAM handlers.
String
getNick()
Return the nickname this session is registered under.
protected I2PServerSocket
getSocketServer()
Return the server socket this session accepts incoming I2P connections on.
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 an incoming connection coming from I2P.
private static String
truncNick(String n)
Nickname truncated to four characters.
Methods inherited from class SAMStreamSession
checkSocketHandlerId, closeConnection, connect, createSocketHandler, getDestination, getListenPort, getListenProtocol, getSocketReader, isDestroyed, lookupDest, newSAMStreamSessionSocketReader, newStreamSender, removeSocketHandler, sendBytes, sendBytes, sendBytes, setReceiveLimit, start
Modifier and Type
Method
Description
protected boolean
checkSocketHandlerId(int id)
Check whether a SAM STREAM session socket handler id is still in use.
boolean
closeConnection(int id)
Close a connection managed by the SAM STREAM session.
boolean
connect(int id, String dest, Properties props)
Connect the SAM STREAM session to the specified Destination.
protected int
createSocketHandler(I2PSocket s, int id)
Create a new SAM STREAM session socket handler, detaching its thread.
Destination
getDestination()
Get the SAM STREAM session Destination.
int
getListenPort()
Get the port for this session's listener.
int
getListenProtocol()
Get the I2CP protocol for this session's listener.
protected SAMStreamSession.SAMStreamSessionSocketReader
getSocketReader(int id)
Get a SAM STREAM session socket handler.
boolean
isDestroyed()
Is the underlying streaming socket manager destroyed?
Destination
lookupDest(String name)
Lookup a destination through the I2CP session.
protected SAMStreamSession.SAMStreamSessionSocketReader
newSAMStreamSessionSocketReader(I2PSocket s, int id)
Create a new SAM STREAM session socket reader.
protected SAMStreamSession.StreamSender
newStreamSender(I2PSocket s, int id)
Creates the sender that writes this socket's outgoing data.
protected void
removeSocketHandler(int id)
Remove and gracefully close a SAM STREAM session socket handler.
boolean
sendBytes(int id, InputStream in, int size)
Send bytes through a SAM STREAM session.
boolean
sendBytes(String s, byte[] b, int pr, int fp, int tp)
Sending bytes is not supported in a STREAM or MASTER session; always throws.
boolean
sendBytes(String s, byte[] b, int pr, int fp, int tp, boolean sendLeaseSet, int sendTags, int tagThreshold, int expiration)
Sending bytes is not supported in a STREAM or MASTER session; always throws.
(package private) boolean
setReceiveLimit(int id, long limit, boolean nolimit)
Set a receive limit for a stream.
void
start()
Start the SAM STREAM session server, if applicable.
Methods inherited from class Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details
- BUFFER_SIZE
  private static final int BUFFER_SIZE
  Buffer size for the stream forwarding, in bytes.
  See Also:
  Constant Field Values
- MAX_ACCEPT_QUEUE
  private static final int MAX_ACCEPT_QUEUE
  Largest accept queue allowed.
  See Also:
  Constant Field Values
- ACCEPT_POLL_TIMEOUT_SECS
  private static final int ACCEPT_POLL_TIMEOUT_SECS
  Seconds to wait for a queued socket before returning null.
  See Also:
  Constant Field Values
- socketServerLock
  private final Object socketServerLock
  Lock for the socket server state.
- socketServer
  private I2PServerSocket socketServer
  This is ONLY set for FORWARD, not for ACCEPT.
- _acceptors
  private final AtomicInteger _acceptors
  This is the count of active ACCEPT sockets.
- _acceptQueue
  private final LinkedBlockingQueue<I2PSocket> _acceptQueue
  For subsession only, null otherwise.
- sslSocketFactory
  private static I2PSSLSocketFactory sslSocketFactory
  Shared factory for the SSL forwarder sockets.
- nick
  private final String nick
  Nickname of the session, for the logs.
Constructor Details
- 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 this session is registered under
  Throws:
  IOException - declared on this constructor, but not raised by the body
  DataFormatException - likewise declared, but not raised by the body
  SAMException - if the destination or properties read from the record name no known direction or cannot build a session
  NullPointerException - if the 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
  props - STREAM command arguments, read by the superclass
  handler - handler used to send STREAM replies back to the client
  mgr - socket manager used to create the stream sockets
  listenPort - local port to accept on, 0 for any port
Method Details
- getNick
  public String getNick()
  Return the nickname this session is registered under.
  Specified by:
  getNick in interface Session
  Returns:
  the nick, the name the client registered this STREAM session under
- queueSocket
  public boolean queueSocket(I2PSocket sock)
  Put a socket on the accept queue. Called by MasterSession.StreamAcceptor when an I2P connection arrives and matches this subsession's listen protocol and port.
  Only for subsessions created with the 5-arg constructor; the 1-arg constructor sets _acceptQueue to null and this method throws IllegalStateException.
  Parameters:
  sock - the accepted I2P socket
  Returns:
  true if queued; false if the queue is full (caller must reset the socket)
  Throws:
  IllegalStateException - if called on a non-subsession
- getAcceptQueueSize
  public int getAcceptQueueSize()
  Return how many accepted sockets are waiting to be handed to the client.
  Returns:
  the number of sockets waiting in the accept queue, 0 if not a subsession
- acceptSocket
  private I2PSocket acceptSocket() throws ConnectException
  Take a socket from the accept queue, with a timeout to avoid indefinite blocking on stale connections. Under heavy tracker traffic, sockets may accumulate faster than the client can consume them. A timeout ensures the acceptor thread can check for shutdown and avoid leaking threads on idle sessions.
  Returns:
  the next queued socket, or null if the queue is empty after the timeout (caller must handle null)
  Throws:
  ConnectException - if the thread is interrupted
- getDB
  public static SessionsDB getDB()
  Get the global sessions database shared by all SAM handlers.
  Returns:
  the sessions database
- 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 - the Base64-encoded destination to connect to
  props - the connection options read from the STREAM CONNECT command
  Throws:
  DataFormatException - if dest is invalid
- truncNick
  private static String truncNick(String n)
  Nickname truncated to four characters.
  Parameters:
  n - the session nickname, any length
  Returns:
  first 4 chars of the session nickname for thread names
- 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
- doAccept
  private void doAccept(SAMv3Handler handler, boolean verbose)
  Blocking accept executed in a dedicated thread so pool workers are never blocked waiting for incoming I2P connections.
  Parameters:
  handler - the handler whose bridge accepts the connection
  verbose - true to report the incoming connection back to the SAM client
- 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.
  Parameters:
  props - session properties supplying HOST, PORT, SSL, and SILENT
  sendPorts - true to report the local port back to the client
  Throws:
  SAMException - if PORT is missing or invalid, or a server is already defined
  InterruptedIOException - if this session is no longer registered
- getSocketServer
  protected I2PServerSocket getSocketServer()
  Return the server socket this session accepts incoming I2P connections on.
  Returns:
  the socket server
- stopForwardingIncoming
  public void stopForwardingIncoming() throws SAMException, InterruptedIOException
  Stop forwarding an incoming connection coming from I2P.
  Throws:
  SAMException - if no socket server has been defined for this destination
  InterruptedIOException - if the session record for this nickname has already been removed
- close
  public void close()
  Close the stream session.
  Specified by:
  close in interface AutoCloseable
  Specified by:
  close in interface Closeable
  Specified by:
  close in interface SAMMessageSess
  Overrides:
  close in class SAMStreamSession

Nested Class Summary

Nested classes/interfaces inherited from class SAMStreamSession

Field Summary

Fields inherited from class SAMStreamSession

Constructor Summary

Method Summary

Methods inherited from class SAMStreamSession

Methods inherited from class Object

Field Details

BUFFER_SIZE

MAX_ACCEPT_QUEUE

ACCEPT_POLL_TIMEOUT_SECS

socketServerLock

socketServer

_acceptors

_acceptQueue

sslSocketFactory

nick

Constructor Details

SAMv3StreamSession

Method Details

getNick

queueSocket

getAcceptQueueSize

acceptSocket

getDB

connectAsync

truncNick

accept

doAccept

startForwardingIncoming

getSocketServer

stopForwardingIncoming

close