}
            if (currentAuthMethod.startsWith("Negotiate")) {
                if (currentAuthMethod.length() == 9) {
                    authMethod = "Negotiate";
                    break;
                }
                if (currentAuthMethod.indexOf(' ') != 9) {
                    continue;
                }
                authMethod = "Negotiate";

 * to a remote host. Newer TLS options are quite useful:
 *
 *  * Server Name Indication (SNI) enables one IP address to negotiate secure connections for
 *    multiple domain names.
 *
 *  * Application Layer Protocol Negotiation (ALPN) enables the HTTPS port (443) to be used to
 *    negotiate HTTP/2.
 *
 * Unfortunately, older HTTPS servers refuse to connect when such options are presented. Rather than

        when(httpSession.getAttribute("NtlmHttpAuth")).thenReturn(null);

        // Create a custom filter that overrides negotiate to test skipAuthentication
        NtlmHttpFilter customFilter = new NtlmHttpFilter() {
            @Override
            protected NtlmPasswordAuthentication negotiate(HttpServletRequest req, HttpServletResponse resp, boolean skipAuthentication)
                    throws IOException, ServletException {

        byte[] initialHash = preauthService.getCurrentPreauthHash(sessionId);
        assertNotNull(initialHash);

        // Update with negotiate message
        byte[] negotiateMessage = "SMB2 Negotiate Request".getBytes();
        preauthService.updatePreauthHash(sessionId, negotiateMessage);

        byte[] afterNegotiateHash = preauthService.getCurrentPreauthHash(sessionId);

                                  int remoteKey,
                                  int length) throws IOException;
    
    /**
     * Negotiate RDMA parameters
     */
    public abstract RdmaNegotiateResponse negotiate(RdmaNegotiateRequest request) throws IOException;
    
    public boolean canSend() {
        return sendCredits.get() > 0 && state == RdmaConnectionState.ESTABLISHED;
    }

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

/**
 * Interface for SMB protocol negotiation request messages.
 * Represents the client's request to negotiate SMB protocol version and capabilities
 * with the server, including security requirements like message signing.
 *
 * @author mbechler
 */
public interface SmbNegotiationRequest {

    /**

import jcifs.Decodable;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Validate Negotiate Info response data structure. This structure contains the server's
 * validation of the originally negotiated SMB2 dialect.
 *
 * @author mbechler
 *
 */
public class ValidateNegotiateInfoResponse implements Decodable {

    /**

    }

    /**
     * Returns the server capabilities negotiated during the SMB handshake.
     *
     * @return the negotiated capabilities
     */
    public int getNegotiatedCapabilities() {
        return this.capabilities;
    }

    /**
     * Gets the negotiated send buffer size.
     *
     * @return negotiated send buffer size
     */
    public int getNegotiatedSendBufferSize() {

     */
    @Override
    public byte[] getServerEncryptionKey() {
        if (this.negotiated == null) {
            return null;
        }

        if (this.negotiated instanceof SmbComNegotiateResponse) {
            return ((SmbComNegotiateResponse) this.negotiated).getServerData().encryptionKey;
        }
        return null;
    }

    @Override

import jcifs.config.PropertyConfiguration;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.smb2.nego.CompressionNegotiateContext;

/**
 * Comprehensive tests for SMB3 compression negotiate context.
 */
public class CompressionNegotiateContextTest {

    private Configuration config;
    private CompressionNegotiateContext context;

    @BeforeEach
    public void setUp() throws Exception {