## net.i2p.client
Class I2PSessionImpl2

    java.lang.Object
      net.i2p.client.I2PSessionImpl
          net.i2p.client.I2PSessionImpl2

All Implemented Interfaces:
  I2CPMessageReader.I2CPMessageEventListener, I2PSession

class I2PSessionImpl2
extends I2PSessionImpl

Thread safe implementation of an I2P session running over TCP.

Author:
  jrandom

Field Summary
`protected I2PAppContext` `_context` used to seperate things out so we can get rid of singletons
`protected I2PClientMessageHandlerMap` `_handlerMap`
`protected I2CPMessageProducer` `_producer` class that generates new messages
`static int` `LISTEN_PORT`

Constructor Summary
`I2PSessionImpl2(I2PAppContext ctx, java.io.InputStream destKeyStream, java.util.Properties options)` Create a new session, reading the Destination, PrivateKey, and SigningPrivateKey from the destKeyStream, and using the specified options to connect to the router

Method Summary
`void` `addNewMessage(MessagePayloadMessage msg)` Recieve a payload message and let the app know its available
`void` `connect()` Connect to the router and establish a session.
`protected static java.util.Set` `createNewTags(int num)`
`(package private) void` `dateUpdated()`
`void` `destroySession()` Tear down the session, and do NOT reconnect
`void` `destroySession(boolean sendDisconnect)`
`protected void` `disconnect()`
`void` `disconnected(I2CPMessageReader reader)` Recieve notification that the I2CP connection was disconnected
`PrivateKey` `getDecryptionKey()` Retrieve the decryption PrivateKey
`(package private) LeaseSet` `getLeaseSet()`
`Destination` `getMyDestination()` Retrieve the destination of the session
`(package private) java.util.Properties` `getOptions()` Retrieve the configuration options
`protected java.lang.String` `getPrefix()`
`SigningPrivateKey` `getPrivateKey()` Retrieve the signing SigningPrivateKey
`(package private) I2CPMessageProducer` `getProducer()` Retrieve the helper that generates I2CP messages
`(package private) SessionId` `getSessionId()` Retrieve the session's ID
`protected long` `getTimeout()`
`boolean` `isClosed()` has the session been closed (or not yet connected)?
`void` `messageReceived(I2CPMessageReader reader, I2CPMessage message)` Recieve notification of some I2CP message and handle it if possible
`(package private) void` `propogateError(java.lang.String msg, java.lang.Throwable error)` Pass off the error to the listener
`void` `readError(I2CPMessageReader reader, java.lang.Exception error)` Recieve notifiation of an error reading the I2CP stream
`byte[]` `receiveMessage(int msgId)` pull the unencrypted AND DECOMPRESSED data
`void` `receiveStatus(int msgId, long nonce, int status)`
`protected boolean` `reconnect()` Called whenever we want to reconnect (used only in the superclass).
`void` `reportAbuse(int msgId, int severity)` Report abuse with regards to the given messageId
`boolean` `sendMessage(Destination dest, byte[] payload)` Send the data to the destination.
`boolean` `sendMessage(Destination dest, byte[] payload, int offset, int size)`
`boolean` `sendMessage(Destination dest, byte[] payload, int offset, int size, SessionKey keyUsed, java.util.Set tagsSent)`
`boolean` `sendMessage(Destination dest, byte[] payload, SessionKey keyUsed, java.util.Set tagsSent)` Like sendMessage above, except the key used and the tags sent are exposed to the application.
`(package private) void` `sendMessage(I2CPMessage message)` Deliver an I2CP message to the router
`(package private) void` `setLeaseSet(LeaseSet ls)`
`(package private) void` `setSessionId(SessionId id)`
`void` `setSessionListener(I2PSessionListener lsnr)` configure the listener
`protected boolean` `shouldReconnect()`

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

Field Detail

### _producer

    protected I2CPMessageProducer _producer

  class that generates new messages

### _handlerMap

    protected I2PClientMessageHandlerMap _handlerMap

### _context

    protected I2PAppContext _context

  used to seperate things out so we can get rid of singletons

### LISTEN_PORT

    public static final int LISTEN_PORT

See Also:
  Constant Field Values

Constructor Detail

### I2PSessionImpl2

    public I2PSessionImpl2(I2PAppContext ctx,
                           java.io.InputStream destKeyStream,
                           java.util.Properties options)
                    throws I2PSessionException

  Create a new session, reading the Destination, PrivateKey, and SigningPrivateKey from the destKeyStream, and using the specified options to connect to the router

Throws:
  `I2PSessionException` - if there is a problem loading the private keys or

Method Detail

### getTimeout

    protected long getTimeout()

### destroySession

    public void destroySession(boolean sendDisconnect)

  Overrides:
    `destroySession` in class `I2PSessionImpl`

### sendMessage

    public boolean sendMessage(Destination dest,
                               byte[] payload)
                        throws I2PSessionException

  Description copied from class: `I2PSessionImpl`
  Send the data to the destination. TODO: this currently always returns true, regardless of whether the message was delivered successfully. make this wait for at least ACCEPTED

  Specified by:
    `sendMessage` in interface `I2PSession`
  Specified by:
    `sendMessage` in class `I2PSessionImpl`
  Throws:
    `I2PSessionException`

### sendMessage

    public boolean sendMessage(Destination dest,
                               byte[] payload,
                               int offset,
                               int size)
                        throws I2PSessionException

  Throws:
    `I2PSessionException`

### sendMessage

    public boolean sendMessage(Destination dest,
                               byte[] payload,
                               SessionKey keyUsed,
                               java.util.Set tagsSent)
                        throws I2PSessionException

  Description copied from interface: `I2PSession`
  Like sendMessage above, except the key used and the tags sent are exposed to the application.

  If some application layer message delivery confirmation is used, rather than i2p's (slow) built in confirmation via guaranteed delivery mode, the application can update the SessionKeyManager, ala:

         SessionKeyManager.getInstance().tagsDelivered(dest.getPublicKey(), keyUsed, tagsSent);

  If an application is using guaranteed delivery mode, this is not useful, but for applications using best effort delivery mode, if they can know with certainty that a message was delivered and can update the SessionKeyManager appropriately, a significant performance boost will occur (subsequent message encryption and decryption will be done via AES and a SessionTag, rather than ElGamal+AES, which is 1000x slower).

  Specified by:
    `sendMessage` in interface `I2PSession`
  Specified by:
    `sendMessage` in class `I2PSessionImpl`
  Throws:
    `I2PSessionException`

### sendMessage

    public boolean sendMessage(Destination dest,
                               byte[] payload,
                               int offset,
                               int size,
                               SessionKey keyUsed,
                               java.util.Set tagsSent)
                        throws I2PSessionException

  Throws:
    `I2PSessionException`

### receiveMessage

    public byte[] receiveMessage(int msgId)
                          throws I2PSessionException

  pull the unencrypted AND DECOMPRESSED data

  Specified by:
    `receiveMessage` in interface `I2PSession`
  Overrides:
    `receiveMessage` in class `I2PSessionImpl`
  Throws:
    `I2PSessionException`

### receiveStatus

    public void receiveStatus(int msgId,
                              long nonce,
                              int status)

  Specified by:
    `receiveStatus` in class `I2PSessionImpl`

### reconnect

    protected boolean reconnect()

  Called whenever we want to reconnect (used only in the superclass). We need to override this to clear out the message state

  Overrides:
    `reconnect` in class `I2PSessionImpl`

### dateUpdated

    void dateUpdated()

### setLeaseSet

    void setLeaseSet(LeaseSet ls)

### getLeaseSet

    LeaseSet getLeaseSet()

### connect

    public void connect()
                 throws I2PSessionException

  Connect to the router and establish a session. This call blocks until a session is granted.

  Specified by:
    `connect` in interface `I2PSession`
  Throws:
    `I2PSessionException` - if there is a configuration error or the router is not reachable

### reportAbuse

    public void reportAbuse(int msgId,
                            int severity)
                     throws I2PSessionException

  Report abuse with regards to the given messageId

  Specified by:
    `reportAbuse` in interface `I2PSession`
  Parameters:
    `msgId` - message that was abusive (or -1 for not message related)
    `severity` - how abusive
  Throws:
    `I2PSessionException`

### createNewTags

    protected static final java.util.Set createNewTags(int num)

### addNewMessage

    public void addNewMessage(MessagePayloadMessage msg)

  Recieve a payload message and let the app know its available

### messageReceived

    public void messageReceived(I2CPMessageReader reader,
                                I2CPMessage message)

  Recieve notification of some I2CP message and handle it if possible

  Specified by:
    `messageReceived` in interface `I2CPMessageReader.I2CPMessageEventListener`

### readError

    public void readError(I2CPMessageReader reader,
                          java.lang.Exception error)

  Recieve notifiation of an error reading the I2CP stream

  Specified by:
    `readError` in interface `I2CPMessageReader.I2CPMessageEventListener`

### getMyDestination

    public Destination getMyDestination()

  Retrieve the destination of the session

  Specified by:
    `getMyDestination` in interface `I2PSession`

### getDecryptionKey

    public PrivateKey getDecryptionKey()

  Retrieve the decryption PrivateKey

  Specified by:
    `getDecryptionKey` in interface `I2PSession`

### getPrivateKey

    public SigningPrivateKey getPrivateKey()

  Retrieve the signing SigningPrivateKey

  Specified by:
    `getPrivateKey` in interface `I2PSession`

### getProducer

    I2CPMessageProducer getProducer()

  Retrieve the helper that generates I2CP messages

### getOptions

    java.util.Properties getOptions()

  Retrieve the configuration options

### getSessionId

    SessionId getSessionId()

  Retrieve the session's ID

### setSessionId

    void setSessionId(SessionId id)

### setSessionListener

    public void setSessionListener(I2PSessionListener lsnr)

  configure the listener

  Specified by:
    `setSessionListener` in interface `I2PSession`
  Parameters:
    `lsnr` - listener to retrieve events

### isClosed

    public boolean isClosed()

  has the session been closed (or not yet connected)?

  Specified by:
    `isClosed` in interface `I2PSession`
  Returns:
    true if the session is closed

### sendMessage

    void sendMessage(I2CPMessage message)
               throws I2PSessionException

  Deliver an I2CP message to the router

  Throws:
    `I2PSessionException` - if the message is malformed or there is an error writing it out

### propogateError

    void propogateError(java.lang.String msg,
                        java.lang.Throwable error)

  Pass off the error to the listener

### destroySession

    public void destroySession()

  Tear down the session, and do NOT reconnect

  Specified by:
    `destroySession` in interface `I2PSession`

### disconnected

    public void disconnected(I2CPMessageReader reader)

  Recieve notification that the I2CP connection was disconnected

  Specified by:
    `disconnected` in interface `I2CPMessageReader.I2CPMessageEventListener`

### disconnect

    protected void disconnect()

### shouldReconnect

    protected boolean shouldReconnect()

### getPrefix

    protected java.lang.String getPrefix()