net.i2p.router.transport.udp

## Class InboundEstablishState2

- 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`