send( new SmbComClose( f, lastWriteTime ), blank_resp() );
    }
    void close( long lastWriteTime ) throws SmbException {
        if( isOpen() == false ) {
            return;
        }
        close( fid, lastWriteTime );
        opened = false;
    }
    void close() throws SmbException {
        close( 0L );
    }

/**
 * Returns the <tt>NtlmPasswordAuthentication</tt> object used as

        ServerInfo1[] results = new ServerInfo1[getNumEntries()];
        for ( int i = 0; i < getNumEntries(); i++ ) {
            results[ i ] = e = new ServerInfo1();
            e.name = readString(buffer, bufferIndex, 16, false);
            bufferIndex += 16;
            e.versionMajor = buffer[ bufferIndex++ ] & 0xFF;
            e.versionMinor = buffer[ bufferIndex++ ] & 0xFF;
            e.type = SMBUtil.readInt4(buffer, bufferIndex);

     * @throws DcerpcException
     */
    public static DcerpcHandle getHandle ( String url, CIFSContext tc ) throws MalformedURLException, DcerpcException {
        return getHandle(url, tc, false);
    }


    /**
     * Get a handle to a service
     * 
     * @param url
     * @param tc
     * @param unshared
     *            whether an exclusive connection should be used

    public void close() throws IOException {
        MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);
        handle.sendrecv(rpc);
        if (rpc.retval != 0)
            throw new SmbException(rpc.retval, false);
    }

    }


    boolean logoff ( boolean inError, boolean inUse ) {
        boolean wasInUse = false;
        try ( SmbTransportImpl trans = getTransport() ) {
            synchronized ( trans ) {
                if ( !this.connectionState.compareAndSet(2, 3) ) { // not-connected
                    return false;
                }

                if ( log.isDebugEnabled() ) {

            int flags ) throws GeneralSecurityException, CIFSException {
        // keep old behavior of anonymous auth when no password is provided
        this(tc, type2, targetName, password, domain, user, workstation, flags, false);
    }


    /**
     * Creates a Type-3 message in response to the given Type-2 message.
     * 
     * @param tc
     *            context to use
     * @param type2

    private String path;
    private SmbNamedPipe pipe;
    private byte[] tmp = new byte[1];
    private boolean dcePipe;

    TransactNamedPipeOutputStream( SmbNamedPipe pipe ) throws IOException {
        super(pipe, false, (pipe.pipeType & 0xFFFF00FF) | SmbFile.O_EXCL);
        this.pipe = pipe;
        this.dcePipe = ( pipe.pipeType & SmbNamedPipe.PIPE_TYPE_DCE_TRANSACT ) == SmbNamedPipe.PIPE_TYPE_DCE_TRANSACT;
        path = pipe.unc;
    }

                    } else {
                        makeKey( req );
                    }

                    synchronized (this) {
                        response.received = false;
                        resp.isReceived = false;
                        try {
                            response_map.put( req, resp );

                            /* 
                             * Send multiple fragments

        System.arraycopy(this.digest.doFinal(), 0, cmp, 0, SIGNATURE_LENGTH);
        if ( !MessageDigest.isEqual(sig, cmp) ) {
            return true;
        }
        return false;
    }

        int ftag = in.read();
        int tag = readTagNumber(in, ftag);
        if ( tag != expectTag ) {
            throw new IOException("Unexpected tag " + tag);
        }
        int length = readLength(in, limit, false);
        byte[] content = new byte[length];
        in.read(content);
        return content;
    }

    // shamelessly stolen from BC ASN1InputStream
    static int readTagNumber(InputStream s, int tag)