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

                /* 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$";

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

        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

    }


    /**
     * 
     * @return the server connected to
     */
    public abstract String getServer ();


    /**
     * @return the server resolved by DFS
     */
    public abstract String getServerWithDfs ();


    /**
     * @return the transport context used
     */
    public abstract CIFSContext getTransportContext ();


    /**

                        return null;
                    }
                    // failure to connect
                    throw new SmbException("Tree disconnected while waiting for connection");
                }
                else if ( before == 2 ) {
                    // concurrently connected
                    return null;
                }

                if ( log.isDebugEnabled() ) {

        try ( SmbFile f = new SmbFile("smb://[::1]/", getContext()) ) {
            f.list();
        } catch (final SmbException e) {
            if (!"Failed to connect: /0:0:0:0:0:0:0:1".equals(e.getMessage())) {
                throw e;
            }
        }
    }

    private static class TestDfsReferral implements DfsReferralData {

        private String server;

        case SMB2_SESSION_SETUP:
            c = "SMB2_SESSION_SETUP";
            break;
        case SMB2_LOGOFF:
            c = "SMB2_LOGOFF";
            break;
        case SMB2_TREE_CONNECT:
            c = "SMB2_TREE_CONNECT";
            break;
        case SMB2_TREE_DISCONNECT:
            c = "SMB2_TREE_DISCONNECT";
            break;
        case SMB2_CREATE:
            c = "SMB2_CREATE";