## 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
`static interface` `I2NPMessageImpl.Builder` interface for extending the types of messages handled - unused

Field Summary
`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
`I2NPMessageImpl(I2PAppContext context)`

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