* @see java.lang.AutoCloseable#close()
     */
    @Override
    public void close () {
        release();
    }


    /**
     * 
     */
    public void release () {
        long usage = this.usageCount.decrementAndGet();
        if ( log.isTraceEnabled() ) {
            log.trace("Release transport " + usage + " " + this);
        }

        if ( usage == 0 ) {

    public synchronized void close () {
        release();
    }


    /**
     * @return tree handle with increased usage count
     */
    public SmbTreeHandleImpl acquire () {
        if ( this.usageCount.incrementAndGet() == 1 ) {
            this.treeConnection.acquire();
        }
        return this;
    }


    @Override
    public void release () {

                if ( wasAcquired ) {
                    // release
                    old.release(true);
                }
            }
            if ( this.delegate != null && this.delegateAcquired ) {
                log.debug("Releasing delegate");
                this.delegateAcquired = false;
                this.delegate.release();
            }
        }
    }


    /**

            log.warn("Session was not properly released");
        }
    }


    /**
     * {@inheritDoc}
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    public void close () {
        release();
    }


    /**
     * 
     */
    public void release () {
        long usage = this.usageCount.decrementAndGet();

            if ( t != null ) {
                // release tree usage
                t.release();
            }
            this.tree = null;
        }
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbFileHandle#close()
     */
    @Override
    public void close () throws CIFSException {
        release();
    }


    /**
     * {@inheritDoc}

     * @return input stream, needs to be closed when finished
     * @throws CIFSException
     */
    InputStream openInputStream () throws CIFSException;


    /**
     * Close/release the file
     * 
     * This releases all resources that this file holds. If not using strict mode this is currently a no-op.
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    void close ();

            this.closed = true;
            try {
                doCloseInternal();
            }
            finally {
                this.next = null;
                this.treeHandle.release();
            }
        }
    }


    /**
     * 
     */
    protected abstract void doCloseInternal () throws CIFSException;


    /**
     * {@inheritDoc}
     *

                }

                int permits = r.getInitialCredits();
                if ( permits > 0 ) {
                    this.credits.release(permits);
                }
                Arrays.fill(this.sbuf, (byte) 0);
                return new SmbNegotiation(
                    new Smb2NegotiateRequest(
                        getContext().getConfig(),

        // ensure file is open
        if ( this.handle == null || !this.handle.isValid() ) {
            // one extra acquire to keep this open till the stream is released
            this.handle = this.file.openUnshared(this.openFlags, this.access, this.sharing, SmbConstants.ATTR_NORMAL, this.options).acquire();
            return this.handle;
        }
        return this.handle.acquire();

     * 
     * Depending on the usage scenario, this may have some benefit as there won't be any delays for restablishing these
     * resources, however comes at the cost of having to properly release all SmbFile instances you no longer need.
     * 
     * @return whether to use strict resource lifecycle
     */
    boolean isStrictResourceLifecycle ();


    /**