* @return A <code>byte[]</code> containing the local security
     * context.  This is used by the client to negotiate local
     * authentication.
     */
    public byte[] getContext() {
        return context;
    }

    /**
     * Sets the local security context.  This is used by the client
     * to negotiate local authentication.
     *
     * @param context The local security context.
     */

        // TCP fallback doesn't support real RDMA write
        throw new UnsupportedOperationException("RDMA write not supported by TCP fallback");
    }

    @Override
    public RdmaNegotiateResponse negotiate(RdmaNegotiateRequest request) throws IOException {
        // For TCP fallback, we simulate successful negotiation
        RdmaNegotiateResponse response = new RdmaNegotiateResponse();
        response.setStatus(0); // Success

        assertTrue(context.isEstablished());
        assertArrayEquals(serverChallenge, context.getServerChallenge());
        // Signing key may or may not be generated depending on flags negotiation
        // The context negotiates flags with server, so we can't guarantee signing key
    }

    @Test
    void testInitSecContext_state2_withoutSigning() throws Exception {

     * both internally supplied passwords are equal. If one {@code NtlmPasswordAuthentication} object has external
     * hashes (meaning negotiated via NTLM HTTP Authentication) and the other does not they will not be equal. This is
     * technically not correct however the server 8 byte challenge would be required to compute and compare the password

        // Test that ChannelManager initializes properly
        assertNotNull(channelManager);
        assertNotNull(channelManager.getChannels());
        // Note: isUseMultiChannel() checks if actual multi-channel is negotiated with server
        // In mock environment, this will be false until we mock successful negotiation

        // Verify load balancer is initialized
        assertNotNull(channelManager.getLoadBalancer());
    }

            //      e.eaSize = readInt4( buffer, bufferIndex + 64 );
            //      e.shortNameLength = buffer[bufferIndex + 68] & 0xFF;

            /* With NT, the shortName is in Unicode regardless of what is negotiated.
             */

            //      e.shortName = readString( buffer, bufferIndex + 70, e.shortNameLength );
            e.filename = readString(buffer, bufferIndex + 94, e.fileNameLength);

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

There may be many routes for a single address. For example, a webserver that is hosted in multiple datacenters may yield multiple IP addresses in its DNS response.

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

		mfs, err := gatherers.Gather()
		if err != nil {
			if len(mfs) == 0 {
				writeErrorResponseJSON(r.Context(), w, toAdminAPIErr(r.Context(), err), r.URL)
				return
			}
		}

		contentType := expfmt.Negotiate(r.Header)
		w.Header().Set("Content-Type", string(contentType))

		enc := expfmt.NewEncoder(w, contentType)
		for _, mf := range mfs {
			if err := enc.Encode(mf); err != nil {