InboundEstablishState2 (Javadocs [I2P+ 2.11.0+]

java.lang.Object
- net.i2p.router.transport.udp.InboundEstablishState
- - net.i2p.router.transport.udp.InboundEstablishState2

All Implemented Interfaces:

SSU2Payload.PayloadCallback
```
class InboundEstablishState2
extends InboundEstablishState
implements SSU2Payload.PayloadCallback
```
Data for a new connection being established, where the remote peer has initiated the connection with us. In other words, they are Alice and we are Bob. SSU2 only.

Nested Class Summary
- Nested classes/interfaces inherited from class net.i2p.router.transport.udp.InboundEstablishState
  InboundEstablishState.InboundState

Field Summary
- Fields inherited from class net.i2p.router.transport.udp.InboundEstablishState
  _aliceIP, _alicePort, _bobIP, _bobPort, _context, _createdSentCount, _currentState, _establishBegin, _introductionRequested, _lastSend, _log, _nextSend, _receivedConfirmedIdentity, _receivedUnconfirmedIdentity, _remoteHostId, _rtt, _sentRelayTag, MAX_DELAY, RETRANSMIT_DELAY

Constructor Summary

Constructors
Constructor and Description
`InboundEstablishState2(RouterContext ctx, UDPTransport transport, UDPPacket packet)` Start a new handshake with the given incoming packet, which must be a Session Request or Token Request.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`createdPacketSent()` Note that we just sent a SessionCreated packet
`void`	`createdPacketSent(DatagramPacket pkt)` note that we just sent the SessionCreated packet and save it for retransmission
`void`	`fail()` Overridden to destroy the handshake state
`HandshakeState`	`getHandshakeState()`
`EstablishmentManager.Token`	`getNextToken()`
`PeerState2`	`getPeerState()`
`long`	`getRcvConnID()`
`byte[]`	`getRcvHeaderEncryptKey1()`
`byte[]`	`getRcvHeaderEncryptKey2()`
`UDPPacket`	`getRetransmitSessionCreatedPacket()`
`long`	`getSendConnID()`
`byte[]`	`getSendHeaderEncryptKey1()`
`byte[]`	`getSendHeaderEncryptKey2()`
`InetSocketAddress`	`getSentAddress()`
`long`	`getToken()`
`int`	`getVersion()`
`void`	`gotACK(long ackThru, int acks, byte[] ranges)`
`void`	`gotAddress(byte[] ip, int port)`
`void`	`gotDateTime(long time)`
`void`	`gotFragment(byte[] data, int off, int len, long messageID, int frag, boolean isLast)` Data must be copied out in this method.
`void`	`gotI2NP(I2NPMessage msg)`
`void`	`gotOptions(byte[] options, boolean isHandshake)`
`void`	`gotPathChallenge(RemoteHostId from, byte[] data)`
`void`	`gotPathResponse(RemoteHostId from, byte[] data)`
`void`	`gotPeerTest(int msg, int status, Hash h, byte[] data)`
`void`	`gotRelayIntro(Hash aliceHash, byte[] data)`
`void`	`gotRelayRequest(byte[] data)`
`void`	`gotRelayResponse(int status, byte[] data)`
`void`	`gotRelayTag(long tag)`
`void`	`gotRelayTagRequest()`
`void`	`gotRI(RouterInfo ri, boolean isHandshake, boolean flood)` For most errors here we throw a RIException with a reason code, which is caught in processPayload() to create a PeerStateDestroyed and send a termination with that reason.
`void`	`gotRIFragment(byte[] data, boolean isHandshake, boolean flood, boolean isGzipped, int frag, int totalFrags)`
`void`	`gotTermination(int reason, long count)`
`void`	`gotToken(long token, long expires)`
`void`	`queuePossibleDataPacket(UDPPacket packet)`
`PeerState2`	`receiveSessionConfirmed(UDPPacket packet)` Receive the last messages in the handshake, and create the PeerState.
`void`	`receiveSessionOrTokenRequestAfterRetry(UDPPacket packet)` All exceptions thrown from here will be fatal.
`void`	`retryPacketSent()` note that we just sent a Retry packet
`String`	`toString()`

Methods inherited from class net.i2p.router.transport.udp.InboundEstablishState
addMessage, complete, confirmedFullyReceived, getConfirmedIdentity, getEstablishBeginTime, getLifetime, getLifetime, getNextQueuedMessage, getNextSendTime, getReceivedOurIP, getReceivedX, getRemoteHostId, getRTT, getSentIP, getSentPort, getSentRelayTag, getSentSignedOnTime, getState, isComplete, isIntroductionRequested, packetReceived, sessionRequestReceived, setSentRelayTag

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

- Constructor Detail
  - InboundEstablishState2
```
public InboundEstablishState2(RouterContext ctx,
                              UDPTransport transport,
                              UDPPacket packet)
                       throws GeneralSecurityException
```
    Start a new handshake with the given incoming packet, which must be a Session Request or Token Request. Caller must then check getState() and build a Retry or Session Created in response.
    
    Parameters:
    
    packet - with all header encryption removed, either a SessionRequest OR a TokenRequest.
    
    Throws:
    
    GeneralSecurityException
- Method Detail
  - createdPacketSent
```
public void createdPacketSent()
```
    Description copied from class: InboundEstablishState
    
    Note that we just sent a SessionCreated packet
    
    Overrides:
    
    createdPacketSent in class InboundEstablishState
  - createdPacketSent
```
public void createdPacketSent(DatagramPacket pkt)
```
    note that we just sent the SessionCreated packet and save it for retransmission
  - fail
```
public void fail()
```
    Overridden to destroy the handshake state
    
    Overrides:
    
    fail in class InboundEstablishState
  - getHandshakeState
```
public HandshakeState getHandshakeState()
```
  - getNextToken
```
public EstablishmentManager.Token getNextToken()
```
    Returns:
    
    may be null
  - getPeerState
```
public PeerState2 getPeerState()
```
    Returns:
    
    null if we have not received the session confirmed
  - getRcvConnID
```
public long getRcvConnID()
```
  - getRcvHeaderEncryptKey1
```
public byte[] getRcvHeaderEncryptKey1()
```
  - getRcvHeaderEncryptKey2
```
public byte[] getRcvHeaderEncryptKey2()
```
  - getRetransmitSessionCreatedPacket
```
public UDPPacket getRetransmitSessionCreatedPacket()
```
    Returns:
    
    null if not sent or already got the session confirmed
  - getSendConnID
```
public long getSendConnID()
```
  - getSendHeaderEncryptKey1
```
public byte[] getSendHeaderEncryptKey1()
```
  - getSendHeaderEncryptKey2
```
public byte[] getSendHeaderEncryptKey2()
```
  - getSentAddress
```
public InetSocketAddress getSentAddress()
```
  - getToken
```
public long getToken()
```
  - getVersion
```
public int getVersion()
```
    Overrides:
    
    getVersion in class InboundEstablishState
  - gotACK
```
public void gotACK(long ackThru,
                   int acks,
                   byte[] ranges)
```
    Specified by:
    
    gotACK in interface SSU2Payload.PayloadCallback
    
    ranges - null if none
  - gotAddress
```
public void gotAddress(byte[] ip,
                       int port)
```
    Specified by:
    
    gotAddress in interface SSU2Payload.PayloadCallback
  - gotDateTime
```
public void gotDateTime(long time)
```
    Specified by:
    
    gotDateTime in interface SSU2Payload.PayloadCallback
  - gotFragment
```
public void gotFragment(byte[] data,
                        int off,
                        int len,
                        long messageID,
                        int frag,
                        boolean isLast)
                 throws DataFormatException
```
    Description copied from interface: SSU2Payload.PayloadCallback
    
    Data must be copied out in this method. Data starts at the 9 byte header for fragment 0.
    
    Specified by:
    
    gotFragment in interface SSU2Payload.PayloadCallback
    
    off - offset in data
    
    len - length of data to copy
    
    Throws:
    
    DataFormatException
  - gotI2NP
```
public void gotI2NP(I2NPMessage msg)
```
    Specified by:
    
    gotI2NP in interface SSU2Payload.PayloadCallback
  - gotOptions
```
public void gotOptions(byte[] options,
                       boolean isHandshake)
```
    Specified by:
    
    gotOptions in interface SSU2Payload.PayloadCallback
    
    isHandshake - true only for message 3 part 2
  - gotPathChallenge
```
public void gotPathChallenge(RemoteHostId from,
                             byte[] data)
```
    Specified by:
    
    gotPathChallenge in interface SSU2Payload.PayloadCallback
    
    Parameters:
    
    from - null if unknown
  - gotPathResponse
```
public void gotPathResponse(RemoteHostId from,
                            byte[] data)
```
    Specified by:
    
    gotPathResponse in interface SSU2Payload.PayloadCallback
    
    Parameters:
    
    from - null if unknown
  - gotPeerTest
```
public void gotPeerTest(int msg,
                        int status,
                        Hash h,
                        byte[] data)
```
    Specified by:
    
    gotPeerTest in interface SSU2Payload.PayloadCallback
    
    Parameters:
    
    msg - 1-7
    
    status - 0 = accept, 1-255 = reject
    
    h - Alice or Charlie hash for msg 2 and 4, null for msg 1, 3, 5-7
    
    data - excludes flag, includes signature
  - gotRelayIntro
```
public void gotRelayIntro(Hash aliceHash,
                          byte[] data)
```
    Specified by:
    
    gotRelayIntro in interface SSU2Payload.PayloadCallback
    
    data - excludes flag, includes signature
  - gotRelayRequest
```
public void gotRelayRequest(byte[] data)
```
    Specified by:
    
    gotRelayRequest in interface SSU2Payload.PayloadCallback
    
    Parameters:
    
    data - excludes flag, includes signature
  - gotRelayResponse
```
public void gotRelayResponse(int status,
                             byte[] data)
```
    Specified by:
    
    gotRelayResponse in interface SSU2Payload.PayloadCallback
    
    Parameters:
    
    status - 0 = accept, 1-255 = reject
    
    data - excludes flag, includes signature
  - gotRelayTag
```
public void gotRelayTag(long tag)
```
    Specified by:
    
    gotRelayTag in interface SSU2Payload.PayloadCallback
  - gotRelayTagRequest
```
public void gotRelayTagRequest()
```
    Specified by:
    
    gotRelayTagRequest in interface SSU2Payload.PayloadCallback
  - gotRI
```
public void gotRI(RouterInfo ri,
                  boolean isHandshake,
                  boolean flood)
           throws DataFormatException
```
    For most errors here we throw a RIException with a reason code, which is caught in processPayload() to create a PeerStateDestroyed and send a termination with that reason. Plain DataFormatExceptions indicate you may not respond in-session.
    
    Specified by:
    
    gotRI in interface SSU2Payload.PayloadCallback
    
    Parameters:
    
    ri - will already be validated
    
    isHandshake - true only for message 3 part 2
    
    Throws:
    
    DataFormatException
  - gotRIFragment
```
public void gotRIFragment(byte[] data,
                          boolean isHandshake,
                          boolean flood,
                          boolean isGzipped,
                          int frag,
                          int totalFrags)
```
    Specified by:
    
    gotRIFragment in interface SSU2Payload.PayloadCallback
    
    Parameters:
    
    data - is first gzipped and then fragmented
    
    isHandshake - true only for message 3 part 2
  - gotTermination
```
public void gotTermination(int reason,
                           long count)
```
    Specified by:
    
    gotTermination in interface SSU2Payload.PayloadCallback
    
    count - in theory could wrap around to negative, but very unlikely
  - gotToken
```
public void gotToken(long token,
                     long expires)
```
    Specified by:
    
    gotToken in interface SSU2Payload.PayloadCallback
  - queuePossibleDataPacket
```
public void queuePossibleDataPacket(UDPPacket packet)
```
    Parameters:
    
    packet - with header still encrypted
  - receiveSessionConfirmed
```
public PeerState2 receiveSessionConfirmed(UDPPacket packet)
                                   throws GeneralSecurityException
```
    Receive the last messages in the handshake, and create the PeerState. If the message is fragmented, store the data for reassembly and return, unless this was the last one. Exceptions thrown from here are fatal.
    
    Returns:
    
    the new PeerState2 if are done, may also be retrieved from getPeerState(), or null if more fragments to go
    
    Throws:
    
    GeneralSecurityException
  - receiveSessionOrTokenRequestAfterRetry
```
public void receiveSessionOrTokenRequestAfterRetry(UDPPacket packet)
                                            throws GeneralSecurityException
```
    All exceptions thrown from here will be fatal. fail() will be called before throwing.
    
    Throws:
    
    GeneralSecurityException
  - retryPacketSent
```
public void retryPacketSent()
```
    note that we just sent a Retry packet
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class InboundEstablishState

Class InboundEstablishState2

Nested Class Summary

Nested classes/interfaces inherited from class net.i2p.router.transport.udp.InboundEstablishState

Field Summary

Fields inherited from class net.i2p.router.transport.udp.InboundEstablishState

Constructor Summary

Method Summary

Methods inherited from class net.i2p.router.transport.udp.InboundEstablishState

Methods inherited from class java.lang.Object

Constructor Detail

InboundEstablishState2

Method Detail

createdPacketSent

createdPacketSent

fail

getHandshakeState

getNextToken

getPeerState

getRcvConnID

getRcvHeaderEncryptKey1

getRcvHeaderEncryptKey2

getRetransmitSessionCreatedPacket

getSendConnID

getSendHeaderEncryptKey1

getSendHeaderEncryptKey2

getSentAddress

getToken

getVersion

gotACK

gotAddress

gotDateTime

gotFragment

gotI2NP

gotOptions

gotPathChallenge

gotPathResponse

gotPeerTest

gotRelayIntro

gotRelayRequest

gotRelayResponse

gotRelayTag

gotRelayTagRequest

gotRI

gotRIFragment

gotTermination

gotToken

queuePossibleDataPacket

receiveSessionConfirmed

receiveSessionOrTokenRequestAfterRetry

retryPacketSent

toString