ClientManager (Javadocs [I2P+ 2.13.0+]

java.lang.Object
- net.i2p.router.client.ClientManager

```
class ClientManager
extends Object
```
Coordinate connections and various tasks

Field Summary

Fields
Modifier and Type	Field and Description
`protected RouterContext`	`_ctx` router context
`protected boolean`	`_isStarted` true after start() completes
`protected List<ClientListenerRunner>`	`_listeners` registered client listener runners
`protected int`	`_port` I2CP listen port
`protected boolean`	`_wasStarted` true if start() was ever called
`static SessionId`	`UNKNOWN_SESSION_ID` Sentinel session ID for unknown/unidentified sessions.

Constructor Summary
Constructors
Constructor and Description
ClientManager(RouterContext context, int port)
Does not start the listeners.

Constructors
Constructor and Description
`ClientManager(RouterContext context, int port)` Does not start the listeners.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`destinationEstablished(ClientConnectionRunner runner, Destination dest)` Add to the clients list.
`(package private) void`	`distributeMessage(ClientConnectionRunner sender, Destination fromDest, Destination toDest, Payload payload, MessageId msgId, long messageNonce, long expiration, int flags)` Distribute message to a local or remote destination.
`FloodfillNetworkDatabaseFacade`	`getClientFloodfillNetworkDatabaseFacade(Hash destHash)` get the FloodfillNetworkDatabaseFacade associated with a particular client destination.
`SessionConfig`	`getClientSessionConfig(Destination dest)` Return the client's current config, or null if not connected
`SessionKeyManager`	`getClientSessionKeyManager(Hash dest)` Return the client's SessionKeyManager Use this instead of the RouterContext.sessionKeyManager() to prevent correlation attacks across destinations
`Set<Hash>`	`getPrimaryHashes()` get all the primary hashes for all the clients and return them as a set
`(package private) ClientConnectionRunner`	`getRunner(Destination dest)` Unsynchronized
`(package private) Set<Destination>`	`getRunnerDestinations()` Get the set of all runner destinations.
`I2CPMessageQueue`	`internalConnect()` The InternalClientManager interface.
`boolean`	`isAlive()` As of 0.9.45, this returns true iff the ClientManager is running.
`boolean`	`isLocal(Destination dest)` Unsynchronized.
`boolean`	`isLocal(Hash destHash)` Unsynchronized.
`Set<Destination>`	`listClients()` Unsynchronized.
`void`	`messageDeliveryStatusUpdate(Destination fromDest, MessageId id, long messageNonce, int status)` Update the message delivery status for a client.
`void`	`messageReceived(ClientMessage msg)` Receive and process an incoming client message inline.
`void`	`registerConnection(ClientConnectionRunner runner)` Register a new client connection.
`boolean`	`registerEncryptedDestination(ClientConnectionRunner runner, Hash hash)` Call after destinationEstablished(), when an encrypted leaseset is created, so we know it's local.
`void`	`registerMetaDest(Destination dest)` Declare that we're going to publish a meta LS for this destination.
`void`	`reportAbuse(Destination dest, String reason, int severity)` Unused
`void`	`requestLeaseSet(Destination dest, LeaseSet set, long timeout, Job onCreateJob, Job onFailedJob)` Request that a particular client authorize the Leases contained in the LeaseSet, after which the onCreateJob is queued up.
`void`	`requestLeaseSet(Hash dest, LeaseSet ls)` Request that a particular client authorize the Leases contained in the LeaseSet.
`void`	`restart()` Restart the client manager, disconnecting and reconnecting all clients.
`boolean`	`shouldPublishLeaseSet(Hash destHash)` Determine if we should publish a leaseSet for this hash.
`void`	`shutdown(String msg)` Shutdown the client manager, disconnecting all clients.
`void`	`start()` Start the listeners.
`protected void`	`startListeners()` Call from synchronized method Todo: Start a 3rd listener for IPV6?
`void`	`unregisterConnection(ClientConnectionRunner runner)` Remove all sessions for this runner.
`void`	`unregisterEncryptedDestination(ClientConnectionRunner runner, Hash hash)` Remove the hash for the encrypted LS.
`void`	`unregisterMetaDest(Destination dest)` Declare that we're no longer going to publish a meta LS for this destination.
`void`	`unregisterSession(SessionId id, Destination dest)` Remove only the following session.

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

- Field Detail
  - _ctx
```
protected final RouterContext _ctx
```
    router context
  - _isStarted
```
protected volatile boolean _isStarted
```
    true after start() completes
  - _listeners
```
protected final List<ClientListenerRunner> _listeners
```
    registered client listener runners
  - _port
```
protected final int _port
```
    I2CP listen port
  - _wasStarted
```
protected volatile boolean _wasStarted
```
    true if start() was ever called
  - UNKNOWN_SESSION_ID
```
public static final SessionId UNKNOWN_SESSION_ID
```
    Sentinel session ID for unknown/unidentified sessions.
- Constructor Detail
  - ClientManager
```
public ClientManager(RouterContext context,
                     int port)
```
    Does not start the listeners. Caller must call start()
    Parameters:
    context - the router context
    port - the I2CP port
- Method Detail
  - destinationEstablished
```
public int destinationEstablished(ClientConnectionRunner runner,
                                  Destination dest)
```
    Add to the clients list. Check for a dup destination. Side effect: Sets the session ID of the runner. Caller must call runner.disconnectClient() on failure.
    Parameters:
    runner - the runner
    dest - the destination
    Returns:
    SessionStatusMessage return code, 1 for success, != 1 for failure
  - distributeMessage
```
void distributeMessage(ClientConnectionRunner sender,
                       Destination fromDest,
                       Destination toDest,
                       Payload payload,
                       MessageId msgId,
                       long messageNonce,
                       long expiration,
                       int flags)
```
    Distribute message to a local or remote destination.
    Parameters:
    sender - non-null
    msgId - the router's ID for this message
    messageNonce - the client's ID for this message
    fromDest - source destination
    toDest - target destination
    payload - the message payload
    expiration - message expiration
    flags - not used for local delivery
  - getClientFloodfillNetworkDatabaseFacade
```
public FloodfillNetworkDatabaseFacade getClientFloodfillNetworkDatabaseFacade(Hash destHash)
```
    get the FloodfillNetworkDatabaseFacade associated with a particular client destination. This is inside the runner, so it won't be there if the runner isn't ready.
    Parameters:
    destHash - destination hash associated with the client who's subDb we're looking for, may be null
    Returns:
    will be null if desthash is null or client does not exist or its netDb is not initialized
  - getClientSessionConfig
```
public SessionConfig getClientSessionConfig(Destination dest)
```
    Return the client's current config, or null if not connected
    Parameters:
    dest - the destination
    Returns:
    the SessionConfig, or null
  - getClientSessionKeyManager
```
public SessionKeyManager getClientSessionKeyManager(Hash dest)
```
    Return the client's SessionKeyManager Use this instead of the RouterContext.sessionKeyManager() to prevent correlation attacks across destinations
    Parameters:
    dest - the destination hash
    Returns:
    the SessionKeyManager, or null
  - getPrimaryHashes
```
public Set<Hash> getPrimaryHashes()
```
    get all the primary hashes for all the clients and return them as a set
    Returns:
    non-null
  - getRunner
```
ClientConnectionRunner getRunner(Destination dest)
```
    Unsynchronized
    Parameters:
    dest - the destination
    Returns:
    the runner, or null
  - getRunnerDestinations
```
Set<Destination> getRunnerDestinations()
```
    Get the set of all runner destinations.
    Returns:
    unmodifiable, not a copy
  - internalConnect
```
public I2CPMessageQueue internalConnect()
                                 throws I2PSessionException
```
    The InternalClientManager interface. Connects to the router, receiving a message queue to talk to the router with.
    Returns:
    the message queue for communicating with the router
    Throws:
    I2PSessionException - if the router isn't ready
  - isAlive
```
public boolean isAlive()
```
    As of 0.9.45, this returns true iff the ClientManager is running. Prior to that, it also required all external I2CP listeners that were registered to be running. Since most of our connections are in-JVM, we now return true even if we have I2CP port conflicts.
    Returns:
    true if the ClientManager is running
  - isLocal
```
public boolean isLocal(Destination dest)
```
    Unsynchronized. DOES contain meta destinations.
    Parameters:
    dest - the destination to check
    Returns:
    true if local
  - isLocal
```
public boolean isLocal(Hash destHash)
```
    Unsynchronized. DOES contain meta destinations.
    Parameters:
    destHash - the destination hash to check
    Returns:
    true if local
  - listClients
```
public Set<Destination> listClients()
```
    Unsynchronized. Does NOT contain meta destinations.
    Returns:
    non-null set of local destinations
  - messageDeliveryStatusUpdate
```
public void messageDeliveryStatusUpdate(Destination fromDest,
                                        MessageId id,
                                        long messageNonce,
                                        int status)
```
    Update the message delivery status for a client.
    Parameters:
    fromDest - the source destination
    id - the router's ID for this message
    messageNonce - the client's ID for this message, greater than zero
    status - see I2CP MessageStatusMessage for success/failure codes
  - messageReceived
```
public void messageReceived(ClientMessage msg)
```
    Receive and process an incoming client message inline.
    Parameters:
    msg - the message to process
  - registerConnection
```
public void registerConnection(ClientConnectionRunner runner)
```
    Register a new client connection.
    Parameters:
    runner - the runner
  - registerEncryptedDestination
```
public boolean registerEncryptedDestination(ClientConnectionRunner runner,
                                            Hash hash)
```
    Call after destinationEstablished(), when an encrypted leaseset is created, so we know it's local. Add to the clients list. Check for a dup hash. Caller must call runner.disconnectClient() on failure.
    Parameters:
    hash - the location of the encrypted LS, will change every day
    runner - the runner
    Returns:
    success, false on dup
  - registerMetaDest
```
public void registerMetaDest(Destination dest)
                      throws I2PSessionException
```
    Declare that we're going to publish a meta LS for this destination. Must be called before publishing the leaseset.
    Parameters:
    dest - the destination
    Throws:
    I2PSessionException - on duplicate dest
  - reportAbuse
```
public void reportAbuse(Destination dest,
                        String reason,
                        int severity)
```
    Unused
    Parameters:
    dest - null for all local destinations
    reason - the abuse reason
    severity - the abuse severity
  - requestLeaseSet
```
public void requestLeaseSet(Destination dest,
                            LeaseSet set,
                            long timeout,
                            Job onCreateJob,
                            Job onFailedJob)
```
    Request that a particular client authorize the Leases contained in the LeaseSet, after which the onCreateJob is queued up. If that doesn't occur within the timeout specified, queue up the onFailedJob. This call does not block. UNUSED, the call below without jobs is always used.
    Parameters:
    dest - Destination from which the LeaseSet's authorization should be requested
    set - LeaseSet with requested leases - this object must be updated to contain the signed version (as well as any changed/added/removed Leases). The LeaseSet contains Leases only; it is unsigned and does not have the destination set.
    timeout - ms to wait before failing
    onCreateJob - Job to run after the LeaseSet is authorized
    onFailedJob - Job to run after the timeout passes without receiving authorization
  - requestLeaseSet
```
public void requestLeaseSet(Hash dest,
                            LeaseSet ls)
```
    Request that a particular client authorize the Leases contained in the LeaseSet.
    Parameters:
    dest - Destination from which the LeaseSet's authorization should be requested
    ls - LeaseSet with requested leases - this object must be updated to contain the signed version (as well as any changed/added/removed Leases). The LeaseSet contains Leases only; it is unsigned and does not have the destination set.
  - restart
```
public void restart()
```
    Restart the client manager, disconnecting and reconnecting all clients.
  - shouldPublishLeaseSet
```
public boolean shouldPublishLeaseSet(Hash destHash)
```
    Determine if we should publish a leaseSet for this hash.
    Parameters:
    destHash - the destination hash
    Returns:
    true if we don't know about this destination at all
  - shutdown
```
public void shutdown(String msg)
```
    Shutdown the client manager, disconnecting all clients.
    Parameters:
    msg - message to send to the clients
  - start
```
public void start()
```
    Start the listeners.
  - startListeners
```
protected void startListeners()
```
    Call from synchronized method Todo: Start a 3rd listener for IPV6?
  - unregisterConnection
```
public void unregisterConnection(ClientConnectionRunner runner)
```
    Remove all sessions for this runner.
    Parameters:
    runner - the runner
  - unregisterEncryptedDestination
```
public void unregisterEncryptedDestination(ClientConnectionRunner runner,
                                           Hash hash)
```
    Remove the hash for the encrypted LS. Call before unregisterConnection, or when the hash changes.
    Parameters:
    runner - the runner
    hash - the hash to remove
  - unregisterMetaDest
```
public void unregisterMetaDest(Destination dest)
```
    Declare that we're no longer going to publish a meta LS for this destination.
    Parameters:
    dest - the destination
  - unregisterSession
```
public void unregisterSession(SessionId id,
                              Destination dest)
```
    Remove only the following session. Does not remove the runner if it has more.
    Parameters:
    id - the session ID
    dest - the destination

Class ClientManager

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

_ctx

_isStarted

_listeners

_port

_wasStarted

UNKNOWN_SESSION_ID

Constructor Detail

ClientManager

Method Detail

destinationEstablished

distributeMessage

getClientFloodfillNetworkDatabaseFacade

getClientSessionConfig

getClientSessionKeyManager

getPrimaryHashes

getRunner

getRunnerDestinations

internalConnect

isAlive

isLocal

isLocal

listClients

messageDeliveryStatusUpdate

messageReceived

registerConnection

registerEncryptedDestination

registerMetaDest

reportAbuse

requestLeaseSet

requestLeaseSet

restart

shouldPublishLeaseSet

shutdown

start

startListeners

unregisterConnection

unregisterEncryptedDestination

unregisterMetaDest

unregisterSession