public int decode(final byte[] buf, int bi, final int len) {
        this.allow = buf[bi] == (byte) 0x00;
        bi++;
        this.flags = buf[bi++] & 0xFF;
        final int size = SMBUtil.readInt2(buf, bi);
        bi += 2;
        this.access = SMBUtil.readInt4(buf, bi);
        bi += 4;
        this.sid = new SID(buf, bi);
        return size;
    }

        // 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));

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.internal.smb1.trans;

import jcifs.Configuration;
import jcifs.internal.util.SMBUtil;

/**
 * SMB1 transaction subcommand for peeking at data in a named pipe.
 *
 * This class implements the TRANS_PEEK_NAMED_PIPE transaction which allows

import jcifs.CIFSContext;
import jcifs.Configuration;
import jcifs.internal.Request;
import jcifs.internal.smb1.SMB1SigningDigest;
import jcifs.internal.smb1.ServerMessageBlock;
import jcifs.internal.util.SMBUtil;

/**
 * SMB1 Close file request message.
 *
 * This command is used to close a file that was previously opened
 * with an Open command.
 */

     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        SMBUtil.writeInt2(4, dst, dstIndex);
        SMBUtil.writeInt2(0, dst, dstIndex + 2);
        return 4;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#readBytesWireFormat(byte[], int)
     */

     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override
    public int encode(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        SMBUtil.writeInt8(this.timeout, dst, dstIndex);
        dstIndex += 8;
        SMBUtil.writeInt4(this.nameBytes.length, dst, dstIndex);
        dstIndex += 4;

        dst[dstIndex] = (byte) (this.timeoutSpecified ? 0x1 : 0x0);
        dstIndex++;

        // 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

        // Assert: should write exactly 4 bytes
        assertEquals(4, written, "Should report 4 bytes written");
        // StructureSize (2 bytes, LE) == 4
        assertEquals(4, SMBUtil.readInt2(buf, offset));
        // Reserved (2 bytes, LE) == 0
        assertEquals(0, SMBUtil.readInt2(buf, offset + 2));
    }

    @Test
    @DisplayName("writeBytesWireFormat throws when buffer too small")

        }
        offset += descrBytes.length;

        // 3. Level (2 bytes)
        assertEquals(0x0001, SMBUtil.readInt2(dst, offset));
        offset += 2;

        // 4. MaxDataCount (2 bytes)
        int maxDataCount = SMBUtil.readInt2(dst, offset);
        assertTrue(maxDataCount > 0);
        offset += 2;

        // Verify total bytes written

            throw new SMBProtocolDecodingException("Invalid durable handle V2 response length: " + len);
        }

        this.timeout100Ns = SMBUtil.readInt4(buffer, bufferIndex) & 0xFFFFFFFFL; // Timeout (4 bytes, 100-ns intervals, unsigned)
        this.flags = SMBUtil.readInt4(buffer, bufferIndex + 4); // Flags (4 bytes)
        return 8;
    }

    /**
     * Get the timeout value in 100-nanosecond intervals (raw wire format)