resp.setContentLength(0);
                resp.flushBuffer();
                return null;
            }
        }

        return ntlm;
    }

    private synchronized NtlmChallenge getChallengeForDomain(final String domain) throws UnknownHostException, ServletException {
        if (domain == null) {
            throw new ServletException("A domain was not specified");
        }

                                    + now
                                    + ", lastUpdated = " + lastUpdated + "). Please verify that the clocks of all"
                                    + " deploying machines are reasonably synchronized.");
                    versioning.setLastUpdated(now);
                    changed = true;
                }
            }
        }

        if (changed) {

     * @throws DcerpcException if the bind operation fails
     * @throws IOException if an I/O error occurs
     */
    public void bind() throws DcerpcException, IOException {
        synchronized (this) {
            try {
                state = 1;
                final DcerpcMessage bind = new DcerpcBind(binding, this);
                sendrecv(bind);
            } catch (final IOException ioe) {

        resultData.setTransformerName(getName());

        initBaseDir();

        final String url = responseData.getUrl();
        final String path = getFilePath(url);

        synchronized (this) {

            final File file = createFile(path);

            try (final InputStream is = responseData.getResponseBody(); final OutputStream os = new FileOutputStream(file);) {

  private class RecordingPushObserver :
    PushObserver,
    Lockable {
    val events = mutableListOf<Any>()

    @Synchronized fun takeEvent(): Any {
      while (events.isEmpty()) {
        wait()
      }
      return events.removeAt(0)
    }

    @Synchronized override fun onRequest(
      streamId: Int,
      requestHeaders: List<Header>,
    ): Boolean {

     *            if there is a DCE/RPC protocol error
     * @throws IOException
     *            if there is an I/O error during binding
     */
    public void bind() throws DcerpcException, IOException {
        synchronized (this) {
            try {
                this.state = 1;
                final DcerpcMessage bind = new DcerpcBind(this.binding, this);
                sendrecv(bind);
            } catch (final IOException ioe) {

                            assertTrue(CrawlerStatus.INITIALIZING.compareTo(CrawlerStatus.DONE) < 0);
                        }
                    } catch (Exception e) {
                        synchronized (exceptions) {
                            exceptions.add(e);
                        }
                    }
                }
            });
        }

        // Start all threads

    public int available() throws IOException {
      return (int) min(in.available(), left);
    }

    // it's okay to mark even if mark isn't supported, as reset won't work
    @Override
    public synchronized void mark(int readLimit) {
      in.mark(readLimit);
      mark = left;
    }

    @Override
    public int read() throws IOException {
      if (left == 0) {
        return -1;
      }

 * since an iteration across all row keys occurs.
 *
 * <p>Note that this implementation is not synchronized. If multiple threads access this table
 * concurrently and one of the threads modifies the table, it must be synchronized externally.
 *
 * @author Jared Levy
 */
@GwtCompatible
class StandardTable<R, C, V> extends AbstractTable<R, C, V> implements Serializable {

    /**
     * Creates a new SmbClient instance.
     */
    public SmbClient() {
        super();
    }

    @Override
    public synchronized void init() {
        if (smbAuthenticationHolder != null) {
            return;
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Initializing SmbClient...");
        }