/**
     * 
     */
    public static final int SMB2_HEADER_LENGTH = 64;

    /**
     * 
     */
    public static final int SMB2_NEGOTIATE_SIGNING_ENABLED = 0x0001;

    /**
     * 
     */
    public static final int SMB2_NEGOTIATE_SIGNING_REQUIRED = 0x0002;

    /**
     * 
     */
    public static final int SMB2_DIALECT_0202 = 0x0202;

    /**
     * 
     */

        if ( type2 == null )
            return getDefaultFlags(tc);
        int flags = NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_VERSION;
        flags |= type2.getFlag(NTLMSSP_NEGOTIATE_UNICODE) ? NTLMSSP_NEGOTIATE_UNICODE : NTLMSSP_NEGOTIATE_OEM;
        return flags;
    }


    /**
     * Returns the LanManager/LMv2 response.
     *

     * @return An <code>int</code> containing the default flags.
     */
    public static int getDefaultFlags ( CIFSContext tc ) {
        return NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_VERSION
                | ( tc.getConfig().isUseUnicode() ? NTLMSSP_NEGOTIATE_UNICODE : NTLMSSP_NEGOTIATE_OEM );
    }


    /**
     * Returns the supplied authentication domain.
     *

    public static int getDefaultFlags(Type1Message type1) {
        if (type1 == null) return DEFAULT_FLAGS;
        int flags = NTLMSSP_NEGOTIATE_NTLM;
        int type1Flags = type1.getFlags();
        flags |= ((type1Flags & NTLMSSP_NEGOTIATE_UNICODE) != 0) ?
                NTLMSSP_NEGOTIATE_UNICODE : NTLMSSP_NEGOTIATE_OEM;
        if ((type1Flags & NTLMSSP_REQUEST_TARGET) != 0) {
            String domain = getDefaultDomain();

            }

            if (++mid == 32000) mid = 1;
            NEGOTIATE_REQUEST.mid = mid;
            int n = NEGOTIATE_REQUEST.encode( sbuf, 4 );
            Encdec.enc_uint32be( n & 0xFFFF, sbuf, 0 ); /* 4 byte ssn msg header */

            if (log.level >= 4) {
                log.println( NEGOTIATE_REQUEST );
                if (log.level >= 6) {
                    Hexdump.hexdump( log, sbuf, 4, n );

        assertEquals(origFlags, parsed.getFlags());

        if ( parsed.getFlag(NtlmFlags.NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED) ) {
            assertEquals(suppliedDomain, parsed.getSuppliedDomain());
        }

        if ( parsed.getFlag(NtlmFlags.NTLMSSP_NEGOTIATE_OEM_WORKSTATION_SUPPLIED) ) {
            assertEquals(suppliedWorkstation, parsed.getSuppliedWorkstation());
        }
    }

                log.error("Multiple preauth negotiate contexts");
                return false;
            }
        }

        if ( !foundPreauth ) {
            log.error("Missing preauth negotiate context");
            return false;
        }
        if ( !foundEnc && ( caps & Smb2Constants.SMB2_GLOBAL_CAP_ENCRYPTION ) != 0 ) {
            log.error("Missing encryption negotiate context");
            return false;

    public int getRequestSecurityMode ( Smb2NegotiateResponse first ) {
        int securityMode = Smb2Constants.SMB2_NEGOTIATE_SIGNING_ENABLED;
        if ( this.signingEnforced || ( first != null && first.isSigningRequired() ) ) {
            securityMode = Smb2Constants.SMB2_NEGOTIATE_SIGNING_REQUIRED | Smb2Constants.SMB2_NEGOTIATE_SIGNING_ENABLED;
        }

        return securityMode;
    }

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

    private byte[] preauthSalt;


    /**
     * @param config
     * @param securityMode
     */
    public Smb2NegotiateRequest ( Configuration config, int securityMode ) {
        super(config, SMB2_NEGOTIATE);
        this.securityMode = securityMode;

        if ( !config.isDfsDisabled() ) {
            this.capabilities |= Smb2Constants.SMB2_GLOBAL_CAP_DFS;
        }