OutboundEstablishState2 (Javadocs [I2P+ 2.13.0+]

java.lang.Object
- net.i2p.router.transport.udp.OutboundEstablishState
- - net.i2p.router.transport.udp.OutboundEstablishState2

All Implemented Interfaces:
SSU2Payload.PayloadCallback
```
class OutboundEstablishState2
extends OutboundEstablishState
implements SSU2Payload.PayloadCallback
```
Data for a new connection being established, where we initiated the connection with a remote peer. In other words, we are Alice and they are Bob. SSU2 only.

Nested Class Summary
Nested Classes
Modifier and Type Class and Description
static class OutboundEstablishState2.IntroState
Per-introducer introduction states
- Nested classes/interfaces inherited from class net.i2p.router.transport.udp.OutboundEstablishState
  OutboundEstablishState.OutboundState

Nested Classes
Modifier and Type	Class and Description
`static class`	`OutboundEstablishState2.IntroState` Per-introducer introduction states

Field Summary
- Fields inherited from class net.i2p.router.transport.udp.OutboundEstablishState
  _aliceIP, _alicePort, _bobIP, _bobPort, _context, _currentState, _establishBegin, _lastSend, _log, _nextSend, _receivedRelayTag, _remoteHostId, _remotePeer, _requestSentCount, _requestSentTime, _rtt, MAX_DELAY, RETRANSMIT_DELAY

Constructor Summary

Constructors
Constructor and Description
`OutboundEstablishState2(RouterContext ctx, UDPTransport transport, RemoteHostId claimedAddress, RemoteHostId remoteHostId, RouterIdentity remotePeer, boolean needIntroduction, SessionKey introKey, RouterAddress ra, UDPAddress addr, int version)` Prepare to start a new handshake with the given peer.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`PeerState2`	`confirmedPacketsSent(UDPPacket[] packets)` Note that we just sent the SessionConfirmed packets and save them for retransmission
`int`	`countIntroducers()`
`void`	`fail()` Overridden to destroy the handshake state
`HandshakeState`	`getHandshakeState()`
`OutboundEstablishState2.IntroState`	`getIntroState(Hash h)` Get the current state for the SSU2 introducer specified
`int`	`getMTU()` What is the largest packet we can send to the peer? Only used for Session Confirmed packets.
`EstablishmentManager.Token`	`getNextToken()` Get the next token for this connection
`PeerState2`	`getPeerState()` Get the peer state for this connection
`long`	`getRcvConnID()`
`byte[]`	`getRcvHeaderEncryptKey1()`
`byte[]`	`getRcvHeaderEncryptKey2()`
`byte[]`	`getRcvRetryHeaderEncryptKey2()`
`UDPPacket`	`getRetransmitSessionRequestPacket()` Get a packet to retransmit the SessionRequest
`long`	`getSendConnID()`
`byte[]`	`getSendHeaderEncryptKey1()`
`byte[]`	`getSendHeaderEncryptKey2()`
`InetSocketAddress`	`getSentAddress()`
`long`	`getToken()`
`int`	`getVersion()` Get the version of the SSU protocol in use.
`void`	`gotACK(long ackThru, int acks, byte[] ranges)` Receive an acknowledgment block.
`void`	`gotAddress(byte[] ip, int port)` Receive an address block.
`void`	`gotDateTime(long time)` Receive a date/time synchronization block.
`void`	`gotFragment(byte[] data, int off, int len, long messageId, int frag, boolean isLast)` Receive a fragment of a fragmented message.
`void`	`gotI2NP(I2NPMessage msg)` Receive an I2NP message block.
`void`	`gotOptions(byte[] options, boolean isHandshake)` Receive a session options block.
`void`	`gotPathChallenge(RemoteHostId from, byte[] data)` Receive a path challenge block.
`void`	`gotPathResponse(RemoteHostId from, byte[] data)` Receive a path response block.
`void`	`gotPeerTest(int msg, int status, Hash h, byte[] data)` Receive a peer test block.
`void`	`gotRelayIntro(Hash aliceHash, byte[] data)` Receive a relay introduction.
`void`	`gotRelayRequest(byte[] data)` Receive a relay request.
`void`	`gotRelayResponse(int status, byte[] data)` Receive a relay response.
`void`	`gotRelayTag(long tag)` Receive a relay tag.
`void`	`gotRelayTagRequest()` Receive a relay tag request.
`void`	`gotRI(RouterInfo ri, boolean isHandshake, boolean flood)` Receive a complete RouterInfo block.
`void`	`gotRIFragment(byte[] data, boolean isHandshake, boolean flood, boolean isGzipped, int frag, int totalFrags)` Receive a fragment of a RouterInfo block.
`void`	`gotTermination(int reason, long count)` Receive a session termination block.
`void`	`gotToken(long token, long expires)` Receive a new session token.
`void`	`introduced(byte[] ip, int port, long token)` After introduction
`void`	`introSent(Hash h)` A relay request was sent to the SSU2 introducer specified
`(package private) boolean`	`receiveHolePunch()` Overridden because we don't have to wait for Relay Response first.
`void`	`receiveRetry(UDPPacket packet)` Receive a retry packet
`void`	`receiveSessionCreated(UDPPacket packet)` Receive a SessionCreated packet
`void`	`requestSent(DatagramPacket pkt)` Note that we just sent the SessionRequest packet and save it for retransmission
`void`	`setIntroState(Hash h, OutboundEstablishState2.IntroState state)` Set the current state for the SSU2 introducer specified
`void`	`tokenRequestSent(DatagramPacket packet)` Note that we just sent a token request packet and save it for retransmission
`String`	`toString()` Get string representation
`boolean`	`validateSessionCreated()` Blocking call (run in the establisher thread) to determine if the session was created properly.

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

- Constructor Detail
  - OutboundEstablishState2
```
public OutboundEstablishState2(RouterContext ctx,
                               UDPTransport transport,
                               RemoteHostId claimedAddress,
                               RemoteHostId remoteHostId,
                               RouterIdentity remotePeer,
                               boolean needIntroduction,
                               SessionKey introKey,
                               RouterAddress ra,
                               UDPAddress addr,
                               int version)
                        throws IllegalArgumentException
```
    Prepare to start a new handshake with the given peer. Caller must then check getState() and build a Token Request or Session Request to send to the peer.
    Parameters:
    ctx - the router context
    transport - the UDP transport
    claimedAddress - an IP/port based RemoteHostId, or null if unknown
    remoteHostId - non-null, == claimedAddress if direct, or a hash-based one if indirect
    remotePeer - must have supported sig type
    needIntroduction - should we ask Bob to be an introducer for us? ignored unless allowExtendedOptions is true
    introKey - Bob's introduction key, as published in the netdb
    ra - the router address
    addr - non-null
    version - the SSU2 version
    Throws:
    IllegalArgumentException
- Method Detail
  - confirmedPacketsSent
```
public PeerState2 confirmedPacketsSent(UDPPacket[] packets)
```
    Note that we just sent the SessionConfirmed packets and save them for retransmission
    Parameters:
    packets - the UDP packets sent
    Returns:
    the new PeerState2, may also be retrieved from getPeerState()
  - countIntroducers
```
public int countIntroducers()
```
    Returns:
    the number of introducers
  - fail
```
public void fail()
```
    Overridden to destroy the handshake state
    Overrides:
    fail in class OutboundEstablishState
  - getHandshakeState
```
public HandshakeState getHandshakeState()
```
    Returns:
    the handshake state
  - getIntroState
```
public OutboundEstablishState2.IntroState getIntroState(Hash h)
```
    Get the current state for the SSU2 introducer specified
    Parameters:
    h - the introducer hash
    Returns:
    non-null current state for the SSU2 introducer specified, or INTRO_STATE_INVALID if peer is not an SSU2 introducer
  - getMTU
```
public int getMTU()
```
    What is the largest packet we can send to the peer? Only used for Session Confirmed packets. Session Request is very small.
    Returns:
    the MTU in bytes
  - getNextToken
```
public EstablishmentManager.Token getNextToken()
```
    Get the next token for this connection
    Returns:
    may be null
  - getPeerState
```
public PeerState2 getPeerState()
```
    Get the peer state for this connection
    Returns:
    null if we have not sent the session confirmed
  - getRcvConnID
```
public long getRcvConnID()
```
    Returns:
    the receive connection ID
  - getRcvHeaderEncryptKey1
```
public byte[] getRcvHeaderEncryptKey1()
```
    Returns:
    the receive header encrypt key 1
  - getRcvHeaderEncryptKey2
```
public byte[] getRcvHeaderEncryptKey2()
```
    Returns:
    null before Session Request is sent (i.e. we sent a Token Request first)
  - getRcvRetryHeaderEncryptKey2
```
public byte[] getRcvRetryHeaderEncryptKey2()
```
    Returns:
    the retry header encrypt key 2
  - getRetransmitSessionRequestPacket
```
public UDPPacket getRetransmitSessionRequestPacket()
```
    Get a packet to retransmit the SessionRequest
    Returns:
    null if not sent or already got the session created
  - getSendConnID
```
public long getSendConnID()
```
    Returns:
    the send connection ID
  - getSendHeaderEncryptKey1
```
public byte[] getSendHeaderEncryptKey1()
```
    Returns:
    the send header encrypt key 1
  - getSendHeaderEncryptKey2
```
public byte[] getSendHeaderEncryptKey2()
```
    Returns:
    the send header encrypt key 2
  - getSentAddress
```
public InetSocketAddress getSentAddress()
```
    Returns:
    the Bob socket address
  - getToken
```
public long getToken()
```
    Returns:
    the current token
  - getVersion
```
public int getVersion()
```
    Description copied from class: OutboundEstablishState
    Get the version of the SSU protocol in use.
    Overrides:
    getVersion in class OutboundEstablishState
    Returns:
    the protocol version
  - gotACK
```
public void gotACK(long ackThru,
                   int acks,
                   byte[] ranges)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive an acknowledgment block.
    Specified by:
    gotACK in interface SSU2Payload.PayloadCallback
    Parameters:
    ackThru - highest contiguous sequence number acknowledged
    acks - number of additional acknowledgments beyond ackThru
    ranges - null if none
  - gotAddress
```
public void gotAddress(byte[] ip,
                       int port)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive an address block.
    Specified by:
    gotAddress in interface SSU2Payload.PayloadCallback
    Parameters:
    ip - IP address bytes
    port - port number
  - gotDateTime
```
public void gotDateTime(long time)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a date/time synchronization block.
    Specified by:
    gotDateTime in interface SSU2Payload.PayloadCallback
    Parameters:
    time - time in milliseconds since epoch
  - gotFragment
```
public void gotFragment(byte[] data,
                        int off,
                        int len,
                        long messageId,
                        int frag,
                        boolean isLast)
                 throws DataFormatException
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a fragment of a fragmented message. 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
    Parameters:
    data - buffer containing fragment data
    off - offset in data
    len - length of data to copy
    messageId - unique message identifier
    frag - fragment number (0-based)
    isLast - whether this is the last fragment
    Throws:
    DataFormatException
  - gotI2NP
```
public void gotI2NP(I2NPMessage msg)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive an I2NP message block.
    Specified by:
    gotI2NP in interface SSU2Payload.PayloadCallback
    Parameters:
    msg - the parsed I2NP message
  - gotOptions
```
public void gotOptions(byte[] options,
                       boolean isHandshake)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a session options block.
    Specified by:
    gotOptions in interface SSU2Payload.PayloadCallback
    Parameters:
    options - the option data
    isHandshake - true only for message 3 part 2
  - gotPathChallenge
```
public void gotPathChallenge(RemoteHostId from,
                             byte[] data)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a path challenge block.
    Specified by:
    gotPathChallenge in interface SSU2Payload.PayloadCallback
    Parameters:
    from - null if unknown
  - gotPathResponse
```
public void gotPathResponse(RemoteHostId from,
                            byte[] data)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a path response block.
    Specified by:
    gotPathResponse in interface SSU2Payload.PayloadCallback
    Parameters:
    from - null if unknown
  - gotPeerTest
```
public void gotPeerTest(int msg,
                        int status,
                        Hash h,
                        byte[] data)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a peer test block.
    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)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a relay introduction.
    Specified by:
    gotRelayIntro in interface SSU2Payload.PayloadCallback
    Parameters:
    aliceHash - hash of the introducer
    data - excludes flag, includes signature
  - gotRelayRequest
```
public void gotRelayRequest(byte[] data)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a relay request.
    Specified by:
    gotRelayRequest in interface SSU2Payload.PayloadCallback
    Parameters:
    data - excludes flag, includes signature
  - gotRelayResponse
```
public void gotRelayResponse(int status,
                             byte[] data)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a relay response.
    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)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a relay tag.
    Specified by:
    gotRelayTag in interface SSU2Payload.PayloadCallback
    Parameters:
    tag - the relay tag
  - gotRelayTagRequest
```
public void gotRelayTagRequest()
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a relay tag request.
    Specified by:
    gotRelayTagRequest in interface SSU2Payload.PayloadCallback
  - gotRI
```
public void gotRI(RouterInfo ri,
                  boolean isHandshake,
                  boolean flood)
           throws DataFormatException
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a complete RouterInfo block.
    Specified by:
    gotRI in interface SSU2Payload.PayloadCallback
    Parameters:
    ri - will already be validated
    isHandshake - true only for message 3 part 2
    flood - true if this is a floodfill router
    Throws:
    DataFormatException
  - gotRIFragment
```
public void gotRIFragment(byte[] data,
                          boolean isHandshake,
                          boolean flood,
                          boolean isGzipped,
                          int frag,
                          int totalFrags)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a fragment of a RouterInfo block.
    Specified by:
    gotRIFragment in interface SSU2Payload.PayloadCallback
    Parameters:
    data - is first gzipped and then fragmented
    isHandshake - true only for message 3 part 2
    flood - true if this is a floodfill router
    isGzipped - true if the data is gzipped
    frag - fragment number (0-based)
    totalFrags - total number of fragments
  - gotTermination
```
public void gotTermination(int reason,
                           long count)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a session termination block.
    Specified by:
    gotTermination in interface SSU2Payload.PayloadCallback
    Parameters:
    reason - termination reason code
    count - in theory could wrap around to negative, but very unlikely
  - gotToken
```
public void gotToken(long token,
                     long expires)
```
    Description copied from interface: SSU2Payload.PayloadCallback
    Receive a new session token.
    Specified by:
    gotToken in interface SSU2Payload.PayloadCallback
    Parameters:
    token - the token value
    expires - token expiration time in milliseconds
  - introduced
```
public void introduced(byte[] ip,
                       int port,
                       long token)
```
    After introduction
    Parameters:
    ip - the IP address bytes
    port - the port number
    token - the token received
  - introSent
```
public void introSent(Hash h)
```
    A relay request was sent to the SSU2 introducer specified
    Parameters:
    h - the introducer hash
  - receiveHolePunch
```
boolean receiveHolePunch()
```
    Overridden because we don't have to wait for Relay Response first.
    Overrides:
    receiveHolePunch in class OutboundEstablishState
    Returns:
    true if we should send the SessionRequest now
  - receiveRetry
```
public void receiveRetry(UDPPacket packet)
                  throws GeneralSecurityException
```
    Receive a retry packet
    Parameters:
    packet - the UDP packet received
    Throws:
    GeneralSecurityException
  - receiveSessionCreated
```
public void receiveSessionCreated(UDPPacket packet)
                           throws GeneralSecurityException
```
    Receive a SessionCreated packet
    Parameters:
    packet - the UDP packet received
    Throws:
    GeneralSecurityException
  - requestSent
```
public void requestSent(DatagramPacket pkt)
```
    Note that we just sent the SessionRequest packet and save it for retransmission
    Parameters:
    pkt - the datagram packet sent
  - setIntroState
```
public void setIntroState(Hash h,
                          OutboundEstablishState2.IntroState state)
```
    Set the current state for the SSU2 introducer specified
    Parameters:
    h - the introducer hash
    state - the new state
  - tokenRequestSent
```
public void tokenRequestSent(DatagramPacket packet)
```
    Note that we just sent a token request packet and save it for retransmission
    Parameters:
    packet - the datagram packet sent
  - toString
```
public String toString()
```
    Description copied from class: OutboundEstablishState
    Get string representation
    Overrides:
    toString in class OutboundEstablishState
  - validateSessionCreated
```
public boolean validateSessionCreated()
```
    Description copied from class: OutboundEstablishState
    Blocking call (run in the establisher thread) to determine if the session was created properly. If it wasn't, all the SessionCreated remnants are dropped (perhaps they were spoofed, etc) so that we can receive another one Generates session key and mac key.
    Overrides:
    validateSessionCreated in class OutboundEstablishState
    Returns:
    true if valid

Class OutboundEstablishState2

Nested Class Summary

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

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Constructor Detail

OutboundEstablishState2

Method Detail

confirmedPacketsSent

countIntroducers

fail

getHandshakeState

getIntroState

getMTU

getNextToken

getPeerState

getRcvConnID

getRcvHeaderEncryptKey1

getRcvHeaderEncryptKey2

getRcvRetryHeaderEncryptKey2

getRetransmitSessionRequestPacket

getSendConnID

getSendHeaderEncryptKey1

getSendHeaderEncryptKey2

getSentAddress

getToken

getVersion

gotACK

gotAddress

gotDateTime

gotFragment

gotI2NP

gotOptions

gotPathChallenge

gotPathResponse

gotPeerTest

gotRelayIntro

gotRelayRequest

gotRelayResponse

gotRelayTag

gotRelayTagRequest

gotRI

gotRIFragment

gotTermination

gotToken

introduced

introSent

receiveHolePunch

receiveRetry

receiveSessionCreated

requestSent

setIntroState

tokenRequestSent

toString

validateSessionCreated