Package net.i2p.router.transport.udp

Class PacketBuilder2

  • class PacketBuilder2
extends Object
    SSU2 only
    Since:
    0.9.54

    • Constructor Detail

      • PacketBuilder2

        public PacketBuilder2​(RouterContext ctx,
                      UDPTransport transport)
        No state, all methods are thread-safe.
        Parameters:
        transport - may be null for unit testing only

    • Method Detail

      • getMaxAdditionalFragmentSize

        public static int getMaxAdditionalFragmentSize​(PeerState peer,
                                               int numFragments,
                                               int curDataSize)
        Will a packet to 'peer' that already has 'numFragments' fragments totalling 'curDataSize' bytes fit another fragment? This includes the 3 byte block overhead, but NOT the 5 byte followon fragment overhead. This doesn't leave anything for acks or anything else.
        Parameters:
        numFragments - >= 1
        Returns:
        max additional fragment size

      • buildPacket

        public UDPPacket buildPacket​(OutboundMessageState state,
                             int fragment,
                             PeerState2 peer)
                      throws IOException
        This builds a data packet (PAYLOAD_TYPE_DATA). See the methods below for the other message types. Note that while the UDP message spec allows for more than one fragment in a message, this method writes exactly one fragment. For no fragments use buildAck().
        Throws:
        IOException - if peer is dead

      • buildACK

        public UDPPacket buildACK​(PeerState2 peer)
                   throws IOException
        Build the ack packet. An ack packet is just a data packet with no data. See buildPacket() for format.
        Throws:
        IOException - if peer is dead

      • buildSessionDestroyPacket

        public UDPPacket buildSessionDestroyPacket​(int reason,
                                           SSU2Sender peer)
                                    throws IOException
        Build a data packet with a termination block. This will also include acks, a new token block, and padding.
        Throws:
        IOException - if peer is dead

      • buildTokenRequestPacket

        public UDPPacket buildTokenRequestPacket​(OutboundEstablishState2 state)
        Build a new SessionRequest packet for the given peer, encrypting it as necessary.
        Returns:
        ready to send packet, non-null

      • buildSessionRequestPacket

        public UDPPacket buildSessionRequestPacket​(OutboundEstablishState2 state)
        Build a new SessionRequest packet for the given peer, encrypting it as necessary.
        Returns:
        ready to send packet, non-null

      • buildSessionCreatedPacket

        public UDPPacket buildSessionCreatedPacket​(InboundEstablishState2 state)
        Build a new SessionCreated packet for the given peer, encrypting it as necessary.
        Returns:
        ready to send packet, non-null

      • buildRetryPacket

        public UDPPacket buildRetryPacket​(InboundEstablishState2 state,
                                  int terminationCode)
        Build a new Retry packet for the given peer, encrypting it as necessary.
        Parameters:
        terminationCode - 0 normally, nonzero to send termination block
        Returns:
        ready to send packet, non-null

      • buildRetryPacket

        public UDPPacket buildRetryPacket​(RemoteHostId to,
                                  SocketAddress toAddr,
                                  long destID,
                                  long srcID,
                                  int terminationCode)
        Build a new Retry packet with a termination code, for a rejection direct from the EstablishmentManager. No InboundEstablishState2 required.
        Parameters:
        terminationCode - must be greater than zero
        Returns:
        ready to send packet, non-null
        Since:
        0.9.57

      • buildSessionConfirmedPackets

        public UDPPacket[] buildSessionConfirmedPackets​(OutboundEstablishState2 state,
                                                RouterInfo ourInfo)
        Build a new series of SessionConfirmed packets for the given peer, encrypting it as necessary. If the RI is large enough that it is fragmented, this will still only return a single Session Confirmed message. The remaining RI blocks will be passed to the establish state via confirmedPacketsSent(), and the state will transmit them via the new PeerState2.
        Returns:
        ready to send packets, non-null

      • buildPeerTestFromAlice

        public UDPPacket buildPeerTestFromAlice​(byte[] signedData,
                                        PeerState2 bob)
                                 throws IOException
        Build a packet as Alice, to Bob to begin a peer test. In-session, message 1.
        Returns:
        ready to send packet, non-null
        Throws:
        IOException - if peer is dead

      • buildPeerTestFromAlice

        public UDPPacket buildPeerTestFromAlice​(InetAddress toIP,
                                        int toPort,
                                        SessionKey introKey,
                                        long sendID,
                                        long rcvID,
                                        byte[] signedData)
        Build a packet as Alice to Charlie. Out-of-session, message 6.
        Returns:
        ready to send packet, non-null

      • buildPeerTestToAlice

        public UDPPacket buildPeerTestToAlice​(int code,
                                      Hash charlieHash,
                                      byte[] signedData,
                                      PeerState2 alice)
                               throws IOException
        Build a packet as Bob to Alice, with the response from Charlie, or a rejection by Bob. In-session, message 4.
        Parameters:
        charlieHash - fake hash (all zeros) if rejected by bob
        Returns:
        ready to send packet, non-null
        Throws:
        IOException - if peer is dead

      • buildPeerTestToAlice

        public UDPPacket buildPeerTestToAlice​(int code,
                                      Hash charlieHash,
                                      byte[] signedData,
                                      SSU2Payload.Block riBlock,
                                      PeerState2 alice)
                               throws IOException
        Build a packet as Bob to Alice, with the response from Charlie, or a rejection by Bob. In-session, message 4.
        Parameters:
        charlieHash - fake hash (all zeros) if rejected by bob
        riBlock - to include, may be null
        Returns:
        ready to send packet, non-null
        Throws:
        IOException - if peer is dead
        Since:
        0.9.57

      • buildPeerTestToAlice

        public UDPPacket buildPeerTestToAlice​(InetAddress aliceIP,
                                      int alicePort,
                                      SessionKey introKey,
                                      boolean firstSend,
                                      long sendID,
                                      long rcvID,
                                      byte[] signedData)
        Build a packet as Charlie to Alice. Out-of-session, messages 5 and 7.
        Returns:
        ready to send packet, non-null

      • buildPeerTestToCharlie

        public UDPPacket buildPeerTestToCharlie​(Hash aliceHash,
                                        byte[] signedData,
                                        SSU2Payload.Block riBlock,
                                        PeerState2 charlie)
                                 throws IOException
        Build a packet as Bob to Charlie to help test Alice. In-session, message 2.
        Parameters:
        riBlock - to include, may be null
        Returns:
        ready to send packet, non-null
        Throws:
        IOException - if peer is dead

      • buildPeerTestToBob

        public UDPPacket buildPeerTestToBob​(int code,
                                    byte[] signedData,
                                    PeerState2 bob)
                             throws IOException
        Build a packet as Charlie to Bob verifying that we will help test Alice. In-session, message 3.
        Returns:
        ready to send packet, non-null
        Throws:
        IOException - if peer is dead

      • buildRelayRequest

        UDPPacket buildRelayRequest​(byte[] signedData,
                            PeerState2 bob)
                     throws IOException
        From Alice to Bob. In-session.
        Parameters:
        signedData - flag + signed data
        Returns:
        non-null
        Throws:
        IOException - if peer is dead

      • buildRelayIntro

        UDPPacket buildRelayIntro​(byte[] signedData,
                          SSU2Payload.Block riBlock,
                          PeerState2 charlie)
                   throws IOException
        From Bob to Charlie. In-session.
        Parameters:
        signedData - flag + alice hash + signed data
        riBlock - to include, may be null
        Returns:
        non-null
        Throws:
        IOException - if peer is dead

      • buildRelayResponse

        UDPPacket buildRelayResponse​(byte[] signedData,
                             PeerState2 state)
                      throws IOException
        From Charlie to Bob or Bob to Alice. In-session.
        Parameters:
        signedData - flag + response code + signed data + optional token
        state - Alice or Bob
        Returns:
        non-null
        Throws:
        IOException - if peer is dead

      • buildHolePunch

        public UDPPacket buildHolePunch​(InetAddress to,
                                int port,
                                SessionKey introKey,
                                long sendID,
                                long rcvID,
                                byte[] signedData)
        Out-of-session, containing a RelayResponse block.