finally {
                        if ( resp2 != null && !trans.isDisconnected() ) {
                            tree.send(new SmbComClose(sess.getConfig(), resp2.getFid(), 0L));
                        }
                    }
                }
                finally {
                    if ( resp != null && !trans.isDisconnected() ) {
                        tree.send(new SmbComClose(sess.getConfig(), resp.getFid(), 0L));

     * @throws SmbException
     */
    boolean hasCapability ( int cap ) throws SmbException;


    /**
     * @return whether the transport has been disconnected
     */
    boolean isDisconnected ();


    /**
     * @param hard
     * @param inuse
     * @return whether the connection was in use
     * @throws IOException
     */

        }
    }


    /**
     * {@inheritDoc}
     *
     * @see java.lang.Object#finalize()
     */
    @Override
    protected void finalize () throws Throwable {
        if ( !isDisconnected() && this.usageCount.get() != 0 ) {
            log.warn("Session was not properly released");
        }
    }


    /**
     * @return the number of known usages
     */

                    && ( tc.getConfig().getSessionLimit() == 0 || conn.getNumSessions() < tc.getConfig().getSessionLimit() ) ) {
                try {
                    if ( conn.isFailed() || ( connectedOnly && conn.isDisconnected() ) ) {
                        continue;
                    }

                    if ( forceSigning && !conn.isSigningEnforced() ) {

    }


    @Override
    public int getInflightRequests () {
        return this.response_map.size();
    }


    @Override
    public boolean isDisconnected () {
        Socket s = this.socket;
        return super.isDisconnected() || s == null || s.isClosed();
    }


    @Override
    public boolean isFailed () {
        Socket s = this.socket;

                }
                f.close();

                Thread.sleep(2 * soTimeout);

                // connection should be closed by now
                assertTrue("Transport is still connected", t.isDisconnected());
                assertFalse("Connection is still in the pool", ( (SmbTransportPoolImpl) ctx.getTransportPool() ).contains(t));
            }
            finally {
                f.delete();
            }

                        if ( response.isReceived() && !response.isError() && response.getErrorCode() == NtStatus.NT_STATUS_OK ) {
                            if ( !transport.isDisconnected() ) {
                                treeConnected(transport, sess, response);
                            }
                            throw se;
                        }
                    }

        try ( SmbSessionImpl session = getSession() ) {
            if ( isConnected() ) {
                try ( SmbTransportImpl transport = session.getTransport() ) {
                    if ( transport.isDisconnected() || transport.getRemoteHostName() == null ) {
                        /*
                         * Tree/session thinks it is connected but transport disconnected

        return this.credentials;
    }


    /**
     * @return whether the session is connected
     */
    public boolean isConnected () {
        return !this.transport.isDisconnected() && this.connectionState.get() == 2;
    }


    /**
     * @return whether the session has been lost
     */
    public boolean isFailed () {
        return this.transport.isFailed();