Class BufferUtils

java.lang.Object
org.apache.sshd.common.util.buffer.BufferUtils

public final class BufferUtils extends Object
General utilities for working with byte-encoded data.
  • Field Details

    • DEFAULT_HEX_SEPARATOR

      public static final char DEFAULT_HEX_SEPARATOR
      See Also:
    • EMPTY_HEX_SEPARATOR

      public static final char EMPTY_HEX_SEPARATOR
      See Also:
    • HEX_DIGITS

      public static final String HEX_DIGITS
      See Also:
    • DEFAULT_HEXDUMP_LEVEL

      public static final Level DEFAULT_HEXDUMP_LEVEL
    • DEFAULT_BUFFER_GROWTH_FACTOR

      public static final IntUnaryOperator DEFAULT_BUFFER_GROWTH_FACTOR
    • MAX_UINT32_VALUE

      public static final long MAX_UINT32_VALUE
      Maximum value of a uint32 field
      See Also:
    • MAX_UINT8_VALUE

      public static final int MAX_UINT8_VALUE
      Maximum value of a uint8 field
      See Also:
  • Constructor Details

    • BufferUtils

      private BufferUtils()
      Private Constructor
  • Method Details

    • indexOf

      public static int indexOf(byte[] array, byte valueToFind, int startIndex, int len)

      Finds the index of the given value in the array starting at the given index and checking up to specified number of elements.

      This method returns -1) for a null input array.

      A negative startIndex is treated as zero. A startIndex larger than the array length will return -1.

      Parameters:
      array - the array to search through for the object, may be null
      valueToFind - the value to find
      startIndex - the index to start searching at
      len - the number of elements to search from the start index
      Returns:
      the index of the value within the array, -1 if not found or null array input or non-positive number of elements
    • dumpHex

      public static void dumpHex(SimplifiedLog logger, Level level, String prefix, PropertyResolver resolver, char sep, byte... data)
    • dumpHex

      public static void dumpHex(SimplifiedLog logger, Level level, String prefix, PropertyResolver resolver, char sep, byte[] data, int offset, int len)
    • dumpHex

      public static void dumpHex(SimplifiedLog logger, Level level, String prefix, char sep, int chunkSize, byte... data)
    • dumpHex

      public static void dumpHex(SimplifiedLog logger, Level level, String prefix, char sep, int chunkSize, byte[] data, int offset, int len)
    • toHex

      public static String toHex(byte... array)
    • toHex

      public static String toHex(char sep, byte... array)
    • toHex

      public static String toHex(byte[] array, int offset, int len)
    • toHex

      public static String toHex(byte[] array, int offset, int len, char sep)
    • appendHex

      public static <A extends Appendable> A appendHex(A sb, char sep, byte... array) throws IOException
      Throws:
      IOException
    • appendHex

      public static <A extends Appendable> A appendHex(A sb, byte[] array, int offset, int len, char sep) throws IOException
      Throws:
      IOException
    • decodeHex

      public static byte[] decodeHex(char separator, CharSequence csq)
      Parameters:
      separator - The separator between the HEX values - may be EMPTY_HEX_SEPARATOR
      csq - The CharSequence containing the HEX encoded bytes
      Returns:
      The decoded bytes
      Throws:
      IllegalArgumentException - If invalid HEX sequence length
      NumberFormatException - If invalid HEX characters found
      See Also:
    • decodeHex

      public static byte[] decodeHex(char separator, CharSequence csq, int start, int end)
      Parameters:
      separator - The separator between the HEX values - may be EMPTY_HEX_SEPARATOR
      csq - The CharSequence containing the HEX encoded bytes
      start - Start offset of the HEX sequence (inclusive)
      end - End offset of the HEX sequence (exclusive)
      Returns:
      The decoded bytes
      Throws:
      IllegalArgumentException - If invalid HEX sequence length
      NumberFormatException - If invalid HEX characters found
    • decodeHex

      public static <S extends OutputStream> int decodeHex(S stream, char separator, CharSequence csq) throws IOException
      Type Parameters:
      S - The OutputStream generic type
      Parameters:
      stream - The target OutputStream
      separator - The separator between the HEX values - may be EMPTY_HEX_SEPARATOR
      csq - The CharSequence containing the HEX encoded bytes
      Returns:
      The number of bytes written to the stream
      Throws:
      IOException - If failed to write
      IllegalArgumentException - If invalid HEX sequence length
      NumberFormatException - If invalid HEX characters found
      See Also:
    • decodeHex

      public static <S extends OutputStream> int decodeHex(S stream, char separator, CharSequence csq, int start, int end) throws IOException
      Type Parameters:
      S - The OutputStream generic type
      Parameters:
      stream - The target OutputStream
      separator - The separator between the HEX values - may be EMPTY_HEX_SEPARATOR
      csq - The CharSequence containing the HEX encoded bytes
      start - Start offset of the HEX sequence (inclusive)
      end - End offset of the HEX sequence (exclusive)
      Returns:
      The number of bytes written to the stream
      Throws:
      IOException - If failed to write
      IllegalArgumentException - If invalid HEX sequence length
      NumberFormatException - If invalid HEX characters found
    • fromHex

      public static byte fromHex(char hi, char lo) throws NumberFormatException
      Throws:
      NumberFormatException
    • readInt

      public static int readInt(InputStream input, byte[] buf) throws IOException
      Read a 32-bit value in network order
      Parameters:
      input - The InputStream
      buf - Work buffer to use
      Returns:
      The read 32-bit value
      Throws:
      IOException - If failed to read 4 bytes or not enough room in work buffer
      See Also:
    • readInt

      public static int readInt(InputStream input, byte[] buf, int offset, int len) throws IOException
      Read a 32-bit value in network order
      Parameters:
      input - The InputStream
      buf - Work buffer to use
      offset - Offset in buffer to us
      len - Available length - must have at least 4 bytes available
      Returns:
      The read 32-bit value
      Throws:
      IOException - If failed to read 4 bytes or not enough room in work buffer
      See Also:
    • readUInt

      public static long readUInt(InputStream input, byte[] buf) throws IOException
      Read a 32-bit value in network order
      Parameters:
      input - The InputStream
      buf - Work buffer to use
      Returns:
      The read 32-bit value
      Throws:
      IOException - If failed to read 4 bytes or not enough room in work buffer
      See Also:
    • readUInt

      public static long readUInt(InputStream input, byte[] buf, int offset, int len) throws IOException
      Read a 32-bit value in network order
      Parameters:
      input - The InputStream
      buf - Work buffer to use
      offset - Offset in buffer to us
      len - Available length - must have at least 4 bytes available
      Returns:
      The read 32-bit value
      Throws:
      IOException - If failed to read 4 bytes or not enough room in work buffer
      See Also:
    • getInt

      public static int getInt(byte[] buf, int off, int len)
      Parameters:
      buf - A buffer holding a 32-bit signed integer in big endian format.
      off - The offset of the data in the buffer
      len - The available data length. Note: if more than 4 bytes are available, then only the first 4 bytes in the buffer will be used (starting at the specified offset)
      Returns:
      The integer value read
    • getUInt

      public static long getUInt(byte... buf)
      Parameters:
      buf - A buffer holding a 32-bit unsigned integer in big endian format. Note: if more than 4 bytes are available, then only the first 4 bytes in the buffer will be used
      Returns:
      The result as a long whose 32 high-order bits are zero
      See Also:
    • getUInt

      public static long getUInt(byte[] buf, int off, int len)
      Parameters:
      buf - A buffer holding a 32-bit unsigned integer in big endian format.
      off - The offset of the data in the buffer
      len - The available data length. Note: if more than 4 bytes are available, then only the first 4 bytes in the buffer will be used (starting at the specified offset)
      Returns:
      The result as a long whose 32 high-order bits are zero
    • getLong

      public static long getLong(byte[] buf, int off, int len)
    • fromMPIntBytes

      public static BigInteger fromMPIntBytes(byte[] mpInt)
    • writeInt

      public static void writeInt(OutputStream output, int value, byte[] buf) throws IOException
      Writes a 32-bit value in network order (i.e., MSB 1st)
      Parameters:
      output - The OutputStream to write the value
      value - The 32-bit value
      buf - A work buffer to use - must have enough space to contain 4 bytes
      Throws:
      IOException - If failed to write the value or work buffer too small
      See Also:
    • writeInt

      public static void writeInt(OutputStream output, int value, byte[] buf, int off, int len) throws IOException
      Writes a 32-bit value in network order (i.e., MSB 1st)
      Parameters:
      output - The OutputStream to write the value
      value - The 32-bit value
      buf - A work buffer to use - must have enough space to contain 4 bytes
      off - The offset to write the value
      len - The available space
      Throws:
      IOException - If failed to write the value or work buffer too small
      See Also:
    • writeUInt

      public static void writeUInt(OutputStream output, long value, byte[] buf) throws IOException
      Writes a 32-bit value in network order (i.e., MSB 1st)
      Parameters:
      output - The OutputStream to write the value
      value - The 32-bit value
      buf - A work buffer to use - must have enough space to contain 4 bytes
      Throws:
      IOException - If failed to write the value or work buffer too small
      See Also:
    • writeUInt

      public static void writeUInt(OutputStream output, long value, byte[] buf, int off, int len) throws IOException
      Writes a 32-bit value in network order (i.e., MSB 1st)
      Parameters:
      output - The OutputStream to write the value
      value - The 32-bit value
      buf - A work buffer to use - must have enough space to contain 4 bytes
      off - The offset to write the value
      len - The available space
      Throws:
      IOException - If failed to write the value or work buffer to small
      See Also:
    • putUInt

      public static int putUInt(long value, byte[] buf)
      Writes a 32-bit value in network order (i.e., MSB 1st)
      Parameters:
      value - The 32-bit value
      buf - The buffer
      Returns:
      The number of bytes used in the buffer
      Throws:
      IllegalArgumentException - if not enough space available
      See Also:
    • putUInt

      public static int putUInt(long value, byte[] buf, int off, int len)
      Writes a 32-bit value in network order (i.e., MSB 1st)
      Parameters:
      value - The 32-bit value
      buf - The buffer
      off - The offset to write the value
      len - The available space
      Returns:
      The number of bytes used in the buffer
      Throws:
      IllegalArgumentException - if not enough space available
    • putLong

      public static int putLong(long value, byte[] buf, int off, int len)
    • equals

      public static boolean equals(byte[] a1, byte[] a2)
      Compares the contents of 2 arrays of bytes - Note: do not use it to execute security related comparisons (e.g. MACs) since the method leaks timing information. Use Mac#equals method instead.
      Parameters:
      a1 - 1st array
      a2 - 2nd array
      Returns:
      true if all bytes in the compared arrays are equal
    • equals

      public static boolean equals(byte[] a1, int a1Offset, byte[] a2, int a2Offset, int length)
      Compares the contents of 2 arrays of bytes - Note: do not use it to execute security related comparisons (e.g. MACs) since the method leaks timing information. Use Mac#equals method instead.
      Parameters:
      a1 - 1st array
      a1Offset - Offset to start comparing in 1st array
      a2 - 2nd array
      a2Offset - Offset to start comparing in 2nd array
      length - Number of bytes to compare
      Returns:
      true if all bytes in the compared arrays are equal when compared from the specified offsets and up to specified length
    • getNextPowerOf2

      public static int getNextPowerOf2(int value)
    • updateLengthPlaceholder

      public static int updateLengthPlaceholder(Buffer buffer, int lenPos)
      Used for encodings where we don't know the data length before adding it to the buffer. The idea is to place a 32-bit "placeholder", encode the data and then return back to the placeholder and update the length. The method calculates the encoded data length, moves the write position to the specified placeholder position, updates the length value and then moves the write position it back to its original value.
      Parameters:
      buffer - The Buffer
      lenPos - The offset in the buffer where the length placeholder is to be update - Note: assumption is that the encoded data starts immediately after the placeholder
      Returns:
      The amount of data that has been encoded
    • updateLengthPlaceholder

      public static void updateLengthPlaceholder(Buffer buffer, int lenPos, long dataLength)
      Updates a 32-bit "placeholder" location for data length - moves the write position to the specified placeholder position, updates the length value and then moves the write position it back to its original value.
      Parameters:
      buffer - The Buffer
      lenPos - The offset in the buffer where the length placeholder is to be update - Note: assumption is that the encoded data starts immediately after the placeholder
      dataLength - The length to update - a UINT32 value as a long
    • clear

      public static <B extends Buffer> B clear(B buffer)
      Type Parameters:
      B - The generic buffer type
      Parameters:
      buffer - A Buffer instance - ignored if null
      Returns:
      The same as the input instance
    • validateInt32Value

      public static long validateInt32Value(long value, String message)
    • validateInt32Value

      public static long validateInt32Value(long value, String format, Object arg)
    • validateInt32Value

      public static long validateInt32Value(long value, String format, Object... args)
    • isValidInt32Value

      public static boolean isValidInt32Value(long value)
    • validateUint32Value

      public static long validateUint32Value(long value, String message)
    • validateUint32Value

      public static long validateUint32Value(long value, String format, Object arg)
    • validateUint32Value

      public static long validateUint32Value(long value, String format, Object... args)
    • isValidUint32Value

      public static boolean isValidUint32Value(long value)