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();
            }
        }

     */
    public void setTarget ( String target ) {
        this.target = target;
    }


    /**
     * Returns the target information block.
     *
     * @return A <code>byte[]</code> containing the target information block.
     *         The target information block is used by the client to create an
     *         NTLMv2 response.
     */
    public byte[] getTargetInformation () {

            while ( len > blockSize && n == r );
            // this used to be len > 0, but this is BS:
            // - InputStream.read gives no such guarantee
            // - otherwise the caller would need to figure out the block size, or otherwise might end up with very small
            // reads
            return (int) ( this.fp - start );
        }
    }


    /**

    /**
     * Returns the target information block.
     *
     * @return A <code>byte[]</code> containing the target information block.
     * The target information block is used by the client to create an
     * NTLMv2 response.
     */ 
    public byte[] getTargetInformation() {
        return targetInformation;
    }

    /**
     * Sets the target information block.

        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;

    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();

        }
    }


    /// Encrypt a block of eight bytes.
    private void encrypt( byte[] clearText, int clearOff, byte[] cipherText, int cipherOff ) {

        squashBytesToInts( clearText, clearOff, tempInts, 0, 2 );
        des( tempInts, tempInts, encryptKeys );
        spreadIntsToBytes( tempInts, 0, cipherText, cipherOff, 2 );
    }

    /// Decrypt a block of eight bytes.

        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00
    };

    private static final Logger log = LoggerFactory.getLogger(NameServiceClientImpl.class);

    private final Object LOCK = new Object();

    private int nbnsIndex = 0;

    private final Map<Name, CacheEntry> addressCache = new HashMap<>();
    private final Set<Name> inFlightLookups = new HashSet<>();

            _dst.enc_ndr_short(domain_guid.time_mid);
            _dst.enc_ndr_short(domain_guid.time_hi_and_version);
            _dst.enc_ndr_small(domain_guid.clock_seq_hi_and_reserved);
            _dst.enc_ndr_small(domain_guid.clock_seq_low);
            int _domain_guid_nodes = 6;
            int _domain_guid_nodei = _dst.index;
            _dst.advance(1 * _domain_guid_nodes);