## net.i2p.i2ptunnel
Class I2PTunnelClientBase

    java.lang.Object
      net.i2p.i2ptunnel.I2PTunnelTask
          net.i2p.i2ptunnel.I2PTunnelClientBase

All Implemented Interfaces:
  Runnable, EventDispatcher

Direct Known Subclasses:
  I2PSOCKSTunnel, I2PTunnelClient, I2PTunnelHTTPClientBase, I2PTunnelIRCClient

    public abstract class I2PTunnelClientBase

extends I2PTunnelTask
implements Runnable

Field Summary
`protected long` `_clientId`
`protected I2PAppContext` `_context`
`(package private) static Executor` `_executor` We keep a static pool of socket handlers for all clients, as there is no need for isolation on the client side.
`protected Log` `_log`
`protected boolean` `_ownDest`
`(package private) static long` `DEFAULT_CONNECT_TIMEOUT`
`protected Destination` `dest`
`protected Logging` `l`
`protected List` `mySockets`
`protected Object` `sockLock`
`protected I2PSocketManager` `sockMgr`

Fields inherited from class net.i2p.i2ptunnel.I2PTunnelTask
`open`

Constructor Summary
`I2PTunnelClientBase(int localPort, boolean ownDest, Logging l, EventDispatcher notifyThis, String handlerName, I2PTunnel tunnel)`
`I2PTunnelClientBase(int localPort, boolean ownDest, Logging l, EventDispatcher notifyThis, String handlerName, I2PTunnel tunnel, String pkf)`
`I2PTunnelClientBase(int localPort, Logging l, I2PSocketManager sktMgr, I2PTunnel tunnel, EventDispatcher notifyThis, long clientId)`

Method Summary
`protected I2PSocketManager` `buildSocketManager()`
`protected static I2PSocketManager` `buildSocketManager(I2PTunnel tunnel)`
`protected static I2PSocketManager` `buildSocketManager(I2PTunnel tunnel, String pkf)`
`protected static I2PSocketManager` `buildSocketManager(I2PTunnel tunnel, String pkf, Logging log)`
`protected abstract void` `clientConnectionRun(Socket s)` Manage a connection in a separate thread.
`boolean` `close(boolean forced)`
`static void` `closeSocket(Socket s)`
`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.
`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)`
`int` `getLocalPort()`
`protected I2PSocketManager` `getSocketManager()` this is ONLY for shared clients
`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 void` `manageConnection(Socket s)` Manage the connection just opened on the specified socket
`void` `run()`
`void` `startRunning()` Actually start working on incoming connections.
`protected void` `verifySocketManager()` Sets the this.sockMgr field if it is null, or if we want a new one We need a socket manager before getDefaultOptions() and most other things

Methods inherited from class net.i2p.i2ptunnel.I2PTunnelTask
`attachEventDispatcher, detachEventDispatcher, disconnected, errorOccurred, getEventDispatcher, getEvents, getEventValue, getId, getTunnel, ignoreEvents, isOpen, notifyEvent, reportAbuse, routerDisconnected, setId, setName, setTunnel, toString, unIgnoreEvents, waitEventValue`

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

Field Detail

### _log

    protected final Log _log

### _context

    protected final I2PAppContext _context

### l

    protected final Logging l

### DEFAULT_CONNECT_TIMEOUT

    static final long DEFAULT_CONNECT_TIMEOUT

See Also:
  Constant Field Values

### _clientId

    protected long _clientId

### sockLock

    protected final Object sockLock

### sockMgr

    protected I2PSocketManager sockMgr

### mySockets

    protected List mySockets

### _ownDest

    protected boolean _ownDest

### dest

    protected Destination dest

### _executor

    static final Executor _executor

  We keep a static pool of socket handlers for all clients, as there is no need for isolation on the client side. Extending classes may use it for other purposes. Not for use by servers, as there is no limit on threads.

Constructor Detail

### I2PTunnelClientBase

    public I2PTunnelClientBase(int localPort,
                               Logging l,
                               I2PSocketManager sktMgr,
                               I2PTunnel tunnel,
                               EventDispatcher notifyThis,
                               long clientId)
                        throws IllegalArgumentException

Throws:
  `IllegalArgumentException`

### I2PTunnelClientBase

    public I2PTunnelClientBase(int localPort,
                               boolean ownDest,
                               Logging l,
                               EventDispatcher notifyThis,
                               String handlerName,
                               I2PTunnel tunnel)
                        throws IllegalArgumentException

Throws:
  `IllegalArgumentException`

### I2PTunnelClientBase

    public I2PTunnelClientBase(int localPort,
                               boolean ownDest,
                               Logging l,
                               EventDispatcher notifyThis,
                               String handlerName,
                               I2PTunnel tunnel,
                               String pkf)
                        throws IllegalArgumentException

Parameters:
  `pkf` - null to generate a transient key
Throws:
  `IllegalArgumentException` - if the I2CP configuration is b0rked so badly that we cant create a socketManager

Method Detail

### verifySocketManager

    protected void verifySocketManager()

  Sets the this.sockMgr field if it is null, or if we want a new one 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

### getSocketManager

    protected I2PSocketManager getSocketManager()

  this is ONLY for shared clients

  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)

  this is ONLY for shared clients

  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

  Returns:
    non-null
  Throws:
    `IllegalArgumentException` - if the I2CP configuration is b0rked so badly that we cant create a socketManager

### buildSocketManager

    protected I2PSocketManager buildSocketManager()

  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)

  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)

  Parameters:
    `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)

  Parameters:
    `pkf` - absolute path or null
  Returns:
    non-null
  Throws:
    `IllegalArgumentException` - if the I2CP configuration is b0rked so badly that we cant create a socketManager

### getLocalPort

    public final int getLocalPort()

### getListenHost

    protected final InetAddress getListenHost(Logging l)

### startRunning

    public void startRunning()

  Actually start working on incoming connections. *Must* be called by derived classes after initialization.

### getDefaultOptions

    protected I2PSocketOptions getDefaultOptions()

  create the default options (using the default timeout, etc)

### getDefaultOptions

    protected I2PSocketOptions getDefaultOptions(Properties overrides)

  create the default options (using the default timeout, etc)

### 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
  Returns:
    a new I2PSocket
  Throws:
    `I2PException`
    `ConnectException`
    `NoRouteToHostException`
    `InterruptedIOException`

### 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
    `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

### run

    public final void run()

  Specified by:
    `run` in interface `Runnable`

### manageConnection

    protected void manageConnection(Socket s)

  Manage the connection just opened on the specified socket

  Parameters:
    `s` - Socket to take care of

### close

    public boolean close(boolean forced)

  Specified by:
    `close` in class `I2PTunnelTask`

### closeSocket

    public static void closeSocket(Socket s)

### clientConnectionRun

    protected abstract void clientConnectionRun(Socket s)

  Manage a connection in a separate thread. This only works if you do not override manageConnection()