return this.state == 5 || this.state == 6;
    }


    /**
     * Send a request message and recieve response
     * 
     * @param request
     * @param response
     * @param params
     * @return the response
     * @throws IOException
     */
    public <T extends Response> T sendrecv ( Request request, T response, Set<RequestParam> params ) throws IOException {

    /**
     * @return the negotiated capbilities
     */
    public int getNegotiatedCapabilities () {
        return this.capabilities;
    }


    /**
     * 
     * @return negotiated send buffer size
     */
    public int getNegotiatedSendBufferSize () {
        return this.snd_buf_size;
    }


    /**
     * 
     * @return negotiated multiplex count
     */

 * There are three degrees of state that any NbtAddress can have.
 * 
 * 1) IP Address - If a dot-quad IP string is used with getByName (or used
 * to create an NbtAddress internal to this netbios package), no query is
 * sent on the wire and the only state this object has is it's IP address
 * (but that's enough to connect to a host using *SMBSERVER for CallingName).
 * 
 * 2) IP Address, NetBIOS name, nodeType, groupName - If however a

SmbComReadAndX request = new SmbComReadAndX( file.fid, fp, r, null );
if( file.type == SmbFile.TYPE_NAMED_PIPE ) {
    request.minCount = request.maxCount = request.remaining = 1024;
}
                file.send( request, response );
            } catch( SmbException se ) {
                if( file.type == SmbFile.TYPE_NAMED_PIPE &&
                        se.getNtStatus() == NtStatus.NT_STATUS_PIPE_BROKEN ) {

    /**
     * @param cap
     * @return whether the capabiltiy is present
     * @throws CIFSException
     */
    boolean hasCapability ( int cap ) throws CIFSException;


    /**
     * @return the send buffer size of the underlying connection
     * @throws CIFSException
     */
    int getSendBufferSize () throws CIFSException;


    /**
     * @return the receive buffer size of the underlying connection

                        request.setReadLength(r);
                        request.setRemainingBytes(len - r);

                        try {
                            Smb2ReadResponse resp = th.send(request, RequestParam.NO_RETRY);
                            n = resp.getDataLength();
                        }
                        catch ( SmbException e ) {

        if ( locator.getType() != SmbConstants.TYPE_SERVER )
            throw new SmbException("The requested list operations is invalid: " + u.toString());

        Set<FileEntry> set = new HashSet<>();

        if ( tc.getDfs().isTrustedDomain(tc, locator.getServer()) ) {
            /*
             * The server name is actually the name of a trusted

     *            initiated by the client (MSIE post requests after successful NTLM SSP
     *            authentication). If false and the user has not been authenticated yet
     *            the client will be forced to send an authentication (server sends
     *            HttpServletResponse.SC_UNAUTHORIZED).
     * @return True if the negotiation is complete, otherwise false
     * @throws ServletException
     */

    */
    public static final int NTLMSSP_NEGOTIATE_ALWAYS_SIGN = 0x00008000;

    /**
    * Sent by the server in the Type 2 message to indicate that the 
    * target authentication realm is a domain.
    */
    public static final int NTLMSSP_TARGET_TYPE_DOMAIN = 0x00010000;

    /**
    * Sent by the server in the Type 2 message to indicate that the 
    * target authentication realm is a server.
    */

         * Looks like the failure case also is just reflecting back the signature we sent
         */

        /**
         * Maybe this is related:
         * 
         * If signing is not active, the SecuritySignature field of the SMB Header for all messages sent, except
         * the SMB_COM_SESSION_SETUP_ANDX Response (section 2.2.4.53.2), MUST be set to