if( pipe.pipeIn != null ) {
            TransactNamedPipeInputStream in = (TransactNamedPipeInputStream)pipe.pipeIn;
            synchronized( in.lock ) {
                in.receive( buffer, bufferIndex, len );
                in.lock.notify();
            }
        }
        return len;
    }
    public String toString() {
        return new String( "TransCallNamedPipeResponse[" + super.toString() + "]" );

        if( pipe.pipeIn != null ) {
            TransactNamedPipeInputStream in = (TransactNamedPipeInputStream)pipe.pipeIn;
            synchronized( in.lock ) {
                in.receive( buffer, bufferIndex, len );
                in.lock.notify();
            }
        }
        return len;
    }
    public String toString() {

    static final int DEFAULT_NOTIFY_BUF_SIZE = 1024;

    static final int DEFAULT_SSN_LIMIT = 250;
    static final int DEFAULT_CONN_TIMEOUT = 35000;

    static final int FLAGS_NONE = 0x00;
    static final int FLAGS_LOCK_AND_READ_WRITE_AND_UNLOCK = 0x01;
    static final int FLAGS_RECEIVE_BUFFER_POSTED = 0x02;
    static final int FLAGS_PATH_NAMES_CASELESS = 0x08;
    static final int FLAGS_PATH_NAMES_CANONICALIZED = 0x10;

        Exception ex0 = null;

        try {
            /* We cannot synchronize (run_thread) here or the caller's
             * thread.wait( timeout ) cannot reaquire the lock and
             * return which would render the timeout effectively useless.
             */
            doConnect();
        } catch( Exception ex ) {
            ex0 = ex; // Defer to below where we're locked

        Exception ex0 = null;

        try {
            /*
             * We cannot synchronize (run_thread) here or the caller's
             * thread.wait( timeout ) cannot reaquire the lock and
             * return which would render the timeout effectively useless.
             */
            if ( this.state != 5 && this.state != 6 ) {
                doConnect();
            }
        }

        final Object lock = new Object();
        final Thread t = Thread.currentThread();

        this.executor.submit(new Runnable() {

            @Override
            public void run () {

                try {
                    synchronized ( lock ) {
                        lock.wait(1000);
                    }

                    Thread.sleep(100);

            break;
        case SMB2_READ:
            c = "SMB2_READ";
            break;
        case SMB2_WRITE:
            c = "SMB2_WRITE";
            break;
        case SMB2_LOCK:
            c = "SMB2_LOCK";
            break;
        case SMB2_IOCTL:
            c = "SMB2_IOCTL";
            break;
        case SMB2_CANCEL:
            c = "SMB2_CANCEL";
            break;

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.smb2.lock;


import jcifs.Configuration;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.smb2.ServerMessageBlock2Response;
import jcifs.internal.util.SMBUtil;


/**
 * @author mbechler

import jcifs.internal.smb2.Smb2Constants;
import jcifs.internal.smb2.io.Smb2ReadResponse;
import jcifs.internal.smb2.ioctl.Smb2IoctlRequest;
import jcifs.internal.smb2.ioctl.Smb2IoctlResponse;
import jcifs.internal.smb2.lock.Smb2OplockBreakNotification;
import jcifs.internal.smb2.nego.EncryptionNegotiateContext;
import jcifs.internal.smb2.nego.Smb2NegotiateRequest;
import jcifs.internal.smb2.nego.Smb2NegotiateResponse;
import jcifs.netbios.Name;

    private static final String RO = Config.getProperty( "jcifs.smb1.resolveOrder" );

    private static LogStream log = LogStream.getInstance();

    private final Object LOCK = new Object();

    private int lport, closeTimeout;
    private byte[] snd_buf, rcv_buf;
    private DatagramSocket socket;
    private DatagramPacket in, out;
    private HashMap responseTable = new HashMap();