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

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `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

    Constructors
    Constructor and Description
    `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

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `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()