I2PTunnelClientBase (Javadocs [I2P+ 2.13.0+]

java.lang.Object
- net.i2p.util.EventDispatcherImpl
- - net.i2p.i2ptunnel.I2PTunnelTask
  - - net.i2p.i2ptunnel.I2PTunnelClientBase

All Implemented Interfaces:
Runnable, EventDispatcher
Direct Known Subclasses:
I2Ping, I2PSOCKSTunnel, I2PTunnelClient, I2PTunnelDCCClient, I2PTunnelHTTPClientBase, I2PTunnelIRCClient
```
public abstract class I2PTunnelClientBase
extends I2PTunnelTask
implements Runnable
```
Abstract base class for I2P client tunnels with common functionality.
Manages I2PSocketManager creation, local server socket setup, connection threading, and framework for shared and non-shared client tunnels. Handles SSL configuration, connection timeouts, and provides abstract methods for connection-specific implementations.
Extended by specific tunnel types like HTTP clients, SOCKS proxies, and standard TCP tunnels.

Field Summary

Fields
Modifier and Type	Field and Description
`protected long`	`_clientId` This client's ID
`protected I2PAppContext`	`_context` The application context
`protected ThreadPoolExecutor`	`_executor` Thread pool executor
`protected Log`	`_log` The logger
`protected boolean`	`_ownDest` Whether we own our destination
`(package private) static long`	`DEFAULT_CONNECT_TIMEOUT` Default connect timeout
`protected Destination`	`dest` The destination
`protected Logging`	`l` The logging instance
`protected boolean`	`listenerReady` Protected for I2Ping since 0.9.11.
`protected List<I2PSocket>`	`mySockets` List of active sockets
`static String`	`PROP_USE_SSL` Property for SSL enable
`protected Object`	`sockLock` Guards sockMgr and mySockets
`protected I2PSocketManager`	`sockMgr` The socket manager
`protected ServerSocket`	`ss` Server socket

Fields inherited from class net.i2p.i2ptunnel.I2PTunnelTask
open, tunnel

Constructor Summary

Constructors
Constructor and Description
`I2PTunnelClientBase(int localPort, boolean ownDest, Logging l, EventDispatcher notifyThis, String handlerName, I2PTunnel tunnel)` The main constructor.
`I2PTunnelClientBase(int localPort, boolean ownDest, Logging l, EventDispatcher notifyThis, String handlerName, I2PTunnel tunnel, String pkf)` Use this to build a client with a persistent private key.
`I2PTunnelClientBase(int localPort, Logging l, I2PSocketManager sktMgr, I2PTunnel tunnel, EventDispatcher notifyThis, long clientId)` This constructor is used to add a client to an existing socket manager.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected I2PSocketManager`	`buildSocketManager()` For NON-SHARED clients (ownDest = true).
`protected static I2PSocketManager`	`buildSocketManager(I2PTunnel tunnel)` As of 0.9.20 this is fast, and does NOT connect the manager to the router.
`protected static I2PSocketManager`	`buildSocketManager(I2PTunnel tunnel, String pkf)` As of 0.9.20 this is fast, and does NOT connect the manager to the router.
`protected static I2PSocketManager`	`buildSocketManager(I2PTunnel tunnel, String pkf, Logging log)` As of 0.9.20 this is fast, and does NOT connect the manager to the router.
`protected abstract void`	`clientConnectionRun(Socket s)` Manage a connection in a separate thread.
`boolean`	`close(boolean forced)` Note that the tunnel can be reopened after this by calling startRunning().
`static void`	`closeSocket(Socket s)` Close a socket silently.
`I2PSocket`	`createI2PSocket(Destination dest)` Create a new I2PSocket towards to the specified destination, adding it to the list of connections actually managed by this tunnel.
`I2PSocket`	`createI2PSocket(Destination dest, I2PSocketOptions opt)` Create a new I2PSocket towards to the specified destination, adding it to the list of connections actually managed by this tunnel.
`I2PSocket`	`createI2PSocket(Destination dest, int port)` Create a new I2PSocket towards to the specified destination, adding it to the list of connections actually managed by this tunnel.
`boolean`	`destroy()` Note that the tunnel cannot be reopened after this by calling startRunning(), as it will destroy the underlying socket manager.
`protected I2PSocketOptions`	`getDefaultOptions()` Create the default options (using the default timeout, etc).
`protected I2PSocketOptions`	`getDefaultOptions(Properties overrides)` Create the default options (using the default timeout, etc).
`protected InetAddress`	`getListenHost(Logging l)` Get the listen host address.
`int`	`getLocalPort()` Get the local port.
`I2PSocketManager`	`getSocketManager()` Returns the I2PSocketManager for this task.
`protected static I2PSocketManager`	`getSocketManager(I2PTunnel tunnel)` This is ONLY for shared clients.
`protected static I2PSocketManager`	`getSocketManager(I2PTunnel tunnel, String pkf)` This is ONLY for shared clients.
`protected static void`	`killSharedClient()` Kill the shared client, so that on restart in android we won't latch onto the old one
`protected void`	`manageConnection(Socket s)` Manage the connection just opened on the specified socket
`void`	`optionsUpdated(I2PTunnel tunnel)` Update the I2PSocketManager.
`void`	`run()` Non-final since 0.9.11.
`void`	`startRunning()` Actually open the local socket and start working on incoming connections.
`protected void`	`verifySocketManager()` Create the manager if it doesn't exist, AND connect it to the router and build tunnels.

Methods inherited from class net.i2p.i2ptunnel.I2PTunnelTask
connected, disconnected, errorOccurred, getBooleanOption, getId, getTunnel, isOpen, reportAbuse, routerDisconnected, setId, setName, setTunnel, toString

Methods inherited from class net.i2p.util.EventDispatcherImpl
attachEventDispatcher, detachEventDispatcher, getEventDispatcher, getEvents, getEventValue, ignoreEvents, notifyEvent, unIgnoreEvents, waitEventValue

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

- Field Detail
  - _clientId
```
protected long _clientId
```
    This client's ID
  - _context
```
protected final I2PAppContext _context
```
    The application context
  - _executor
```
protected volatile ThreadPoolExecutor _executor
```
    Thread pool executor
  - _log
```
protected final Log _log
```
    The logger
  - _ownDest
```
protected boolean _ownDest
```
    Whether we own our destination
  - DEFAULT_CONNECT_TIMEOUT
```
static final long DEFAULT_CONNECT_TIMEOUT
```
    Default connect timeout
    See Also:
    Constant Field Values
  - dest
```
protected Destination dest
```
    The destination
  - l
```
protected final Logging l
```
    The logging instance
  - listenerReady
```
protected boolean listenerReady
```
    Protected for I2Ping since 0.9.11. Not for use outside package.
  - mySockets
```
protected final List<I2PSocket> mySockets
```
    List of active sockets
  - PROP_USE_SSL
```
public static final String PROP_USE_SSL
```
    Property for SSL enable
    See Also:
    Constant Field Values
  - sockLock
```
protected final Object sockLock
```
    Guards sockMgr and mySockets
  - sockMgr
```
protected I2PSocketManager sockMgr
```
    The socket manager
  - ss
```
protected ServerSocket ss
```
    Server socket
- Constructor Detail
  - I2PTunnelClientBase
```
public I2PTunnelClientBase(int localPort,
                           boolean ownDest,
                           Logging l,
                           EventDispatcher notifyThis,
                           String handlerName,
                           I2PTunnel tunnel)
                    throws IllegalArgumentException
```
    The main constructor.
    As of 0.9.21 this is fast, and does NOT connect the manager to the router, or open the local socket. You MUST call startRunning() for that.
    (0.9.20 claimed to be fast, but due to a bug it DID connect the manager to the router. It did NOT open the local socket however, so it was still necessary to call startRunning() for that.)
    Parameters:
    localPort - if 0, use any port, get actual port selected with getLocalPort()
    ownDest - whether to use an owned destination
    l - the logging instance
    notifyThis - the event dispatcher for notifications
    handlerName - the handler name
    tunnel - the I2PTunnel instance
    Throws:
    IllegalArgumentException - if the I2CP configuration is b0rked so badly that we can't create a socketManager
  - I2PTunnelClientBase
```
public I2PTunnelClientBase(int localPort,
                           boolean ownDest,
                           Logging l,
                           EventDispatcher notifyThis,
                           String handlerName,
                           I2PTunnel tunnel,
                           String pkf)
                    throws IllegalArgumentException
```
    Use this to build a client with a persistent private key.
    As of 0.9.21 this is fast, and does NOT connect the manager to the router, or open the local socket. You MUST call startRunning() for that.
    (0.9.20 claimed to be fast, but due to a bug it DID connect the manager to the router. It did NOT open the local socket however, so it was still necessary to call startRunning() for that.)
    Parameters:
    localPort - if 0, use any port, get actual port selected with getLocalPort()
    ownDest - whether to use an owned destination
    l - the logging instance
    notifyThis - the event dispatcher for notifications
    handlerName - the handler name
    tunnel - the I2PTunnel instance
    pkf - Path to the private key file, or null to generate a transient key
    Throws:
    IllegalArgumentException - if the I2CP configuration is b0rked so badly that we can't create a socketManager
  - I2PTunnelClientBase
```
public I2PTunnelClientBase(int localPort,
                           Logging l,
                           I2PSocketManager sktMgr,
                           I2PTunnel tunnel,
                           EventDispatcher notifyThis,
                           long clientId)
                    throws IllegalArgumentException
```
    This constructor is used to add a client to an existing socket manager.
    As of 0.9.21 this does NOT open the local socket. You MUST call startRunning() for that. The local socket will be opened immediately (ignoring the i2cp.delayOpen option).
    Parameters:
    localPort - if 0, use any port, get actual port selected with getLocalPort()
    l - the logging instance
    sktMgr - the existing socket manager
    tunnel - the I2PTunnel instance
    notifyThis - the event dispatcher for notifications
    clientId - the client identifier
    Throws:
    IllegalArgumentException
- Method Detail
  - buildSocketManager
```
protected I2PSocketManager buildSocketManager()
```
    For NON-SHARED clients (ownDest = true). As of 0.9.20 this is fast, and does NOT connect the manager to the router. Call verifySocketManager() for that.
    Returns:
    non-null
    Throws:
    IllegalArgumentException - if the I2CP configuration is b0rked so badly that we cant create a socketManager
  - buildSocketManager
```
protected static I2PSocketManager buildSocketManager(I2PTunnel tunnel)
```
    As of 0.9.20 this is fast, and does NOT connect the manager to the router. Call verifySocketManager() for that.
    Parameters:
    tunnel - the I2PTunnel instance
    Returns:
    non-null
    Throws:
    IllegalArgumentException - if the I2CP configuration is b0rked so badly that we cant create a socketManager
  - buildSocketManager
```
protected static I2PSocketManager buildSocketManager(I2PTunnel tunnel,
                                                     String pkf)
```
    As of 0.9.20 this is fast, and does NOT connect the manager to the router. Call verifySocketManager() for that.
    Parameters:
    tunnel - the I2PTunnel instance
    pkf - absolute path or null
    Returns:
    non-null
    Throws:
    IllegalArgumentException - if the I2CP configuration is b0rked so badly that we cant create a socketManager
  - buildSocketManager
```
protected static I2PSocketManager buildSocketManager(I2PTunnel tunnel,
                                                     String pkf,
                                                     Logging log)
```
    As of 0.9.20 this is fast, and does NOT connect the manager to the router. Call verifySocketManager() for that.
    Parameters:
    tunnel - the I2PTunnel instance
    pkf - absolute path or null
    log - the logging instance
    Returns:
    non-null
    Throws:
    IllegalArgumentException - if the I2CP configuration is b0rked so badly that we cant create a socketManager
  - clientConnectionRun
```
protected abstract void clientConnectionRun(Socket s)
```
    Manage a connection in a separate thread. This only works if you do not override manageConnection(). This is run in a thread from an unlimited-size thread pool, so it may block or run indefinitely.
    Parameters:
    s - the socket to manage
  - close
```
public boolean close(boolean forced)
```
    Note that the tunnel can be reopened after this by calling startRunning(). This may not release all resources. In particular, the I2PSocketManager remains and it may have timer threads that continue running. To release all resources permanently, call destroy(). Does nothing if open is already false. Sets open = false but does not notifyAll().
    Specified by:
    close in class I2PTunnelTask
    Returns:
    success
  - closeSocket
```
public static void closeSocket(Socket s)
```
    Close a socket silently.
    Parameters:
    s - the socket to close
  - createI2PSocket
```
public I2PSocket createI2PSocket(Destination dest)
                          throws I2PException,
                                 ConnectException,
                                 NoRouteToHostException,
                                 InterruptedIOException
```
    Create a new I2PSocket towards to the specified destination, adding it to the list of connections actually managed by this tunnel.
    Parameters:
    dest - The destination to connect to, non-null
    Returns:
    a new I2PSocket
    Throws:
    I2PException - if there is an I2P-related problem
    ConnectException - if the peer refuses the connection
    NoRouteToHostException - if the peer is not found or not reachable
    InterruptedIOException - if the connection times out
  - createI2PSocket
```
public I2PSocket createI2PSocket(Destination dest,
                                 I2PSocketOptions opt)
                          throws I2PException,
                                 ConnectException,
                                 NoRouteToHostException,
                                 InterruptedIOException
```
    Create a new I2PSocket towards to the specified destination, adding it to the list of connections actually managed by this tunnel.
    Parameters:
    dest - The destination to connect to, non-null
    opt - Option to be used to open when opening the socket
    Returns:
    a new I2PSocket
    Throws:
    ConnectException - if the peer refuses the connection
    NoRouteToHostException - if the peer is not found or not reachable
    InterruptedIOException - if the connection timeouts
    I2PException - if there is some other I2P-related problem
  - createI2PSocket
```
public I2PSocket createI2PSocket(Destination dest,
                                 int port)
                          throws I2PException,
                                 ConnectException,
                                 NoRouteToHostException,
                                 InterruptedIOException
```
    Create a new I2PSocket towards to the specified destination, adding it to the list of connections actually managed by this tunnel.
    Parameters:
    dest - The destination to connect to, non-null
    port - The destination port to connect to 0 - 65535
    Returns:
    a new I2PSocket
    Throws:
    I2PException - if there is an I2P-related problem
    ConnectException - if the peer refuses the connection
    NoRouteToHostException - if the peer is not found or not reachable
    InterruptedIOException - if the connection times out
  - destroy
```
public boolean destroy()
```
    Note that the tunnel cannot be reopened after this by calling startRunning(), as it will destroy the underlying socket manager. This releases all resources if not a shared client. For shared client, the router will kill all the remaining streaming timers at shutdown.
    Overrides:
    destroy in class I2PTunnelTask
    Returns:
    success
  - getDefaultOptions
```
protected I2PSocketOptions getDefaultOptions()
```
    Create the default options (using the default timeout, etc). Warning, this does not make a copy of I2PTunnel's client options, it modifies them directly.
    Returns:
    the default socket options
  - getDefaultOptions
```
protected I2PSocketOptions getDefaultOptions(Properties overrides)
```
    Create the default options (using the default timeout, etc). Warning, this does not make a copy of I2PTunnel's client options, it modifies them directly. Do not use overrides for per-socket options.
    Parameters:
    overrides - the properties to override
    Returns:
    the default socket options with overrides
  - getListenHost
```
protected final InetAddress getListenHost(Logging l)
```
    Get the listen host address.
    Parameters:
    l - the logging instance
    Returns:
    the InetAddress for the listen host, or null on error
  - getLocalPort
```
public final int getLocalPort()
```
    Get the local port.
    Returns:
    the local port number
  - getSocketManager
```
public I2PSocketManager getSocketManager()
```
    Returns the I2PSocketManager for this task. For non-shared clients returns the instance socket manager. For shared clients returns the shared static socket manager.
    Overrides:
    getSocketManager in class I2PTunnelTask
    Returns:
    the socket manager
  - getSocketManager
```
protected static I2PSocketManager getSocketManager(I2PTunnel tunnel)
```
    This is ONLY for shared clients. As of 0.9.20 this is fast, and does NOT connect the manager to the router. Call verifySocketManager() for that.
    Parameters:
    tunnel - the I2PTunnel instance
    Returns:
    non-null
    Throws:
    IllegalArgumentException - if the I2CP configuration is b0rked so badly that we cant create a socketManager
  - getSocketManager
```
protected static I2PSocketManager getSocketManager(I2PTunnel tunnel,
                                                   String pkf)
```
    This is ONLY for shared clients. As of 0.9.20 this is fast, and does NOT connect the manager to the router. Call verifySocketManager() for that.
    Parameters:
    tunnel - the I2PTunnel instance
    pkf - the private key file path, or null
    Returns:
    non-null
    Throws:
    IllegalArgumentException - if the I2CP configuration is b0rked so badly that we cant create a socketManager
  - killSharedClient
```
protected static void killSharedClient()
```
    Kill the shared client, so that on restart in android we won't latch onto the old one
  - manageConnection
```
protected void manageConnection(Socket s)
```
    Manage the connection just opened on the specified socket
    Parameters:
    s - Socket to take care of
  - optionsUpdated
```
public void optionsUpdated(I2PTunnel tunnel)
```
    Update the I2PSocketManager.
    Overrides:
    optionsUpdated in class I2PTunnelTask
  - run
```
public void run()
```
    Non-final since 0.9.11. open will be true before being called. Any overrides must set listenerReady = true and then notifyAll() if setup is successful, and must call close() and then notifyAll() on failure or termination.
    Specified by:
    run in interface Runnable
  - startRunning
```
public void startRunning()
```
    Actually open the local socket and start working on incoming connections. *Must* be called by derived classes after initialization. (this wasn't actually true until 0.9.20) This will be fast if i2cp.delayOpen is true, but could take a LONG TIME if it is false, as it connects to the router and builds tunnels. Extending classes must check the value of boolean open after calling super.startRunning(), if false then something went wrong.
  - verifySocketManager
```
protected void verifySocketManager()
```
    Create the manager if it doesn't exist, AND connect it to the router and build tunnels. Sets the this.sockMgr field if it is null, or if we want a new one. This may take a LONG time if building a new manager. We need a socket manager before getDefaultOptions() and most other things
    Throws:
    IllegalArgumentException - if the I2CP configuration is b0rked so badly that we cant create a socketManager

Class I2PTunnelClientBase

Field Summary

Fields inherited from class net.i2p.i2ptunnel.I2PTunnelTask

Constructor Summary

Method Summary

Methods inherited from class net.i2p.i2ptunnel.I2PTunnelTask

Methods inherited from class net.i2p.util.EventDispatcherImpl

Methods inherited from class java.lang.Object

Field Detail

_clientId

_context

_executor

_log

_ownDest

DEFAULT_CONNECT_TIMEOUT

dest

l

listenerReady

mySockets

PROP_USE_SSL

sockLock

sockMgr

ss

Constructor Detail

I2PTunnelClientBase

I2PTunnelClientBase

I2PTunnelClientBase

Method Detail

buildSocketManager

buildSocketManager

buildSocketManager

buildSocketManager

clientConnectionRun

close

closeSocket

createI2PSocket

createI2PSocket

createI2PSocket

destroy

getDefaultOptions

getDefaultOptions

getListenHost

getLocalPort

getSocketManager

getSocketManager

getSocketManager

killSharedClient

manageConnection

optionsUpdated

run

startRunning

verifySocketManager