/**
     * Negotiate RDMA parameters
     *
     * @param request negotiation request parameters
     * @return negotiation response
     * @throws IOException if negotiation fails
     */
    public abstract RdmaNegotiateResponse negotiate(RdmaNegotiateRequest request) throws IOException;

    /**

    /**
     * Constructs a new SmbUnsupportedOperationException with a default message
     */
    public SmbUnsupportedOperationException() {
        super("Operation is not supported with the negotiated capabilities");
    }

    /**
     * Constructs a new SmbUnsupportedOperationException with the specified message
     * @param msg the detail message
     */

  ) {
  }

  /** Called after the TLS handshake to release resources allocated by [configureTlsExtensions]. */
  open fun afterHandshake(sslSocket: SSLSocket) {
  }

  /** Returns the negotiated protocol, or null if no protocol was negotiated. */
  open fun getSelectedProtocol(sslSocket: SSLSocket): String? = null

  /** For MockWebServer. This returns the inbound SNI names. */

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.smb2.rdma;

/**
 * RDMA negotiation response parameters.
 *
 * Contains the negotiated parameters returned by the RDMA peer
 * during connection establishment.
 */
public class RdmaNegotiateResponse {

    private int status;
    private int selectedVersion;
    private int creditsGranted;

        final int start = bufferIndex;

        pathConsumed = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        /* Samba 2.2.8a will reply with Unicode paths even though
         * ASCII is negotiated so we must use flags2 (probably
         * should anyway).
         */
        if ((flags2 & FLAGS2_UNICODE) != 0) {
            pathConsumed /= 2;
        }
        numReferrals = readInt2(buffer, bufferIndex);

          message == "No session to resume." -> Type.Handshake
          message.startsWith("Consuming ") -> Type.Handshake
          message.startsWith("Produced ") -> Type.Handshake
          message.startsWith("Negotiated ") -> Type.Handshake
          message.startsWith("Found resumable session") -> Type.Handshake
          message.startsWith("Resuming session") -> Type.Handshake

import jcifs.smb1.smb1.NtlmPasswordAuthentication;
import jcifs.smb1.util.Base64;

/**
 * This class is used internally by {@code NtlmHttpFilter},
 * {@code NtlmServlet}, and {@code NetworkExplorer} to negiotiate password
 * hashes via NTLM SSP with MSIE. It might also be used directly by servlet
 * containers to incorporate similar functionality.
 * <p>
 * How NTLMSSP is used in conjunction with HTTP and MSIE clients is

     * @param selectedMech the selected mechanism OID
     * @return whether the specified mechanism is preferred
     */
    boolean isPreferredMech(ASN1ObjectIdentifier selectedMech);

    /**
     * Gets the negotiated context flags.
     * @return context flags
     */
    int getFlags();

    /**
     * Gets the array of supported security mechanism OIDs.
     * @return array of supported mechanism OIDs
     */

    memory if web socket compression is negotiated but not used.


## Version 4.5.0-RC1

_2020-03-17_

**This release candidate turns on web socket compression.**

The [spec][rfc_7692] includes a sophisticated mechanism for client and server to negotiate
compression features. We strive to offer great performance in our default configuration and so we're

        assertSame(transport, t);
        verify(transport, times(1)).acquire();
    }

    @Test
    @DisplayName("isSignatureSetupRequired depends on digest and negotiate flags")
    void testIsSignatureSetupRequired() throws Exception {
        SmbSessionImpl session = newSession();

        // Case 1: digest already set -> false