* Reads an integer as specified by {@link DataInputStream#readInt()}, except using little-endian
   * byte order.
   *
   * @return the next four bytes of the input stream, interpreted as an {@code int} in little-endian
   *     byte order
   * @throws IOException if an I/O error occurs
   */
  @CanIgnoreReturnValue // to skip some bytes
  @Override
  public int readInt() throws IOException {
    byte b1 = readAndCheckByte();

        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);

        if (structureSize != 9) {
            throw new SMBProtocolDecodingException("Expected structureSize = 9");
        }

        final int bufferOffset = SMBUtil.readInt2(buffer, bufferIndex + 2) + getHeaderStart();
        bufferIndex += 4;
        final int bufferLength = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        }

        final short dataOffset = buffer[bufferIndex + 2];
        bufferIndex += 4;
        this.dataLength = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.dataRemaining = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        bufferIndex += 4; // Reserved2

        final int dataStart = getHeaderStart() + dataOffset;

        // Verify all fields in the buffer
        assertEquals(33, SMBUtil.readInt2(buffer, 64)); // Structure size
        assertEquals((byte) 0x02, buffer[66]); // Info type
        assertEquals((byte) 0x08, buffer[67]); // File info class
        assertEquals(64, SMBUtil.readInt4(buffer, 68)); // Buffer length
        assertEquals(0xABCDEF00, SMBUtil.readInt4(buffer, 76)); // Additional information

        // Verify file ID

        assertEquals(getField(cmd, "fid"), SMBUtil.readInt2(buffer, 0));
        assertEquals(getField(cmd, "typeOfLock"), buffer[2]);
        assertEquals(getField(cmd, "newOpLockLevel"), buffer[3]);
        assertEquals(getField(cmd, "timeout"), (long) SMBUtil.readInt4(buffer, 4));
        assertEquals(1, SMBUtil.readInt2(buffer, 8));
        assertEquals(1, SMBUtil.readInt2(buffer, 10));
    }

    /**

        final int inputOffset = SMBUtil.readInt4(buffer, bufferIndex) + getHeaderStart();
        bufferIndex += 4;

        final int inputCount = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        final int outputOffset = SMBUtil.readInt4(buffer, bufferIndex) + getHeaderStart();
        bufferIndex += 4;

        final int outputCount = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

    try {
      listSource().buffer().use { bufferedSource ->
        val totalBytes = bufferedSource.readInt()
        publicSuffixListBytes = bufferedSource.readByteString(totalBytes.toLong())

        val totalExceptionBytes = bufferedSource.readInt()
        publicSuffixExceptionListBytes = bufferedSource.readByteString(totalExceptionBytes.toLong())
      }

      synchronized(this) {

     * @return decoded transform
     */
    public static Smb2RdmaTransform decode(byte[] buffer, int bufferIndex) {
        long offset = SMBUtil.readInt8(buffer, bufferIndex);
        int token = SMBUtil.readInt4(buffer, bufferIndex + 8);
        int length = SMBUtil.readInt4(buffer, bufferIndex + 12);
        return new Smb2RdmaTransform(offset, token, length);
    }

        // Verify structure size (should be 24)
        assertEquals(24, SMBUtil.readInt2(buffer, offset));

        // Verify Reserved1 (2 bytes at offset+2, should be 0)
        assertEquals(0, SMBUtil.readInt2(buffer, offset + 2));

        // Verify Reserved2 (4 bytes at offset+4, should be 0)
        assertEquals(0, SMBUtil.readInt4(buffer, offset + 4));

            /*
             * these fields are common to all andx commands
             * so let's populate them here
             */

            andxCommand = buffer[bufferIndex];
            andxOffset = readInt2(buffer, bufferIndex + 2);

            if (andxOffset == 0) { /* Snap server workaround */
                andxCommand = (byte) 0xFF;
            }

            /*