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

        if ( auth != null ) {
            NtlmPasswordAuthenticator newAuth = NtlmAuthenticator
                    .requestNtlmPasswordAuthentication(auth, locationHint, ( error instanceof SmbAuthException ) ? (SmbAuthException) error : null);
            if ( newAuth != null ) {
                this.creds = newAuth;
                return true;
            }
        }
        return false;
    }

                    this.completed = true;
                    return;
                }
                log.error("Unexpected error", e);
            }
            finally {
                try {
                    this.file.close();
                }
                catch ( Exception e ) {
                    log.error("Failed to close");
                }
            }
        }
    }


    @Test

                // this is the signature error
                throw new SMBProtocolDowngradeException("Signature error during negotiate validation", e);
            }

            // other errors are treated as success
            return;
        }
        ValidateNegotiateInfoResponse out = resp.getOutputData(ValidateNegotiateInfoResponse.class);

    static final int[] WINERR_CODES = {
        ERROR_SUCCESS,
        ERROR_ACCESS_DENIED,
        ERROR_REQ_NOT_ACCEP,
        ERROR_BAD_PIPE,
        ERROR_PIPE_BUSY,
        ERROR_NO_DATA,
        ERROR_PIPE_NOT_CONNECTED,
        ERROR_MORE_DATA,
        ERROR_NO_BROWSER_SERVERS_FOUND,
    };

    static final String[] WINERR_MESSAGES = {
        "The operation completed successfully.",

        inLen = 0;
        while(( n = is.read( in, inLen, IN_SIZE - inLen )) != -1 ) {
            inLen += n;
        }
        if( inLen < 100 || inLen == IN_SIZE ) {
            throw new IOException( "Error reading jcifs/smb1/util/mime.map resource" );
        }
        is.close();
    }

    public String getMimeType( String extension ) throws IOException {
        return getMimeType( extension, "application/octet-stream" );

                resp = super.sendrecv(curHead, resp, params);

                if ( !checkStatus(curHead, resp) ) {
                    if ( log.isDebugEnabled() ) {
                        log.debug("Breaking on error " + resp);
                    }
                    break;
                }

                if ( nextHead != null ) {
                    // prepare remaining

        try {
            if ( !this.nameFilter.accept(this.parent, name) ) {
                return false;
            }
            return true;
        }
        catch ( CIFSException e ) {
            log.error("Failed to apply name filter", e);
            return false;
        }
    }


    protected final FileEntry advance ( boolean last ) throws CIFSException {
        FileEntry[] results = getResults();

        synchronized ( this ) {
            notifyAll();
        }
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Response#error()
     */
    @Override
    public void error () {
        this.isError = true;
        synchronized ( this ) {
            notifyAll();
        }
    }


    /**
     * @return the response
     */

     * @return whether signature verification failed
     */
    boolean isVerifyFailed ();


    /**
     * 
     * @return whether the response is an error
     */
    boolean isError ();


    /**
     * Set error status
     */
    void error ();


    /**
     * 
     * @return the message timeout
     */
    Long getExpiration ();


    /**
     * 
     * @param exp