java.lang.Object
net.i2p.router.tunnel.TrivialPreprocessor
All Implemented Interfaces:
TunnelGateway.QueuePreprocessor
Direct Known Subclasses:
BatchedPreprocessor
class TrivialPreprocessorextends Object implements TunnelGateway.QueuePreprocessor
Do the simplest thing possible for preprocessing - for each message available, turn it into the minimum number of fragmented preprocessed blocks, sending each of those out. This does not coalesce message fragments or delay for more optimal throughput.

See FragmentHandler Javadoc for tunnel message fragment format

Not instantiated directly except in unit tests; see BatchedPreprocessor.

  • Field Details

    • _context

      protected final RouterContext _context
      The router context.

    • _log

      protected final Log _log
      The logger.

    • PREPROCESSED_SIZE

      public static final int PREPROCESSED_SIZE
      Size of preprocessed data blocks.
      See Also:

    • IV_SIZE

      protected static final int IV_SIZE
      Length of the IV.
      See Also:

    • _dataCache

      protected static final ByteCache _dataCache
      Here in tunnels, we take from the cache but never add to it. In other words, we take advantage of other places in the router also using 1024-byte ByteCaches (since ByteCache only maintains once instance for each size) Used in BatchedPreprocessor; see add'l comments there.

    • MASK_IS_SUBSEQUENT

      private static final byte MASK_IS_SUBSEQUENT
      Is this a follow-up byte?
      See Also:

    • MASK_FRAGMENTED

      private static final byte MASK_FRAGMENTED
      Is this the first fragment of a fragmented message?
      See Also:

    • MASK_TUNNEL

      private static final byte MASK_TUNNEL
      Type bits of a tunnel fragment
      See Also:

    • MASK_ROUTER

      private static final byte MASK_ROUTER
      Type bits of a router fragment
      See Also:

  • Constructor Details

    • TrivialPreprocessor

      public TrivialPreprocessor(RouterContext ctx)
      Binds the router context and initializes the log.
      Parameters:
      ctx - the router context

  • Method Details

    • getDelayAmount

      public long getDelayAmount()
      How long to wait before flushing.
      Specified by:
      getDelayAmount in interface TunnelGateway.QueuePreprocessor
      Returns:
      delay in milliseconds

    • preprocessQueue

      public boolean preprocessQueue(List<PendingGatewayMessage> pending, TunnelGateway.Sender sender, TunnelGateway.Receiver rec)
      Return true if there were messages remaining, and we should queue up a delayed flush to clear them

      NOTE: Unused here, see BatchedPreprocessor override, super is not called.

      Specified by:
      preprocessQueue in interface TunnelGateway.QueuePreprocessor
      Parameters:
      pending - list of Pending objects for messages either unsent or partly sent. This list should be update with any values removed (the preprocessor owns the lock) Messages are not removed from the list until actually sent. The status of unsent and partially-sent messages is stored in the Pending structure.
      sender - the sender to hand the encrypted data to
      rec - the receiver to accept encrypted data
      Returns:
      true if we should delay before preprocessing again

    • notePreprocessing

      protected void notePreprocessing(long messageId, int numFragments, int totalLength, List<Long> messageIds, String msg)
      Note preprocessing statistics. No-op - intentionally empty.
      Parameters:
      messageId - the message this fragment carries data for
      numFragments - the fragment number within that message
      totalLength - the total length of the message the fragment belongs to
      messageIds - the message ids of everything coalesced into this fragment
      msg - a description of the flush event, for debugging output

    • preprocess

      protected void preprocess(byte[] fragments, int fragmentLength)
      Wrap the preprocessed fragments with the necessary padding / checksums to act as a tunnel message.
      Parameters:
      fragments - the fragment data
      fragmentLength - fragments[0:fragmentLength] is used

    • fillRandomNonZero

      private void fillRandomNonZero(byte[] b, int off, int len)
      Efficiently fill with nonzero random data Don't waste too much entropy or call random() too often.
      Parameters:
      b - the buffer to fill
      off - the index in b of the first byte to fill
      len - the number of bytes to fill, none of which will be zero

    • writeFirstFragment

      protected int writeFirstFragment(PendingGatewayMessage msg, byte[] target, int offset)
      Write the first fragment of a tunnel message.
      Parameters:
      msg - the pending gateway message
      target - the buffer to write the control byte and fragment body into
      offset - the starting offset
      Returns:
      the new offset after writing

    • writeSubsequentFragment

      protected int writeSubsequentFragment(PendingGatewayMessage msg, byte[] target, int offset)
      Write a subsequent fragment of a tunnel message.
      Parameters:
      msg - the pending gateway message
      target - the buffer to write the control byte and fragment body into
      offset - the starting offset
      Returns:
      the new offset after writing

    • getInstructionsSize

      protected static int getInstructionsSize(PendingGatewayMessage msg)
      Calculate the size of the instructions for a pending message. Does NOT include 4 for the message ID if the message will be fragmented; call getInstructionAugmentationSize(PendingGatewayMessage, int, int) for that.
      Parameters:
      msg - the pending gateway message
      Returns:
      generally 3 or 35 or 39 for first fragment, 7 for subsequent fragments.

    • getInstructionAugmentationSize

      protected static int getInstructionAugmentationSize(PendingGatewayMessage msg, int offset, int instructionsSize)
      Get the augmentation size for instructions if fragmentation is needed.
      Parameters:
      msg - the pending gateway message
      offset - the current offset
      instructionsSize - the current instructions size
      Returns:
      0 or 4