src[srcIndex + 7] = 0x00;
        src[srcIndex + 8] = 0x00;
        src[srcIndex + 9] = 0x00;
        // rDataLength (2 bytes)
        src[srcIndex + 10] = 0x00;
        src[srcIndex + 11] = 0x06; // 6 bytes of data

        // Initialize questionName to avoid NPE
        Field questionNameField = NameServicePacket.class.getDeclaredField("questionName");
        questionNameField.setAccessible(true);

        // This check is imperfect: it doesn't tell us whether a handshake will succeed, just
        // that it will almost certainly fail because the proxy has sent unexpected data.
        if (!socket.source.buffer.exhausted() || !socket.sink.buffer.exhausted()) {
          throw IOException("TLS tunnel buffered too many bytes!")
        }

        call.eventListener.secureConnectStart(call)

// WithSharedResponse indicates it is unsafe to reuse the response
// when it has been returned on a handler.
// This will disable automatic response recycling/pooling.
// Typically this is used when the response sharing part of its data structure.
func (h *SingleHandler[Req, Resp]) WithSharedResponse() *SingleHandler[Req, Resp] {
	h.sharedResp = true
	return h
}

// NewResponse creates a new response.

            for (int i = 0; i < buffer.length; i++) {
                buffer[i] = (byte) 0xFF;
            }

            int bytesEncoded = request.encode(buffer, offset);

            // Verify data at correct offset
            assertEquals(timeout, SMBUtil.readInt8(buffer, offset));
            assertEquals(pipeName.getBytes(StandardCharsets.UTF_16LE).length, SMBUtil.readInt4(buffer, offset + 8));

         */
        public boolean isTeminated() {
            return teminated;
        }
    }

    /**
     * Thread that reads input stream data and buffers it for later retrieval.
     * Captures output from command execution with configurable line buffering.
     */
    protected static class InputStreamThread extends Thread {

	}
	serverStats.TotalS3Canceled = ServerHTTPAPIStats{
		APIStats: st.totalS3Canceled.Load(toLowerKeys),
	}
	return serverStats
}

// Update statistics from http request and response data
func (st *HTTPStats) updateStats(api string, w *xhttp.ResponseRecorder) {
	st.totalS3Requests.Inc(api)

	// Increment the prometheus http request response histogram with appropriate label

app = FastAPI()


class FormData(BaseModel):
    username: str
    password: str
    model_config = {"extra": "forbid"}


@app.post("/login/")
async def login(data: Annotated[FormData, Form()]):
    return data
```

Read the new docs: [Form Models - Forbid Extra Form Fields](https://fastapi.tiangolo.com/tutorial/request-form-models/#forbid-extra-form-fields).

### Features

- Update change notification handling

---

### Phase 5: RDMA (SMB Direct) Support
**Priority: LOW** | **Estimated Effort: 8-10 weeks**

RDMA provides high-speed, low-latency data transfer for supported network adapters.

#### 5.1 Core RDMA Infrastructure
```
Package: jcifs.internal.smb2.rdma
├── RdmaTransport.java           - RDMA transport implementation

            // Read the response
            int bytesRead = echoResponse.readBytesWireFormat(buffer, bufferIndex);
            assertEquals(0, bytesRead);

            // Write response (echo responses don't write data)
            int bytesWritten = echoResponse.writeBytesWireFormat(buffer, 0);
            assertEquals(0, bytesWritten);

            // Mark as received
            echoResponse.received();

        // toString() implementation may vary, just check it's not null and not empty
        assertFalse(stringRep.isEmpty());
    }

    @Test
    @DisplayName("Should generate correct associated data for AEAD")
    void testGetAssociatedData() {
        // Given
        transformHeader.setNonce(testNonce);
        transformHeader.setOriginalMessageSize(1024);
        transformHeader.setFlags(0x0001);