te = null;
            thread = new Thread( this, name );
            thread.setDaemon( true );

            synchronized (thread) {
                thread.start();
                thread.wait( timeout );          /* wait for doConnect */

                switch (state) {
                    case 1: /* doConnect never returned */
                        state = 0;
                        thread = null;

                        continue;
                    }

                    curResp.wait();
                    if ( handleIntermediate(request, curResp) ) {
                        continue;
                    }
                    if ( log.isDebugEnabled() ) {
                        log.debug("Wait returned state is " + this.state);
                    }
                    if ( isDisconnected() ) {

    public static final int FSCTL_DFS_GET_REFERRALS = 0x0060194;
    /**
     * 
     */
    public static final int FSCTL_PIPE_PEEK = 0x0011400C;
    /**
     * 
     */
    public static final int FSCTL_PIPE_WAIT = 0x00110018;
    /**
     * 
     */
    public static final int FSCTL_PIPE_TRANSCEIVE = 0x0011C017;
    /**
     * 
     */
    public static final int FSCTL_SRV_COPYCHUNK = 0x001440F2;
    /**
     * 

                    this.handle = this.pipe.openUnshared(this.uncPath, 0, this.access, this.sharing, SmbConstants.ATTR_NORMAL, 0);
                    return this.handle.acquire();
                }

                // TODO: wait for pipe, still not sure when this needs to be called exactly
                if ( this.uncPath.startsWith("\\pipe\\") ) {

 */
package jcifs.smb;


/**
 * Internal use only
 * 
 * @author mbechler
 * @internal
 */
public enum RequestParam {

    /**
     * 
     */
    NONE,

    /**
     * Wait indefinitely for a response
     */
    NO_TIMEOUT,

    /**
     * Do not retry request on failure
     */
    NO_RETRY,

    /**
     * Save the raw payload for further inspection
     */

package jcifs.smb1.smb1;

class TransWaitNamedPipe extends SmbComTransaction {

    TransWaitNamedPipe( String pipeName ) {
        name = pipeName;
        command = SMB_COM_TRANSACTION;
        subCommand = TRANS_WAIT_NAMED_PIPE;
        timeout = 0xFFFFFFFF;
        maxParameterCount = 0;
        maxDataCount = 0;
        maxSetupCount = (byte)0x00;
        setupCount = 2;
    }

        while (connectionState != 0) {
            if (connectionState == 2 || connectionState == 3) // connected or disconnecting
                return;
            try {
                transport.wait();
            } catch (InterruptedException ie) {
                throw new SmbException(ie.getMessage(), ie);
            }
        }
        connectionState = 1; // trying ...

        try {

        lock = new Object();
    }
    public int read() throws IOException {
        int result = -1;

        synchronized( lock ) {
            try {
                while( used == 0 ) {
                    lock.wait();
                }
            } catch( InterruptedException ie ) {
                throw new IOException( ie.getMessage() );
            }
            result = pipe_buf[beg_idx] & 0xFF;

                    synchronized ( w ) {
                        w.checkException();
                        while ( !w.isReady() ) {
                            try {
                                w.wait();
                            }
                            catch ( InterruptedException ie ) {
                                throw new SmbException(dest.getURL().toString(), ie);
                            }

                LOOKUP_TABLE.put( name, name );
                return null;
            }
            while( LOOKUP_TABLE.containsKey( name )) {
                try {
                    LOOKUP_TABLE.wait();
                } catch( InterruptedException e ) {
                }
            }
        }
        obj = getCachedAddress( name );
        if( obj == null ) {
            synchronized( LOOKUP_TABLE ) {