boolean result = response.verifySignature(buffer, 0, 100);

            assertTrue(result);
        }

        @Test
        @DisplayName("Should verify signature on error when secure negotiate required")
        void testVerifySignatureErrorWithSecureNegotiate() {
            byte[] buffer = new byte[100];
            response.setDigest(mockDigest);

    /**
     * Function code to trim file level storage
     */
    public static final int FSCTL_FILE_LEVEL_TRIM = 0x00098208;
    /**
     * Function code to validate SMB2 negotiate information
     */
    public static final int FSCTL_VALIDATE_NEGOTIATE_INFO = 0x000140204;

    /**
     * Flag indicating this IOCTL is a file system control operation
     */

  integrity sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w==

negotiator@0.6.3:
  version "0.6.3"
  resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.3.tgz#58e323a72fedc0d6f9cd4d31fe49f51479590ccd"
  integrity sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==

        } catch (Exception e) {
            state = RdmaConnectionState.ERROR;
            throw new IOException("DiSNI RDMA write failed", e);
        }
    }

    @Override
    public RdmaNegotiateResponse negotiate(RdmaNegotiateRequest request) throws IOException {
        // Simulate successful negotiation for skeleton implementation
        RdmaNegotiateResponse response = new RdmaNegotiateResponse();

_2025-10-07_

 *  New: Support [HTTP 101] responses with `Response.socket`. This mechanism is only supported on
    HTTP/1.1. We also reimplemented our websocket client to use this new mechanism.

 *  New: The `okhttp-zstd` module negotiates [Zstandard (zstd)][zstd] compression with servers that
    support it. It integrates a new (unstable) [ZSTD-KMP] library, also from Square. Enable it like
    this:

    ```kotlin
    val client = OkHttpClient.Builder()

        boolean dfsStrictView = delegatingConfig.isDfsStrictView();

        // Then
        assertTrue(smb2Only, "Should delegate SMB2 only negotiation");
        assertFalse(secureNegotiate, "Should delegate secure negotiate requirement");
        assertTrue(ntlmTargetName, "Should delegate NTLM target name setting");
        assertFalse(port139Failover, "Should delegate port 139 failover setting");

                dc_list_expiration = 0;
            } while (retry-- > 0);

            dc_list_expiration = now + 1000 * 60 * 15; /* 15 min */
        }

        throw new UnknownHostException("Failed to negotiate with a suitable domain controller for " + DOMAIN);
    }

    /**
     * Retrieves the NTLM challenge from the specified domain controller.
     *
     * @param dc the domain controller address

            return false;
        }

        // MS-SMB2: Check if server advertised SMB2_GLOBAL_CAP_MULTI_CHANNEL (0x00000008)
        // This capability should be checked from the negotiate response
        // The server capabilities are typically stored in the session or transport

        // TODO: Integration point - check server capabilities

     * for requests and the writeXxxWireFormat for responses are not implemented
     * and simply return 0. These would need to be completed for a server
     * implementation.
     */

    /** SMB2 negotiate protocol command */
    protected static final short SMB2_NEGOTIATE = 0x00;
    /** SMB2 session setup command */
    protected static final short SMB2_SESSION_SETUP = 0x01;
    /** SMB2 logoff command */

  public val proxyAddress: Proxy
    get() = Proxy(Proxy.Type.HTTP, socketAddress)

  /**
   * True if ALPN is used on incoming HTTPS connections to negotiate a protocol like HTTP/1.1 or
   * HTTP/2. This is true by default; set to false to disable negotiation and restrict connections
   * to HTTP/1.1.
   */
  public var protocolNegotiationEnabled: Boolean = true

  /**