EstablishmentManager (Javadocs [I2P+ 2.13.0+]

java.lang.Object
- net.i2p.router.transport.udp.EstablishmentManager

```
public class EstablishmentManager
extends Object
```
Coordinate the establishment of new sessions - both inbound and outbound. This has its own thread to add packets to the packet queue when necessary, as well as to drop any failed establishment attempts.

Nested Class Summary
Nested Classes
Modifier and Type Class and Description
static class EstablishmentManager.Token
Token used for SSU2 session establishment and validation.

Nested Classes
Modifier and Type	Class and Description
`static class`	`EstablishmentManager.Token` Token used for SSU2 session establishment and validation.

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) static AtomicLong`	`DATA_MESSAGE_TIMEOUT` for the DSM and or netdb store
`static long`	`IB_TOKEN_EXPIRATION` IB_TOKEN_EXPIRATION.
`(package private) static AtomicLong`	`MAX_IB_ESTABLISH_TIME` Kill any inbound that takes more than this.
`(package private) static AtomicLong`	`MAX_OB_ESTABLISH_TIME` Kill any outbound that takes more than this.
`static long`	`MAX_TAG_VALUE` the relay tag is a 4-byte field in the protocol
`static long`	`OB_MESSAGE_TIMEOUT` Max wait before receiving a response to a single message during outbound establishment

Constructor Summary
Constructors
Constructor and Description
EstablishmentManager(RouterContext ctx, UDPTransport transport)
EstablishmentManager.

Constructors
Constructor and Description
`EstablishmentManager(RouterContext ctx, UDPTransport transport)` EstablishmentManager.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addOutboundToken(RemoteHostId peer, long token, long expires)` Remember a token that can be used later to connect to the peer
`void`	`establish(OutNetMessage msg)` Send the message to its specified recipient by establishing a connection with them and sending it off.
`static int`	`getDefaultHighMaxConcurrentEstablish()` Get the default high max concurrent establish
`static int`	`getDefaultLowMaxConcurrentEstablish()` Get the default low max concurrent establish
`(package private) InboundEstablishState`	`getInboundState(RemoteHostId from)` Grab the active establishing state
`EstablishmentManager.Token`	`getInboundToken(RemoteHostId peer)` Get a token that can be used later for the peer to connect to us
`EstablishmentManager.Token`	`getInboundToken(RemoteHostId peer, long expiration)` Get a token that can be used later for the peer to connect to us.
`static int`	`getMaxQueuedOutbound()`
`DatabaseStoreMessage`	`getOurInfo()` A database store message with our router info
`(package private) OutboundEstablishState`	`getOutboundState(RemoteHostId from)` Grab the active establishing state
`long`	`getOutboundToken(RemoteHostId peer)` Get a token to connect to the peer
`void`	`ipChanged(boolean isIPv6)` Remove our tokens for this length
`boolean`	`isConnecting(Hash dest)` Check if an outbound SSU handshake is in progress for the given peer.
`boolean`	`isInboundTokenValid(RemoteHostId peer, long token)` Is the token from this peer valid?
`(package private) boolean`	`isValid(byte[] ip, int port)` Are IP and port valid? This is only for checking the relay response.
`static String`	`parseReason(int reasonCode)` parseReason.
`void`	`portChanged()` Remove all tokens
`(package private) PeerState`	`receiveData(OutboundEstablishState state)` A data packet arrived on an outbound connection being established, which means its complete (yay!).
`(package private) void`	`receiveHolePunch(RemoteHostId id, UDPPacket packet)` Called from PacketHandler.
`(package private) void`	`receiveRelayResponse(PeerState2 bob, long nonce, int code, byte[] data)` We are Alice, we sent a RelayRequest to Bob and got a RelayResponse back.
`(package private) void`	`receiveRetry(OutboundEstablishState2 state, UDPPacket packet)` Got a Retry (in response to our outbound SessionRequest or TokenRequest) SSU 2 only.
`(package private) void`	`receiveSessionConfirmed(InboundEstablishState2 state, UDPPacket packet)` got a SessionConfirmed (should only happen as part of an inbound establishment) SSU 2 only.
`(package private) void`	`receiveSessionCreated(OutboundEstablishState2 state, UDPPacket packet)` Got a SessionCreated (in response to our outbound SessionRequest) SSU 2 only.
`(package private) void`	`receiveSessionDestroy(RemoteHostId from)` Got a SessionDestroy - maybe during an inbound establish? TODO - PacketHandler won't look up inbound establishes As this packet was essentially unauthenticated (i.e.
`(package private) void`	`receiveSessionDestroy(RemoteHostId from, OutboundEstablishState state)` Got a SessionDestroy during outbound establish SSU 2
`(package private) void`	`receiveSessionDestroy(RemoteHostId from, PeerState state)` Got a SessionDestroy on an established conn SSU 2
`(package private) void`	`receiveSessionOrTokenRequest(RemoteHostId from, InboundEstablishState2 state, UDPPacket packet)` Got a SessionRequest OR a TokenRequest (initiates an inbound establishment) SSU 2 only.
`static void`	`setDefaultHighMaxConcurrentEstablish(int val)` Set the default high max concurrent establish, bounded 64-8192
`static void`	`setDefaultLowMaxConcurrentEstablish(int val)` Set the default low max concurrent establish, bounded 32-4096
`static void`	`setMaxQueuedOutbound(int max)` Set the max queued outbound connections (called by Tuner).
`boolean`	`shouldAllowInboundEstablishment()` Should we allow another inbound establishment?
`void`	`shutdown()` shutdown.
`void`	`startup()` startup.

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

- Field Detail
  - DATA_MESSAGE_TIMEOUT
```
static final AtomicLong DATA_MESSAGE_TIMEOUT
```
    for the DSM and or netdb store
  - IB_TOKEN_EXPIRATION
```
public static final long IB_TOKEN_EXPIRATION
```
    IB_TOKEN_EXPIRATION.
    See Also:
    Constant Field Values
  - MAX_IB_ESTABLISH_TIME
```
static final AtomicLong MAX_IB_ESTABLISH_TIME
```
    Kill any inbound that takes more than this. One round trip (Created-Confirmed), possibly two for SSU2 with retry. Tuned to ~3-5x average establish time; the Tuner further adjusts this at runtime.
  - MAX_OB_ESTABLISH_TIME
```
static final AtomicLong MAX_OB_ESTABLISH_TIME
```
    Kill any outbound that takes more than this. Two round trips (Req-Created-Confirmed-Data) for direct; 3 1/2 round trips (RReq-RResp+Intro-HolePunch-Req-Created-Confirmed-Data) for indirect. Tuned to ~3-5x average establish time; the Tuner further adjusts this at runtime.
  - MAX_TAG_VALUE
```
public static final long MAX_TAG_VALUE
```
    the relay tag is a 4-byte field in the protocol
    See Also:
    Constant Field Values
  - OB_MESSAGE_TIMEOUT
```
public static final long OB_MESSAGE_TIMEOUT
```
    Max wait before receiving a response to a single message during outbound establishment
    See Also:
    Constant Field Values
- Constructor Detail
  - EstablishmentManager
```
public EstablishmentManager(RouterContext ctx,
                            UDPTransport transport)
```
    EstablishmentManager.
- Method Detail
  - addOutboundToken
```
public void addOutboundToken(RemoteHostId peer,
                             long token,
                             long expires)
```
    Remember a token that can be used later to connect to the peer
    Parameters:
    token - nonzero
    expires - absolute time
  - establish
```
public void establish(OutNetMessage msg)
```
    Send the message to its specified recipient by establishing a connection with them and sending it off. This call does not block, and on failure, the message is failed. Note - if we go back to multiple PacketHandler threads, this may need more locking.
  - getDefaultHighMaxConcurrentEstablish
```
public static int getDefaultHighMaxConcurrentEstablish()
```
    Get the default high max concurrent establish
  - getDefaultLowMaxConcurrentEstablish
```
public static int getDefaultLowMaxConcurrentEstablish()
```
    Get the default low max concurrent establish
  - getInboundState
```
InboundEstablishState getInboundState(RemoteHostId from)
```
    Grab the active establishing state
    Returns:
    null if none
  - getInboundToken
```
public EstablishmentManager.Token getInboundToken(RemoteHostId peer)
```
    Get a token that can be used later for the peer to connect to us
    Returns:
    the inbound token
  - getInboundToken
```
public EstablishmentManager.Token getInboundToken(RemoteHostId peer,
                                                  long expiration)
```
    Get a token that can be used later for the peer to connect to us.
    Parameters:
    expiration - time from now, will be reduced if necessary based on cache eviction time.
    Returns:
    non-null
  - getMaxQueuedOutbound
```
public static int getMaxQueuedOutbound()
```
    Returns:
    the current max queued outbound connections
  - getOurInfo
```
public DatabaseStoreMessage getOurInfo()
```
    A database store message with our router info
    Returns:
    non-null
  - getOutboundState
```
OutboundEstablishState getOutboundState(RemoteHostId from)
```
    Grab the active establishing state
    Returns:
    null if none
  - getOutboundToken
```
public long getOutboundToken(RemoteHostId peer)
```
    Get a token to connect to the peer
    Returns:
    0 if none available
  - ipChanged
```
public void ipChanged(boolean isIPv6)
```
    Remove our tokens for this length
  - isConnecting
```
public boolean isConnecting(Hash dest)
```
    Check if an outbound SSU handshake is in progress for the given peer.
    Parameters:
    dest - router hash
    Returns:
    true if we are currently trying to establish an outbound connection
  - isInboundTokenValid
```
public boolean isInboundTokenValid(RemoteHostId peer,
                                   long token)
```
    Is the token from this peer valid?
    Returns:
    valid
  - isValid
```
boolean isValid(byte[] ip,
                int port)
```
    Are IP and port valid? This is only for checking the relay response. Allow IPv6 as of 0.9.50. Refuse anybody in the same /16
  - parseReason
```
public static String parseReason(int reasonCode)
```
    parseReason.
  - portChanged
```
public void portChanged()
```
    Remove all tokens
  - receiveData
```
PeerState receiveData(OutboundEstablishState state)
```
    A data packet arrived on an outbound connection being established, which means its complete (yay!). This is a blocking call, more than I'd like...
    Returns:
    the new PeerState
  - receiveHolePunch
```
void receiveHolePunch(RemoteHostId id,
                      UDPPacket packet)
```
    Called from PacketHandler. Accelerate response to RelayResponse if we haven't sent it yet. SSU 2 only.
    Parameters:
    id - non-null
    packet - header already decrypted
  - receiveRelayResponse
```
void receiveRelayResponse(PeerState2 bob,
                          long nonce,
                          int code,
                          byte[] data)
```
    We are Alice, we sent a RelayRequest to Bob and got a RelayResponse back. Time and version already checked by caller. SSU 2 only.
    Parameters:
    data - including nonce, including token if code == 0
  - receiveRetry
```
void receiveRetry(OutboundEstablishState2 state,
                  UDPPacket packet)
```
    Got a Retry (in response to our outbound SessionRequest or TokenRequest) SSU 2 only.
  - receiveSessionConfirmed
```
void receiveSessionConfirmed(InboundEstablishState2 state,
                             UDPPacket packet)
```
    got a SessionConfirmed (should only happen as part of an inbound establishment) SSU 2 only.
    Parameters:
    state - non-null
    packet - header decrypted only
  - receiveSessionCreated
```
void receiveSessionCreated(OutboundEstablishState2 state,
                           UDPPacket packet)
```
    Got a SessionCreated (in response to our outbound SessionRequest) SSU 2 only.
    Parameters:
    state - non-null
    packet - header decrypted only
  - receiveSessionDestroy
```
void receiveSessionDestroy(RemoteHostId from)
```
    Got a SessionDestroy - maybe during an inbound establish? TODO - PacketHandler won't look up inbound establishes As this packet was essentially unauthenticated (i.e. intro key, not session key) we just log it as it could be spoofed. SSU 2
  - receiveSessionDestroy
```
void receiveSessionDestroy(RemoteHostId from,
                           OutboundEstablishState state)
```
    Got a SessionDestroy during outbound establish SSU 2
  - receiveSessionDestroy
```
void receiveSessionDestroy(RemoteHostId from,
                           PeerState state)
```
    Got a SessionDestroy on an established conn SSU 2
  - receiveSessionOrTokenRequest
```
void receiveSessionOrTokenRequest(RemoteHostId from,
                                  InboundEstablishState2 state,
                                  UDPPacket packet)
```
    Got a SessionRequest OR a TokenRequest (initiates an inbound establishment) SSU 2 only.
    Parameters:
    state - as looked up in PacketHandler, but null unless retransmitted or retry sent
    packet - header decrypted only
  - setDefaultHighMaxConcurrentEstablish
```
public static void setDefaultHighMaxConcurrentEstablish(int val)
```
    Set the default high max concurrent establish, bounded 64-8192
  - setDefaultLowMaxConcurrentEstablish
```
public static void setDefaultLowMaxConcurrentEstablish(int val)
```
    Set the default low max concurrent establish, bounded 32-4096
  - setMaxQueuedOutbound
```
public static void setMaxQueuedOutbound(int max)
```
    Set the max queued outbound connections (called by Tuner).
  - shouldAllowInboundEstablishment
```
public boolean shouldAllowInboundEstablishment()
```
    Should we allow another inbound establishment?
    Returns:
    whether allow inbound establishment
  - shutdown
```
public void shutdown()
```
    shutdown.
  - startup
```
public void startup()
```
    startup.

Class EstablishmentManager

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DATA_MESSAGE_TIMEOUT

IB_TOKEN_EXPIRATION

MAX_IB_ESTABLISH_TIME

MAX_OB_ESTABLISH_TIME

MAX_TAG_VALUE

OB_MESSAGE_TIMEOUT

Constructor Detail

EstablishmentManager

Method Detail

addOutboundToken

establish

getDefaultHighMaxConcurrentEstablish

getDefaultLowMaxConcurrentEstablish

getInboundState

getInboundToken

getInboundToken

getMaxQueuedOutbound

getOurInfo

getOutboundState

getOutboundToken

ipChanged

isConnecting

isInboundTokenValid

isValid

parseReason

portChanged

receiveData

receiveHolePunch

receiveRelayResponse

receiveRetry

receiveSessionConfirmed

receiveSessionCreated

receiveSessionDestroy

receiveSessionDestroy

receiveSessionDestroy

receiveSessionOrTokenRequest

setDefaultHighMaxConcurrentEstablish

setDefaultLowMaxConcurrentEstablish

setMaxQueuedOutbound

shouldAllowInboundEstablishment

shutdown

startup