## Uses of Class
net.i2p.data.SessionKey

Packages that use SessionKey
net.i2p.client: Implements the base I2P SDK for developing applications that communicate through I2P.
net.i2p.client.streaming: Implements a TCP-like (reliable, authenticated, in order) set of sockets for communicating over the IP-like (unreliable, unauthenticated, unordered) I2P messages.
net.i2p.crypto
net.i2p.data
net.i2p.data.i2np
net.i2p.router.message
net.i2p.router.transport.ntcp
net.i2p.router.transport.tcp: Implements the transport for communicating with other routers via TCP/IP.
net.i2p.router.transport.udp
net.i2p.router.tunnel
net.i2p.router.tunnel.pool

Uses of SessionKey in net.i2p.client

Methods in net.i2p.client that return SessionKey
`SessionKey` `MessageState.getKey()`
`SessionKey` `MessageState.getNewKey()`

Methods in net.i2p.client with parameters of type SessionKey
`boolean` `I2PSessionImpl2.sendMessage(Destination dest, byte[] payload, int offset, int size, SessionKey keyUsed, java.util.Set tagsSent)`
`boolean` `I2PSession.sendMessage(Destination dest, byte[] payload, int offset, int size, SessionKey keyUsed, java.util.Set tagsSent)`
`boolean` `I2PSessionImpl2.sendMessage(Destination dest, byte[] payload, SessionKey keyUsed, java.util.Set tagsSent)`
`abstract boolean` `I2PSessionImpl.sendMessage(Destination dest, byte[] payload, SessionKey keyUsed, java.util.Set tagsSent)`
`boolean` `I2PSession.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.
`void` `I2CPMessageProducer.sendMessage(I2PSessionImpl session, Destination dest, long nonce, byte[] payload, SessionTag tag, SessionKey key, java.util.Set tags, SessionKey newKey)` Package up and send the payload to the router for delivery
`void` `MessageState.setKey(SessionKey key)`
`void` `MessageState.setNewKey(SessionKey key)`

Uses of SessionKey in net.i2p.client.streaming

Methods in net.i2p.client.streaming that return SessionKey
`SessionKey` `PacketLocal.getKeyUsed()`

Methods in net.i2p.client.streaming with parameters of type SessionKey
`boolean` `ConnectionManager.ping(Destination peer, long timeoutMs, boolean blocking, SessionKey keyToUse, java.util.Set tagsToSend, ConnectionManager.PingNotifier notifier)`
`void` `PacketLocal.setKeyUsed(SessionKey key)`

Uses of SessionKey in net.i2p.crypto

Methods in net.i2p.crypto that return SessionKey
`SessionKey` `TransientSessionKeyManager.consumeTag(SessionTag tag)` Determine if we have received a session key associated with the given session tag, and if so, discard it (but keep track for frequent dups) and return the decryption key it was received with (via tagsReceived(...)).
`SessionKey` `SessionKeyManager.consumeTag(SessionTag tag)` Determine if we have received a session key associated with the given session tag, and if so, discard it (but keep track for frequent dups) and return the decryption key it was received with (via tagsReceived(...)).
`SessionKey` `SessionKeyManager.createSession(PublicKey target)` Generate a new session key and associate it with the specified target.
`SessionKey` `KeyGenerator.generateSessionKey()` Generate a private 256 bit session key
`SessionKey` `KeyGenerator.generateSessionKey(byte[] salt, byte[] passphrase)` PBE the passphrase with the salt
`SessionKey` `TransientSessionKeyManager.TagSet.getAssociatedKey()`
`SessionKey` `TransientSessionKeyManager.OutboundSession.getCurrentKey()`
`SessionKey` `TransientSessionKeyManager.getCurrentKey(PublicKey target)` Retrieve the session key currently associated with encryption to the target, or null if a new session key should be generated.
`SessionKey` `SessionKeyManager.getCurrentKey(PublicKey target)` Retrieve the session key currently associated with encryption to the target, or null if a new session key should be generated.
`SessionKey` `DHSessionKeyBuilder.getSessionKey()` Retrieve the session key, calculating it if necessary (and if possible).

Methods in net.i2p.crypto with parameters of type SessionKey
`Hash` `HMACGenerator.calculate(SessionKey key, byte[] data)` Calculate the HMAC of the data with the given key
`void` `HMACGenerator.calculate(SessionKey key, byte[] data, int offset, int length, byte[] target, int targetOffset)` Calculate the HMAC of the data with the given key
`SessionTag` `TransientSessionKeyManager.consumeNextAvailableTag(PublicKey target, SessionKey key)` Retrieve the next available session tag for identifying the use of the given key when communicating with the target.
`SessionTag` `SessionKeyManager.consumeNextAvailableTag(PublicKey target, SessionKey key)` Retrieve the next available session tag for identifying the use of the given key when communicating with the target.
`void` `TransientSessionKeyManager.createSession(PublicKey target, SessionKey key)` Associate a new session key with the specified target.
`void` `SessionKeyManager.createSession(PublicKey target, SessionKey key)` Associate a new session key with the specified target.
`void` `CryptixAESEngine.decrypt(byte[] payload, int payloadIndex, byte[] out, int outIndex, SessionKey sessionKey, byte[] iv, int length)`
`void` `AESEngine.decrypt(byte[] payload, int payloadIndex, byte[] out, int outIndex, SessionKey sessionKey, byte[] iv, int length)` Decrypt the data with the session key
`void` `CryptixAESEngine.decrypt(byte[] payload, int payloadIndex, byte[] out, int outIndex, SessionKey sessionKey, byte[] iv, int ivOffset, int length)`
`void` `AESEngine.decrypt(byte[] payload, int payloadIndex, byte[] out, int outIndex, SessionKey sessionKey, byte[] iv, int ivOffset, int length)` Decrypt the data with the session key
`(package private) byte[]` `ElGamalAESEngine.decryptAESBlock(byte[] encrypted, int offset, int encryptedLen, SessionKey key, byte[] iv, byte[] sentTag, java.util.Set foundTags, SessionKey foundKey)`
`(package private) byte[]` `ElGamalAESEngine.decryptAESBlock(byte[] encrypted, SessionKey key, byte[] iv, byte[] sentTag, java.util.Set foundTags, SessionKey foundKey)` Decrypt the AES data with the session key and IV.
`void` `CryptixAESEngine.decryptBlock(byte[] payload, int inIndex, SessionKey sessionKey, byte[] rv, int outIndex)` decrypt the data with the session key provided
`void` `AESEngine.decryptBlock(byte[] payload, int inIndex, SessionKey sessionKey, byte[] rv, int outIndex)` decrypt the data with the session key provided
`(package private) byte[]` `ElGamalAESEngine.decryptExistingSession(byte[] data, SessionKey key, PrivateKey targetPrivateKey, java.util.Set foundTags, SessionKey usedKey, SessionKey foundKey)` scenario 2: The data begins with 32 byte session tag, which also serves as the preIV.

`(package private) byte[]`

`ElGamalAESEngine.decryptNewSession(byte[] data, PrivateKey targetPrivateKey, java.util.Set foundTags, SessionKey usedKey, SessionKey foundKey)`
scenario 1: Begin with 222 bytes, ElG encrypted, containing: - 32 byte SessionKey - 32 byte pre-IV for the AES - 158 bytes of random padding Then encrypt with AES using that session key and the first 16 bytes of the SHA256 of the pre-IV, using the decryptAESBlock method & structure.

`void` `CryptixAESEngine.encrypt(byte[] payload, int payloadIndex, byte[] out, int outIndex, SessionKey sessionKey, byte[] iv, int length)`
`void` `AESEngine.encrypt(byte[] payload, int payloadIndex, byte[] out, int outIndex, SessionKey sessionKey, byte[] iv, int length)` Encrypt the payload with the session key
`void` `CryptixAESEngine.encrypt(byte[] payload, int payloadIndex, byte[] out, int outIndex, SessionKey sessionKey, byte[] iv, int ivOffset, int length)`
`void` `AESEngine.encrypt(byte[] payload, int payloadIndex, byte[] out, int outIndex, SessionKey sessionKey, byte[] iv, int ivOffset, int length)` Encrypt the payload with the session key
`byte[]` `ElGamalAESEngine.encrypt(byte[] data, PublicKey target, SessionKey key, long paddedSize)` Encrypt the data to the target using the given key delivering no tags
`byte[]` `ElGamalAESEngine.encrypt(byte[] data, PublicKey target, SessionKey key, java.util.Set tagsForDelivery, long paddedSize)` Encrypt the data to the target using the given key and deliver the specified tags
`byte[]` `ElGamalAESEngine.encrypt(byte[] data, PublicKey target, SessionKey key, java.util.Set tagsForDelivery, SessionTag currentTag, long paddedSize)` Encrypt the data to the target using the given key and deliver the specified tags
`byte[]` `ElGamalAESEngine.encrypt(byte[] data, PublicKey target, SessionKey key, java.util.Set tagsForDelivery, SessionTag currentTag, SessionKey newKey, long paddedSize)` Encrypt the unencrypted data to the target.
`(package private) byte[]` `ElGamalAESEngine.encryptAESBlock(byte[] data, SessionKey key, byte[] iv, java.util.Set tagsForDelivery, SessionKey newKey, long paddedSize)` For both scenarios, this method encrypts the AES area using the given key, iv and making sure the resulting data is at least as long as the paddedSize and also mod 16 bytes.
`(package private) byte[]` `ElGamalAESEngine.encryptAESBlock(byte[] data, SessionKey key, byte[] iv, java.util.Set tagsForDelivery, SessionKey newKey, long paddedSize, int prefixBytes)`
`void` `CryptixAESEngine.encryptBlock(byte[] payload, int inIndex, SessionKey sessionKey, byte[] out, int outIndex)`
`void` `AESEngine.encryptBlock(byte[] payload, int inIndex, SessionKey sessionKey, byte[] out, int outIndex)`
`(package private) byte[]` `ElGamalAESEngine.encryptExistingSession(byte[] data, PublicKey target, SessionKey key, java.util.Set tagsForDelivery, SessionTag currentTag, SessionKey newKey, long paddedSize)` scenario 2: Begin with 32 byte session tag, which also serves as the preIV.

`(package private) byte[]`

`ElGamalAESEngine.encryptNewSession(byte[] data, PublicKey target, SessionKey key, java.util.Set tagsForDelivery, SessionKey newKey, long paddedSize)`
scenario 1: Begin with 222 bytes, ElG encrypted, containing: - 32 byte SessionKey - 32 byte pre-IV for the AES - 158 bytes of random padding Then encrypt with AES using that session key and the first 16 bytes of the SHA256 of the pre-IV: - 2 byte integer specifying the # of session tags - that many 32 byte session tags - 4 byte integer specifying data.length - SHA256 of data - 1 byte flag that, if == 1, is followed by a new SessionKey - data - random bytes, padding the total size to greater than paddedSize with a mod 16 = 0

`int` `TransientSessionKeyManager.getAvailableTags(PublicKey target, SessionKey key)` Determine (approximately) how many available session tags for the current target have been confirmed and are available
`int` `SessionKeyManager.getAvailableTags(PublicKey target, SessionKey key)` Determine (approximately) how many available session tags for the current target have been confirmed and are available
`long` `TransientSessionKeyManager.getAvailableTimeLeft(PublicKey target, SessionKey key)` Determine how long the available tags will be available for before expiring, in milliseconds
`long` `SessionKeyManager.getAvailableTimeLeft(PublicKey target, SessionKey key)` Determine how long the available tags will be available for before expiring, in milliseconds
`byte[]` `AESEngine.safeDecrypt(byte[] payload, SessionKey sessionKey, byte[] iv)`
`byte[]` `AESEngine.safeEncrypt(byte[] payload, SessionKey sessionKey, byte[] iv, int paddedSize)`
`void` `TransientSessionKeyManager.OutboundSession.setCurrentKey(SessionKey key)`
`void` `TransientSessionKeyManager.tagsDelivered(PublicKey target, SessionKey key, java.util.Set sessionTags)` Take note of the fact that the given sessionTags associated with the key for encryption to the target have definitely been received at the target (aka call this method after receiving an ack to a message delivering them)
`void` `SessionKeyManager.tagsDelivered(PublicKey target, SessionKey key, java.util.Set sessionTags)` Take note of the fact that the given sessionTags associated with the key for encryption to the target have definitely been received at the target (aka call this method after receiving an ack to a message delivering them)
`void` `TransientSessionKeyManager.tagsReceived(SessionKey key, java.util.Set sessionTags)` Accept the given tags and associate them with the given key for decryption
`void` `SessionKeyManager.tagsReceived(SessionKey key, java.util.Set sessionTags)` Accept the given tags and associate them with the given key for decryption
`boolean` `HMACGenerator.verify(SessionKey key, byte[] curData, int curOffset, int curLength, byte[] origMAC, int origMACOffset, int origMACLength)` Verify the MAC inline, reducing some unnecessary memory churn.

Constructors in net.i2p.crypto with parameters of type SessionKey
`AESInputStream(I2PAppContext context, java.io.InputStream source, SessionKey key, byte[] iv)`
`AESOutputStream(I2PAppContext context, java.io.OutputStream source, SessionKey key, byte[] iv)`
`TransientSessionKeyManager.OutboundSession(PublicKey target, SessionKey curKey, long established, long lastUsed, java.util.List tagSets)`
`TransientSessionKeyManager.TagSet(java.util.Set tags, SessionKey key, long date)`

Uses of SessionKey in net.i2p.data

Fields in net.i2p.data declared as SessionKey
`static SessionKey` `SessionKey.INVALID_KEY`

Uses of SessionKey in net.i2p.data.i2np

Methods in net.i2p.data.i2np that return SessionKey
`SessionKey` `DeliveryInstructions.getEncryptionKey()`
`SessionKey` `TunnelCreateMessage.getIVKey()`
`SessionKey` `TunnelSessionKey.getKey()`
`SessionKey` `TunnelCreateMessage.getLayerKey()`
`SessionKey` `TunnelCreateMessage.getReplyKey()`
`SessionKey` `BuildRequestRecord.readIVKey()` Tunnel IV encryption key that the current hop should use
`SessionKey` `BuildRequestRecord.readLayerKey()` Tunnel layer encryption key that the current hop should use
`SessionKey` `BuildRequestRecord.readReplyKey()` Session key that should be used to encrypt the reply

Methods in net.i2p.data.i2np with parameters of type SessionKey
`byte[]` `BuildResponseRecord.create(I2PAppContext ctx, int status, SessionKey replyKey, byte[] replyIV, long responseMessageId)` Create a new encrypted response
`void` `BuildRequestRecord.createRecord(I2PAppContext ctx, long receiveTunnelId, Hash peer, long nextTunnelId, Hash nextHop, long nextMsgId, SessionKey layerKey, SessionKey ivKey, SessionKey replyKey, byte[] iv, boolean isInGateway, boolean isOutEndpoint)` Populate this instance with data.
`void` `DeliveryInstructions.setEncryptionKey(SessionKey key)`
`void` `TunnelCreateMessage.setIVKey(SessionKey key)`
`void` `TunnelSessionKey.setKey(SessionKey key)`
`void` `TunnelCreateMessage.setLayerKey(SessionKey key)`
`void` `TunnelCreateMessage.setReplyKey(SessionKey key)`

Constructors in net.i2p.data.i2np with parameters of type SessionKey
`TunnelSessionKey(SessionKey key)`

Uses of SessionKey in net.i2p.router.message

Methods in net.i2p.router.message with parameters of type SessionKey
`static GarlicMessage` `GarlicMessageBuilder.buildMessage(RouterContext ctx, GarlicConfig config, SessionKey wrappedKey, java.util.Set wrappedTags)`
`static GarlicMessage` `GarlicMessageBuilder.buildMessage(RouterContext ctx, GarlicConfig config, SessionKey wrappedKey, java.util.Set wrappedTags, int numTagsToDeliver)`
`static GarlicMessage` `GarlicMessageBuilder.buildMessage(RouterContext ctx, GarlicConfig config, SessionKey wrappedKey, java.util.Set wrappedTags, int numTagsToDeliver, boolean forceElGamal)`
`static GarlicMessage` `GarlicMessageBuilder.buildMessage(RouterContext ctx, GarlicConfig config, SessionKey wrappedKey, java.util.Set wrappedTags, PublicKey target, SessionKey encryptKey, SessionTag encryptTag)`

`(package private) static GarlicMessage`

`OutboundClientMessageJobHelper.createGarlicMessage(RouterContext ctx, long replyToken, long expiration, PublicKey recipientPK, PayloadGarlicConfig dataClove, Hash from, Destination dest, TunnelInfo replyTunnel, SessionKey wrappedKey, java.util.Set wrappedTags, boolean requireAck, LeaseSet bundledReplyLeaseSet)`
Allow the app to specify the data clove directly, which enables OutboundClientMessage to resend the same payload (including expiration and unique id) in different garlics (down different tunnels)

`(package private) static GarlicMessage`

`OutboundClientMessageJobHelper.createGarlicMessage(RouterContext ctx, long replyToken, long expiration, PublicKey recipientPK, Payload data, Hash from, Destination dest, TunnelInfo replyTunnel, SessionKey wrappedKey, java.util.Set wrappedTags, boolean requireAck, LeaseSet bundledReplyLeaseSet)`
Build a garlic message that will be delivered to the router on which the target is located.

Constructors in net.i2p.router.message with parameters of type SessionKey
`SendGarlicJob(RouterContext ctx, GarlicConfig config, Job onSend, Job onSendFailed, ReplyJob onReply, Job onReplyFailed, long timeoutMs, int priority, MessageSelector replySelector, SessionKey wrappedKey, java.util.Set wrappedTags)`

Uses of SessionKey in net.i2p.router.transport.ntcp

Methods in net.i2p.router.transport.ntcp with parameters of type SessionKey
`void` `NTCPConnection.finishInboundEstablishment(SessionKey key, long clockSkew, byte[] prevWriteEnd, byte[] prevReadEnd)`
`void` `NTCPConnection.finishOutboundEstablishment(SessionKey key, long clockSkew, byte[] prevWriteEnd, byte[] prevReadEnd)`

Uses of SessionKey in net.i2p.router.transport.tcp

Methods in net.i2p.router.transport.tcp that return SessionKey
`SessionKey` `ConnectionTagManager.getKey(ByteArray tag)`
`SessionKey` `ConnectionTagManager.getKey(Hash peer)`

Methods in net.i2p.router.transport.tcp with parameters of type SessionKey
`void` `ConnectionTagManager.replaceTag(Hash peer, ByteArray newTag, SessionKey key)` Update the tag associated with a peer, dropping the old one

Uses of SessionKey in net.i2p.router.transport.udp

Methods in net.i2p.router.transport.udp that return SessionKey
`SessionKey` `PeerTestState.getAliceIntroKey()`
`SessionKey` `PeerTestState.getBobCipherKey()`
`SessionKey` `PeerTestState.getBobMACKey()`
`SessionKey` `PeerTestState.getCharlieIntroKey()`
`SessionKey` `OutboundEstablishState.getCipherKey()`
`SessionKey` `InboundEstablishState.getCipherKey()`
`SessionKey` `PeerState.getCurrentCipherKey()` The AES key used to encrypt/decrypt packets, set only after the connection is established.
`SessionKey` `PeerState.getCurrentMACKey()` The AES key used to verify packets, set only after the connection is established.
`SessionKey` `UDPTransport.getIntroKey()` Introduction key that people should use to contact us
`SessionKey` `OutboundEstablishState.getIntroKey()`
`SessionKey` `OutboundEstablishState.getMACKey()`
`SessionKey` `InboundEstablishState.getMACKey()`
`SessionKey` `PeerState.getNextCipherKey()` The pending AES key for encrypting/decrypting packets if we are rekeying the connection, or null if we are not in the process of rekeying.
`SessionKey` `PeerState.getNextMACKey()` The pending AES key for verifying packets if we are rekeying the connection, or null if we are not in the process of rekeying.

Methods in net.i2p.router.transport.udp with parameters of type SessionKey
`UDPPacket` `PacketBuilder.buildPeerTestFromAlice(java.net.InetAddress toIP, int toPort, SessionKey toIntroKey, long nonce, SessionKey aliceIntroKey)` Build a packet as if we are Alice and we either want Bob to begin a peer test or Charlie to finish a peer test.
`UDPPacket` `PacketBuilder.buildPeerTestFromAlice(java.net.InetAddress toIP, int toPort, SessionKey toCipherKey, SessionKey toMACKey, long nonce, SessionKey aliceIntroKey)`
`UDPPacket` `PacketBuilder.buildPeerTestToAlice(java.net.InetAddress aliceIP, int alicePort, SessionKey aliceIntroKey, SessionKey charlieIntroKey, long nonce)` Build a packet as if we are either Bob or Charlie and we are helping test Alice.
`UDPPacket` `PacketBuilder.buildPeerTestToBob(java.net.InetAddress bobIP, int bobPort, java.net.InetAddress aliceIP, int alicePort, SessionKey aliceIntroKey, long nonce, SessionKey bobCipherKey, SessionKey bobMACKey)` Build a packet as if we are Charlie sending Bob a packet verifying that we will help test Alice.
`UDPPacket` `PacketBuilder.buildPeerTestToCharlie(java.net.InetAddress aliceIP, int alicePort, SessionKey aliceIntroKey, long nonce, java.net.InetAddress charlieIP, int charliePort, SessionKey charlieCipherKey, SessionKey charlieMACKey)` Build a packet as if we are Bob sending Charlie a packet to help test Alice.
`UDPPacket` `PacketBuilder.buildRelayRequest(java.net.InetAddress introHost, int introPort, byte[] introKey, long introTag, SessionKey ourIntroKey, long introNonce, boolean encrypt)`
`UDPPacket[]` `PacketBuilder.buildRelayRequest(UDPTransport transport, OutboundEstablishState state, SessionKey ourIntroKey)` build intro packets for each of the published introducers
`UDPPacket` `PacketBuilder.buildRelayResponse(RemoteHostId alice, PeerState charlie, long nonce, SessionKey aliceIntroKey)`
`UDPPacket` `PacketBuilder.buildSessionCreatedPacket(InboundEstablishState state, int externalPort, SessionKey ourIntroKey)` Build a new SessionCreated packet for the given peer, encrypting it as necessary.
`void` `UDPPacket.decrypt(SessionKey cipherKey)` Decrypt this valid packet, overwriting the _data buffer's payload with the decrypted data (leaving the MAC and IV unaltered)
`void` `PeerTestManager.runTest(java.net.InetAddress bobIP, int bobPort, SessionKey bobCipherKey, SessionKey bobMACKey)`
`void` `PeerTestState.setAliceIntroKey(SessionKey key)`
`void` `PeerTestState.setBobCipherKey(SessionKey key)`
`void` `PeerTestState.setBobMACKey(SessionKey key)`
`void` `PeerTestState.setCharlieIntroKey(SessionKey key)`
`void` `PeerState.setCurrentCipherKey(SessionKey key)` The AES key used to encrypt/decrypt packets, set only after the connection is established.
`void` `PeerState.setCurrentMACKey(SessionKey key)` The AES key used to verify packets, set only after the connection is established.
`void` `PeerState.setNextCipherKey(SessionKey key)` The pending AES key for encrypting/decrypting packets if we are rekeying the connection, or null if we are not in the process of rekeying.
`void` `PeerState.setNextMACKey(SessionKey key)` The pending AES key for verifying packets if we are rekeying the connection, or null if we are not in the process of rekeying.
`boolean` `UDPPacket.validate(SessionKey macKey)` Validate the packet against the MAC specified, returning true if the MAC matches, false otherwise.

Constructors in net.i2p.router.transport.udp with parameters of type SessionKey
`OutboundEstablishState(RouterContext ctx, java.net.InetAddress remoteHost, int remotePort, RouterIdentity remotePeer, SessionKey introKey, UDPAddress addr)`

Uses of SessionKey in net.i2p.router.tunnel

Methods in net.i2p.router.tunnel that return SessionKey
`SessionKey` `HopConfig.getIVKey()` what key should we use to encrypt the preIV before passing it on?
`SessionKey` `HopConfig.getLayerKey()` what key should we use to encrypt the layer before passing it on?
`SessionKey` `HopConfig.getReplyKey()` key to encrypt the reply sent for the new tunnel creation crypto

Methods in net.i2p.router.tunnel with parameters of type SessionKey
`void` `HopConfig.setIVKey(SessionKey key)`
`void` `HopConfig.setLayerKey(SessionKey key)`
`void` `HopConfig.setReplyKey(SessionKey key)`

Uses of SessionKey in net.i2p.router.tunnel.pool

Constructors in net.i2p.router.tunnel.pool with parameters of type SessionKey
`SendGarlicMessageJob(RouterContext ctx, I2NPMessage payload, RouterInfo target, MessageSelector selector, ReplyJob onReply, Job onTimeout, SessionKey sentKey, java.util.Set sentTags)`