// recordType (2 bytes)
        src[srcIndex + 2] = 0x00;
        src[srcIndex + 3] = 0x20; // NB (0x0020)
        // recordClass (2 bytes)
        src[srcIndex + 4] = 0x00;
        src[srcIndex + 5] = 0x01; // IN (0x0001)
        // ttl (4 bytes)
        src[srcIndex + 6] = 0x00;
        src[srcIndex + 7] = 0x00;
        src[srcIndex + 8] = 0x00;
        src[srcIndex + 9] = 0x00;
        // rDataLength (2 bytes)

            }
        } else {
            this.createDisposition = FILE_OPEN;
        }

        if ((createOptions & 0x0001) == 0) {
            this.createOptions = createOptions | 0x0040;
        } else {
            this.createOptions = createOptions;
        }
        this.impersonationLevel = 0x02; // As seen on NT :~)
        this.securityFlags = (byte) 0x03; // SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY
    }

# ADR-0002 - Avoid using Java serialization

## Status

- ACCEPTED on 2023-12-01

## Context

In Gradle we often need to serialize in-memory objects for caching, or to transmit them across process barriers, etc.
Java serialization is one way to implement this, however, despite its simplicity of implementation, it has several drawbacks:

- **Performance:**
Java's built-in serialization mechanism is often slower compared to other serialization solutions.

        assertEquals(expectedHigh, buffer[offset + 3]);
    }

    private static Stream<Arguments> provideFidTestCases() {
        return Stream.of(Arguments.of(0x0000, (byte) 0x00, (byte) 0x00), Arguments.of(0x00FF, (byte) 0xFF, (byte) 0x00),
                Arguments.of(0xFF00, (byte) 0x00, (byte) 0xFF), Arguments.of(0xFFFF, (byte) 0xFF, (byte) 0xFF),
                Arguments.of(0x1234, (byte) 0x34, (byte) 0x12));
    }

    @Test

    /**
     * Flag indicating that SIDs should be resolved to names.
     */
    public static final int SID_FLAG_RESOLVE_SIDS = 0x0001;

    /**
     * Well known SID: EVERYONE
     */
    public static SID EVERYONE = null;

    /**
     * Well known SID: CREATOR_OWNER
     */
    public static SID CREATOR_OWNER = null;

    /**

        Field commandField = ServerMessageBlock2.class.getDeclaredField("command");
        commandField.setAccessible(true);
        int command = (int) commandField.get(req);

        assertEquals(0x0003, command); // SMB2_TREE_CONNECT command value

        // Verify path is set correctly
        Field pathField = Smb2TreeConnectRequest.class.getDeclaredField("path");
        pathField.setAccessible(true);

        assertArrayEquals(expectedDescrBytes, actualDescrBytes);

        // Verify level (0x0001)
        int descrEnd = 2 + expectedDescrBytes.length;
        assertEquals(0x01, dst[descrEnd]);
        assertEquals(0x00, dst[descrEnd + 1]);

        // Verify maxDataCount (16384)
        assertEquals(16384, SMBUtil.readInt2(dst, descrEnd + 2));

	// but these seem to be the values agreed on by tools.
	s_IFMT   = 0xf000
	s_IFSOCK = 0xc000
	s_IFLNK  = 0xa000
	s_IFREG  = 0x8000
	s_IFBLK  = 0x6000
	s_IFDIR  = 0x4000
	s_IFCHR  = 0x2000
	s_IFIFO  = 0x1000
	s_ISUID  = 0x800
	s_ISGID  = 0x400
	s_ISVTX  = 0x200

	msdosDir      = 0x10
	msdosReadOnly = 0x01
)

```java
public class Smb2LeaseState {
    // Lease state flags (can be combined)
    public static final int SMB2_LEASE_NONE           = 0x00;
    public static final int SMB2_LEASE_READ_CACHING   = 0x01;  // R - Read caching
    public static final int SMB2_LEASE_HANDLE_CACHING = 0x02;  // H - Handle caching  
    public static final int SMB2_LEASE_WRITE_CACHING  = 0x04;  // W - Write caching
    
    // Common combinations

        final int start = di;
        int ch;
        final int strlen = str.length();

        for (int i = 0; di < dlim && i < strlen; i++) {
            ch = str.charAt(i);
            if (ch >= 0x0001 && ch <= 0x007F) {
                dst[di] = (byte) ch;
                di++;
            } else {
                if (ch > 0x07FF) {
                    if (dlim - di < 3) {
                        break;