}
                }
            } catch( IOException ioe ) {
                if (log.level > 2)
                    ioe.printStackTrace( log );
                try {
                    disconnect( true );
                } catch( IOException ioe2 ) {
                    ioe2.printStackTrace( log );
                }
                throw ioe;
            } catch( InterruptedException ie ) {

                        throw this.te;
                    }
                    this.state = 3; /* Success! */
                    return true;
                }
                break;
            case 3:
                return true; // already connected
            case 4:
                this.state = 6;
                throw new TransportException("Connection in error", this.te);
            case 5:

            pos += 4;

            if ( avId == AvPair.MsvAvEOL ) {
                if ( avLen != 0 ) {
                    throw new CIFSException("Invalid avLen for AvEOL");
                }
                foundEnd = true;
                break;
            }

            byte[] raw = new byte[avLen];
            System.arraycopy(data, pos, raw, 0, avLen);
            pairs.add(parseAvPair(avId, raw));

            pos += avLen;

    }

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

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

    public URL getURL() {
        return connection.getURL();
    }

    public int getContentLength() {

        this.openFlags &= ~(SmbFile.O_CREAT | SmbFile.O_TRUNC); /* in case close and reopen */
        writeSize = file.tree.session.transport.snd_buf_size - 70;

        useNTSmbs = file.tree.session.transport.hasCapability( ServerMessageBlock.CAP_NT_SMBS );
        if( useNTSmbs ) {
            reqx = new SmbComWriteAndX();
            rspx = new SmbComWriteAndXResponse();

        handle.sendrecv(rpc);
        if ( rpc.retval != 0 ) {
            throw new SmbException(rpc.retval, false);
        }
        this.opened = true;
    }


    @Override
    public synchronized void close () throws IOException {
        if ( this.opened ) {
            this.opened = false;
            MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);

    public static final int DCERPC_DID_NOT_EXECUTE = 0x20;
    public static final int DCERPC_MAYBE = 0x40; /* `maybe' call semantics requested */
    public static final int DCERPC_OBJECT_UUID = 0x80; /* if true, a non-nil object UUID */

        if( isOpen() ) {
            return;
        }
        fid = open0( flags, access, attrs, options );
        opened = true;
        tree_num = tree.tree_num;
    }
    boolean isOpen() {
        boolean ans = opened && isConnected() && tree_num == tree.tree_num;
        return ans;
    }
    void close( int f, long lastWriteTime ) throws SmbException {

        if( log.level >= 3 )

        this.username = username;
        this.password = null;
        this.challenge = challenge;
        this.ansiHash = ansiHash;
        this.unicodeHash = unicodeHash;
        hashesExternal = true;
    }

/**
 * Returns the domain.
 */
    public String getDomain() {
        return domain;
    }

/**
 * Returns the username.
 */
    public String getUsername() {

            // server doesn't want unicode
            if ( ctx.getConfig().isForceUnicode() ) {
                this.capabilities |= SmbConstants.CAP_UNICODE;
                this.useUnicode = true;
            }
            else {
                this.useUnicode = false;
                this.negotiatedFlags2 &= 0xFFFF ^ SmbConstants.FLAGS2_UNICODE;
            }
        }
        else {