// Test encoding and decoding roundtrip
        byte[] buffer = new byte[context.size()];
        int encoded = context.encode(buffer, 0);
        assertEquals(context.size(), encoded);

        DirectoryLeaseContext decodedContext = new DirectoryLeaseContext(new Smb2LeaseKey(), 0, DirectoryCacheScope.IMMEDIATE_CHILDREN);

        decodedContext.decode(buffer, 0, buffer.length);

        // Verify roundtrip integrity

net.ipv4.tcp_sack=1

# Low latency mode for TCP
net.ipv4.tcp_low_latency=1

# The following variable is used to tell the kernel how 
# much of the socket buffer space should be used for TCP 
# window size, and how much to save for an application buffer.
net.ipv4.tcp_adv_win_scale=1

# disable RFC2861 behavior
net.ipv4.tcp_slow_start_after_idle = 0

# Fix faulty network setups
net.ipv4.tcp_mtu_probing=1

- **Thread Safety**: Components support concurrent access
- **DFS Support**: Distributed File System resolution
- **Streaming Operations**: Efficient directory listings and file operations
- **Buffer Caching**: Optimized buffer management
- **DCE/RPC Protocol**: Support for advanced operations

## Quick Start

### Basic Usage

```java
import jcifs.CIFSContext;
import jcifs.context.SingletonContext;

        final int length = readUShort(src, index);
        final int offset = readULong(src, index + 4);
        final byte[] buffer = new byte[length];
        System.arraycopy(src, offset, buffer, 0, length);
        return buffer;
    }

    static void writeULong(final byte[] dest, final int offset, final int ulong) {
        dest[offset] = (byte) (ulong & 0xff);

     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#readBytesWireFormat(byte[], int)
     */
    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) throws SMBProtocolDecodingException {
        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 4) {
            throw new SMBProtocolDecodingException("Structure size is not 4");
        }
        return 4;
    }

import okio.BufferedSink
import okio.GzipSink
import okio.buffer

internal class GzipRequestBody(
  val delegate: RequestBody,
) : RequestBody() {
  override fun contentType() = delegate.contentType()

  // We don't know the compressed length in advance!
  override fun contentLength() = -1L

  override fun writeTo(sink: BufferedSink) {
    GzipSink(sink).buffer().use(delegate::writeTo)
  }

    protected int maxMpxCount = SmbConstants.DEFAULT_MAX_MPX_COUNT;
    /** Send buffer size for SMB socket operations */
    protected int smbSendBufferSize = SmbConstants.DEFAULT_SND_BUF_SIZE;
    /** Receive buffer size for SMB socket operations */
    protected int smbRecvBufferSize = SmbConstants.DEFAULT_RCV_BUF_SIZE;
    /** Buffer size for SMB notification operations */

        return dstIndex - start;
    }

    @Override
    int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    public String toString() {

        return dstIndex - start;
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    public String toString() {

    string: String,
    pos: Int,
    limit: Int,
    result: Buffer,
  ): Boolean {
    if (!string.regionMatches(pos, PREFIX_STRING, 0, 4, ignoreCase = true)) {
      result.writeUtf8(string, pos, limit)
      return true
    }

    var pos = pos + 4 // 'xn--'.size.

    // We'd prefer to operate directly on `result` but it doesn't offer insertCodePoint(), only