net.i2p.data.i2np

## Class I2NPMessageImpl

- java.lang.Object
- - net.i2p.data.DataStructureImpl
  - - net.i2p.data.i2np.I2NPMessageImpl

- All Implemented Interfaces:
    DataStructure, I2NPMessage
  Direct Known Subclasses:
    DatabaseLookupMessage, DatabaseSearchReplyMessage, DatabaseStoreMessage, DataMessage, DeliveryStatusMessage, GarlicMessage, TunnelBuildMessage, TunnelBuildReplyMessage, TunnelDataMessage, TunnelGatewayMessage, UnknownI2NPMessage

      public abstract class I2NPMessageImpl
      extends DataStructureImpl
      implements I2NPMessage

  Defines the base message implementation.
  Author:
    jrandom

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static interface` | `I2NPMessageImpl.Builder` interface for extending the types of messages handled - unused

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected I2PAppContext` | `_context`
    `static int` | `CHECKSUM_LENGTH`
    `static long` | `DEFAULT_EXPIRATION_MS`

    - ### Fields inherited from interface net.i2p.data.i2np.I2NPMessage

      `MAX_ID_VALUE, MAX_SIZE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `I2NPMessageImpl(I2PAppContext context)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected abstract int` | `calculateWrittenLength()` calculate the message body's length (not including the header and footer
    `static I2NPMessage` | `createMessage(I2PAppContext context, int type)` Yes, this is fairly ugly, but its the only place it ever happens.
    `static I2NPMessage` | `fromRawByteArray(I2PAppContext ctx, byte[] buffer, int offset, int len, I2NPMessageHandler handler)` used by SSU only
    `long` | `getMessageExpiration()` Date after which the message should be dropped (and the associated uniqueId forgotten)
    `int` | `getMessageSize()` How large the message is, including any checksums
    `int` | `getRawMessageSize()` How large the raw message is
    `long` | `getUniqueId()` Replay resistent message Id
    `int` | `readBytes(byte[] data, int type, int offset)` Read the header, then read the rest into buffer, then call readMessage in the implemented message type
    `void` | `readBytes(InputStream in)` Deprecated. Unused, why would you do this
    `int` | `readBytes(InputStream in, int type, byte[] buffer)` Read the header, then read the rest into buffer, then call readMessage in the implemented message type
    `void` | `readMessage(byte[] data, int offset, int dataSize, int type, I2NPMessageHandler handler)`
    `static void` | `registerBuilder(I2NPMessageImpl.Builder builder, int type)` Deprecated. unused
    `void` | `setMessageExpiration(long exp)`
    `void` | `setUniqueId(long id)`
    `byte[]` | `toByteArray()`
    `int` | `toByteArray(byte[] buffer)` write the message to the buffer, returning the number of bytes written.
    `int` | `toRawByteArray(byte[] buffer)` used by SSU only
    `void` | `writeBytes(OutputStream out)` Write out the data structure to the stream, using the format defined in the I2P data structure specification.
    `protected abstract int` | `writeMessageBody(byte[] out, int curIndex)` write the message body to the output array, starting at the given index.

    - ### Methods inherited from class net.i2p.data.DataStructureImpl

      `calculateHash, fromBase64, fromByteArray, read, toBase64`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface net.i2p.data.i2np.I2NPMessage

      `getType, readMessage`

    - ### Methods inherited from interface net.i2p.data.DataStructure

      `calculateHash, fromBase64, fromByteArray, toBase64`

- - ### Field Detail

    - #### _context

          protected I2PAppContext _context

    - #### DEFAULT_EXPIRATION_MS

          public static final long DEFAULT_EXPIRATION_MS

      See Also:
        Constant Field Values

    - #### CHECKSUM_LENGTH

          public static final int CHECKSUM_LENGTH

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### I2NPMessageImpl

          public I2NPMessageImpl(I2PAppContext context)

  - ### Method Detail

    - #### registerBuilder

          public static final void registerBuilder(I2NPMessageImpl.Builder builder,
                             int type)

      Deprecated. unused

    - #### readBytes

          public void readBytes(InputStream in)
                         throws DataFormatException,
                                IOException

      Deprecated. Unused, why would you do this
      Read the whole message (including the type) and throw it away.
      Specified by:
        `readBytes` in interface `DataStructure`
      Parameters:
        `in` - stream to read from
      Throws:
        `DataFormatException` - if the data is improperly formatted
        `IOException` - if there was a problem reading the stream

    - #### readBytes

          public int readBytes(InputStream in,
                      int type,
                      byte[] buffer)
                        throws I2NPMessageException,
                               IOException

      Read the header, then read the rest into buffer, then call readMessage in the implemented message type

            Specifically:
              1 byte type (if caller didn't read already, as specified by the type param
              4 byte ID
              8 byte expiration
              2 byte size
              1 byte checksum
              size bytes of payload (read by readMessage() in implementation)

      Specified by:
        `readBytes` in interface `I2NPMessage`
      Parameters:
        `type` - the message type or -1 if we should read it here
        `buffer` - temp buffer to use
        `in` - stream to read from
      Returns:
        total length of the message
      Throws:
        `I2NPMessageException` - if the stream doesn't contain a valid message that this class can read.
        `IOException` - if there is a problem reading from the stream

    - #### readBytes

          public int readBytes(byte[] data,
                      int type,
                      int offset)
                        throws I2NPMessageException,
                               IOException

      Read the header, then read the rest into buffer, then call readMessage in the implemented message type

            Specifically:
              1 byte type (if caller didn't read already, as specified by the type param
              4 byte ID
              8 byte expiration
              2 byte size
              1 byte checksum
              size bytes of payload (read by readMessage() in implementation)

      Specified by:
        `readBytes` in interface `I2NPMessage`
      Parameters:
        `type` - the message type or -1 if we should read it here
      Returns:
        total length of the message
      Throws:
        `I2NPMessageException`
        `IOException`

    - #### writeBytes

          public void writeBytes(OutputStream out)
                          throws DataFormatException,
                                 IOException

      Description copied from interface: `DataStructure`
      Write out the data structure to the stream, using the format defined in the I2P data structure specification.
      Specified by:
        `writeBytes` in interface `DataStructure`
      Parameters:
        `out` - stream to write to
      Throws:
        `DataFormatException` - if the data was incomplete or not yet ready to be written
        `IOException` - if there was a problem writing to the stream

    - #### getUniqueId

          public long getUniqueId()

      Replay resistent message Id
      Specified by:
        `getUniqueId` in interface `I2NPMessage`

    - #### setUniqueId

          public void setUniqueId(long id)

      Specified by:
        `setUniqueId` in interface `I2NPMessage`

    - #### getMessageExpiration

          public long getMessageExpiration()

      Date after which the message should be dropped (and the associated uniqueId forgotten)
      Specified by:
        `getMessageExpiration` in interface `I2NPMessage`

    - #### setMessageExpiration

          public void setMessageExpiration(long exp)

      Specified by:
        `setMessageExpiration` in interface `I2NPMessage`

    - #### getMessageSize

          public int getMessageSize()

      Description copied from interface: `I2NPMessage`
      How large the message is, including any checksums
      Specified by:
        `getMessageSize` in interface `I2NPMessage`

    - #### getRawMessageSize

          public int getRawMessageSize()

      Description copied from interface: `I2NPMessage`
      How large the raw message is
      Specified by:
        `getRawMessageSize` in interface `I2NPMessage`

    - #### toByteArray

          public byte[] toByteArray()

      Specified by:
        `toByteArray` in interface `DataStructure`
      Overrides:
        `toByteArray` in class `DataStructureImpl`

    - #### toByteArray

          public int toByteArray(byte[] buffer)

      Description copied from interface: `I2NPMessage`
      write the message to the buffer, returning the number of bytes written. the data is formatted so as to be self contained, with the type, size, expiration, unique id, as well as a checksum bundled along.
      Specified by:
        `toByteArray` in interface `I2NPMessage`

    - #### calculateWrittenLength

          protected abstract int calculateWrittenLength()

      calculate the message body's length (not including the header and footer

    - #### writeMessageBody

          protected abstract int writeMessageBody(byte[] out,
                             int curIndex)
                                           throws I2NPMessageException

      write the message body to the output array, starting at the given index.
      Returns:
        the index into the array after the last byte written
      Throws:
        `I2NPMessageException`

    - #### toRawByteArray

          public int toRawByteArray(byte[] buffer)

      used by SSU only
      Specified by:
        `toRawByteArray` in interface `I2NPMessage`

    - #### readMessage

          public void readMessage(byte[] data,
                         int offset,
                         int dataSize,
                         int type,
                         I2NPMessageHandler handler)
                           throws I2NPMessageException,
                                  IOException

      Specified by:
        `readMessage` in interface `I2NPMessage`
      Throws:
        `I2NPMessageException`
        `IOException`

    - #### fromRawByteArray

          public static I2NPMessage fromRawByteArray(I2PAppContext ctx,
                                     byte[] buffer,
                                     int offset,
                                     int len,
                                     I2NPMessageHandler handler)
                                              throws I2NPMessageException

      used by SSU only
      Throws:
        `I2NPMessageException`

    - #### createMessage

          public static I2NPMessage createMessage(I2PAppContext context,
                                  int type)
                                           throws I2NPMessageException

      Yes, this is fairly ugly, but its the only place it ever happens.
      Throws:
        `I2NPMessageException`