final int start = bufferIndex;
        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 16) {
            throw new SMBProtocolDecodingException("Structure size is not 16");
        }

        this.shareType = buffer[bufferIndex + 2];
        bufferIndex += 4;
        this.shareFlags = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // CurrentLeaseState (4 bytes)
        this.currentLeaseState = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // NewLeaseState (4 bytes)
        this.newLeaseState = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // BreakReason (4 bytes)
        this.breakReason = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        final int start = bufferIndex;

        status = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        converter = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        numEntries = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        totalAvailableEntries = readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        return bufferIndex - start;
    }

     * @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);
    }

        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;

		select {
		case <-ctx.Done():
			r.err = ctx.Err()
			return ctx.Err()
		case dst <- meta:
		}
	}
}

// readFn will return all remaining objects
// and provide a callback for each entry read in order
// as long as true is returned on the callback.
func (r *metacacheReader) readFn(fn func(entry metaCacheEntry) bool) error {
	r.checkInit()
	if r.err != nil {
		return r.err
	}
	if r.current.name != "" {

        if (wordCount == 0) {
            return 0;
        }
        fileAttributes = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        lastWriteTime = readUTime(buffer, bufferIndex);
        bufferIndex += 4;
        fileSize = readInt4(buffer, bufferIndex);
        return 20;
    }

    @Override
    int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {

        // Then
        assertEquals(6, bytesWritten);
        assertEquals(fid, SMBUtil.readInt2(dst, 0));
        // lastWriteTime is not written if digest is null, so the remaining bytes should be zero
        assertEquals(0, SMBUtil.readInt4(dst, 2));
    }

    /**

            assertEquals(4, written);
            assertEquals(4, SMBUtil.readInt2(minBuffer, 0));

            // Large buffer
            byte[] largeBuffer = new byte[10000];
            written = echoRequest.writeBytesWireFormat(largeBuffer, 5000);
            assertEquals(4, written);
            assertEquals(4, SMBUtil.readInt2(largeBuffer, 5000));
        }

        @Test

        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 17) {
            throw new SMBProtocolDecodingException("Expected structureSize = 17");
        }
        bufferIndex += 4;

        this.count = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.remaining = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;