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.