super(connection.getURL());
        this.connection = connection;
        requestProperties = new HashMap();
    }

    public void connect() throws IOException {
        if (connected) return;
        connection.connect();
        connected = true;
    }

    private void handshake() throws IOException {
        if (handshakeComplete) return;
        doHandshake();
        handshakeComplete = true;

     * Build a connection. Only one thread will ever call this method at
     * any one time. If this method throws an exception or the connect timeout
     * expires an encapsulating TransportException will be thrown from connect
     * and the transport will be in error.
     */

    protected abstract void doConnect () throws Exception;


    /*
     * Tear down a connection. If the hard parameter is true, the diconnection

    /* Build a connection. Only one thread will ever call this method at
     * any one time. If this method throws an exception or the connect timeout
     * expires an encapsulating TransportException will be thrown from connect
     * and the transport will be in error.
     */

    protected abstract void doConnect() throws Exception;

    /* Tear down a connection. If the hard parameter is true, the diconnection

                                String service, ServerMessageBlock andx ) {
        super( andx );
        this.session = session;
        this.path = path;
        this.service = service;
        command = SMB_COM_TREE_CONNECT_ANDX;
    }

    int getBatchLimit( byte command ) {
        int c = (int)( command & 0xFF );
        // why isn't this just return batchLimits[c]?
        switch( c ) {
            case SMB_COM_CHECK_DIRECTORY:

                /* Some pipes may require that the hostname in the tree connect
                 * be the netbios name. So if we have the netbios server name
                 * from the NTLMSSP type 2 message, and the share is IPC$, we
                 * assert that the tree connect path uses the netbios hostname.
                 */
                tcax.path = "\\\\" + netbiosName + "\\IPC$";

            }
        } else {
            throw new SmbException("Unsupported");
        }
    }

    int getBatchLimit( byte command ) {
        return command == SMB_COM_TREE_CONNECT_ANDX ? BATCH_LIMIT : 0;
    }
    int writeParameterWordsWireFormat( byte[] dst, int dstIndex ) {
        int start = dstIndex;

        writeInt2( session.transport.snd_buf_size, dst, dstIndex );

            synchronized ( trans ) {
                try {
                    // ensure connected
                    trans.ensureConnected();
                    refServerName = trans.getRemoteHostName();
                }
                catch ( IOException e ) {
                    log.warn("Failed to connect to domain controller", e);
                }

        else {
            throw new SmbException("Unsupported");
        }
    }


    @Override
    protected int getBatchLimit ( Configuration cfg, byte cmd ) {
        return cmd == SMB_COM_TREE_CONNECT_ANDX ? cfg.getBatchLimit("SessionSetupAndX.TreeConnectAndX") : 0;
    }


    @Override
    protected int writeParameterWordsWireFormat ( byte[] dst, int dstIndex ) {
        int start = dstIndex;

        this.setInstanceFollowRedirects(this.connection.getInstanceFollowRedirects());
    }


    @Override
    public void connect () throws IOException {
        if ( this.connected )
            return;
        this.connection.connect();
        this.connected = true;
    }


    private void handshake () {
        if ( this.handshakeComplete )
            return;
        try {

                }
            }
        }
    }
    public void connect() throws SmbException {
        try {
            super.connect( RESPONSE_TIMEOUT );
        } catch( TransportException te ) {
            throw new SmbException( "Failed to connect: " + address, te );
        }
    }
    protected void doConnect() throws IOException {
        /*
         * Negotiate Protocol Request / Response