}
    }


    /**
     * Disconnect the transport
     * 
     * @param hard
     * @return whether conenction was in use
     * @throws IOException
     */
    public synchronized boolean disconnect ( boolean hard ) throws IOException {
        return disconnect(hard, true);
    }


    /**
     * Disconnect the transport
     * 
     * @param hard
     * @param inUse

                switch (state) {
                    case 1: /* doConnect never returned */
                        state = 0;
                        thread = null;
                        throw new TransportException( "Connection timeout" );
                    case 2:
                        if (te != null) { /* doConnect throw Exception */

        try {
            handshake();
        } catch (IOException ex) { }
        return connection.getResponseMessage();
    }

    public void disconnect() {
        connection.disconnect();
        handshakeComplete = false;
        connected = false;
    }

    public boolean usingProxy() {
        return connection.usingProxy();
    }

                                 * sent. Unfortunately calling disconnect() doesn't always
                                 * actually shutdown the connection before other threads
                                 * have committed themselves (e.g. InterruptTest example).
                                 */
                                try { transport.disconnect(true); } catch (Exception e) {}
                            }
    

 */
public class SmbComTreeDisconnect extends ServerMessageBlock {

    /**
     * 
     * @param config
     */
    public SmbComTreeDisconnect ( Configuration config ) {
        super(config, SMB_COM_TREE_DISCONNECT);
    }


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


    @Override

    /**
     * @param config
     */
    public Smb2TreeDisconnectRequest ( Configuration config ) {
        super(config, SMB2_TREE_DISCONNECT);
    }


    @Override
    protected Smb2TreeDisconnectResponse createResponse ( CIFSContext tc, ServerMessageBlock2Request<Smb2TreeDisconnectResponse> req ) {

 */

package jcifs.smb1.smb1;

class SmbComTreeDisconnect extends ServerMessageBlock {

    SmbComTreeDisconnect() {
        command = SMB_COM_TREE_DISCONNECT;
    }

    int writeParameterWordsWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int writeBytesWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }

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


    /**
     * @param hard
     * @param inuse
     * @return whether the connection was in use
     * @throws IOException
     */
    boolean disconnect ( boolean hard, boolean inuse ) throws IOException;


    /**

                     * Someone removed the share while we were
                     * connected. Bastards! Disconnect this tree
                     * so that it reconnects cleanly should the share
                     * reappear in this client's lifetime.
                     */
                    log.debug("Disconnect tree on NT_STATUS_NETWORK_NAME_DELETED");
                    treeDisconnect(true, true);
                }

            // Disconnect and try again from scratch.

            if ( log.isDebugEnabled() ) {
                log.debug(String.format("Retrying (%d/%d) request %s", retries, maxRetries, request));
            }

            // should we disconnect the transport here? otherwise we make an additional attempt to detect that if the