log.warn("Disconnected tree while still in use " + this);
                        dumpResource();
                        wasInUse = true;
                        if ( sess.getConfig().isTraceResourceUsage() ) {
                            throw new RuntimeCIFSException("Disconnected tree while still in use");
                        }
                    }

            this.file = smbFile;
        }


        public void waitForStart () throws InterruptedException {
            synchronized ( this.startedLock ) {
                while ( !this.started ) {
                    this.startedLock.wait();
                }
            }
        }


        public void shutdown () {
            this.shutdown = true;

                w.interrupt();
                try {
                    w.join();
                }
                catch ( InterruptedException e ) {
                    log.warn("Interrupted while joining copy thread", e);
                }
            }
        }
        catch ( CIFSException e ) {
            throw SmbException.wrap(e);
        }
    }


    @Override

        synchronized ( this.inFlightLookups ) {
            if ( this.inFlightLookups.contains(name) == false ) {
                this.inFlightLookups.add(name);
                return null;
            }
            while ( this.inFlightLookups.contains(name) ) {
                try {
                    this.inFlightLookups.wait();
                }
                catch ( InterruptedException e ) {

 * other SMB clients will be permitted to read from the target file while
 * this file is open. This constant may be logically OR'd with other share
 * access flags.
 */
    public static final int FILE_SHARE_READ   = 0x01;
/**
 * When specified as the <tt>shareAccess</tt> constructor parameter,
 * other SMB clients will be permitted to write to the target file while
 * this file is open. This constant may be logically OR'd with other share

     * @param maxLen
     * @return position of terminating null bytes
     */
    public static int findUNITermination ( byte[] buffer, int bufferIndex, int maxLen ) {
        int len = 0;
        while ( buffer[ bufferIndex + len ] != (byte) 0x00 || buffer[ bufferIndex + len + 1 ] != (byte) 0x00 ) {
            len += 2;
            if ( len > maxLen ) {
                if ( log.isDebugEnabled() ) {

        }
        return sequence;
    }

    public KerberosApRequest(ASN1Sequence seq, KerberosKey[] keys) throws PACDecodingException {
        Enumeration<?> fields = seq.getObjects();
        while ( fields.hasMoreElements() ) {
            ASN1TaggedObject tagged = ASN1Util.as(ASN1TaggedObject.class, fields.nextElement());
            switch ( tagged.getTagNo() ) {
            case 0:

            if (0 == tagNo)
            {
                throw new IOException("corrupted stream - invalid high tag number found");
            }

            while ((b & 0x80) != 0)
            {
                if ((tagNo >>> 24) != 0)
                {
                    throw new IOException("Tag number more than 31 bits");
                }

            throws CIFSException, GeneralSecurityException {
        try ( SmbTransportImpl trans = getTransport() ) {
            synchronized ( trans ) {

                while ( !this.connectionState.compareAndSet(0, 1) ) {
                    int st = this.connectionState.get();
                    if ( st == 2 || st == 3 ) // connected or disconnecting
                        return chainedResponse;

    //@Test
    public void testSessionMaintenance () throws IOException, InterruptedException {
        try ( SmbFile f = getDefaultShareRoot() ) {
            checkConnection(f);
            while ( true ) {
                f.list();
                Thread.sleep(5000);
            }

        }
    }