"NT LM 0.12"
            };
        }
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.SmbNegotiationRequest#isSigningEnforced()
     */
    @Override
    public boolean isSigningEnforced () {
        return this.signingEnforced;
    }


    @Override
    protected int writeParameterWordsWireFormat ( byte[] dst, int dstIndex ) {
        return 0;
    }

 */
package jcifs.internal;


/**
 * @author mbechler
 *
 */
public interface SmbNegotiationRequest {

    /**
     * @return whether SMB singing is enforced
     */
    boolean isSigningEnforced ();

                        }
                        continue;
                    }

                    if ( !forceSigning && !tc.getConfig().isSigningEnforced() && conn.isSigningEnforced()
                            && !conn.getNegotiateResponse().isSigningRequired() ) {
                        // if signing is not enforced, dont use connections that have signing enforced

        return this.delegate.isSigningEnabled();
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Configuration#isSigningEnforced()
     */
    @Override
    public boolean isSigningEnforced () {
        return this.delegate.isSigningEnforced();
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Configuration#isIpcSigningEnforced()
     */
    @Override

    }


    /**
     * @return the securityMode
     */
    public int getSecurityMode () {
        return this.securityMode;
    }


    @Override
    public boolean isSigningEnforced () {
        return ( getSecurityMode() & Smb2Constants.SMB2_NEGOTIATE_SIGNING_REQUIRED ) != 0;
    }


    /**
     * @return the capabilities
     */
    public int getCapabilities () {

     */
    boolean isSigningOptional () throws SmbException;


    /**
     * @return whether signatures are enforced from either side
     * @throws SmbException
     */
    boolean isSigningEnforced () throws SmbException;


    /**
     * @return the encryption key used by the server
     */
    byte[] getServerEncryptionKey ();


    /**
     * @param ctx
     * @return session

            return false;
        }

        if ( req.isSigningEnforced() || this.server.signaturesRequired || ( this.server.signaturesEnabled && ctx.getConfig().isSigningEnabled() ) ) {
            this.negotiatedFlags2 |= SmbConstants.FLAGS2_SECURITY_SIGNATURES;
            if ( req.isSigningEnforced() || isSigningRequired() ) {

    @Override
    public boolean isValid ( CIFSContext tc, SmbNegotiationRequest req ) {
        if ( !isReceived() || getStatus() != 0 ) {
            return false;
        }

        if ( req.isSigningEnforced() && !isSigningEnabled() ) {
            log.error("Signing is enforced but server does not allow it");
            return false;
        }

        if ( getDialectRevision() == Smb2Constants.SMB2_DIALECT_ANY ) {

    boolean isSignatureSetupRequired () throws SmbException {
        SMBSigningDigest cur = getDigest();
        if ( cur != null ) {
            return false;
        }
        else if ( this.transport.isSigningEnforced() ) {
            return true;
        }
        return this.transport.getNegotiateResponse().isSigningNegotiated();
    }


    /**
     * @param digest
     *            the digest to set

    /**
     * 
     * Property <tt>jcifs.smb.client.signingEnforced</tt> (boolean, default false)
     * 
     * @return whether to enforce SMB signing (for everything)
     */
    boolean isSigningEnforced ();


    /**
     * Property <tt>jcifs.smb.client.encryptionEnabled</tt> (boolean, default false)
     * 
     * This is an experimental option allowing to indicate support during protocol