this.source.finished = true
      }
      open = isOpen
      notifyAll()
    }
    if (!open) {
      connection.removeStream(id)
    }
  }

  fun receiveRstStream(errorCode: ErrorCode) {
    withLock {
      if (this.errorCode == null) {
        this.errorCode = errorCode
        notifyAll()
      }
    }
  }

  /**

                if (coordinatorTask != null) {
                  waitingCoordinatorNotified = true
                  currentTask = coordinatorTask
                  taskRunner.notifyAll()
                } else {
                  startNextTask()
                }
              }
            }
        }

        override fun coordinatorWait(
          taskRunner: TaskRunner,

 */
interface Lockable

internal inline fun Lockable.wait() = (this as Object).wait()

internal inline fun Lockable.notify() = (this as Object).notify()

internal inline fun Lockable.notifyAll() = (this as Object).notifyAll()

internal inline fun Lockable.awaitNanos(nanos: Long) {
  val ms = nanos / 1_000_000L
  val ns = nanos - (ms * 1_000_000L)
  if (ms > 0L || nanos > 0) {
    (this as Object).wait(ms, ns.toInt())
  }

        if (isAsync() && getStatus() == NtStatus.NT_STATUS_PENDING) {
            synchronized (this) {
                notifyAll();
            }
            return;
        }
        this.received = true;
        synchronized (this) {
            notifyAll();
        }
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Response#exception(java.lang.Exception)

import java.io.File
import java.io.IOException
import java.io.RandomAccessFile
import okhttp3.internal.closeQuietly
import okhttp3.internal.concurrent.Lockable
import okhttp3.internal.concurrent.notifyAll
import okio.Buffer
import okio.ByteString
import okio.ByteString.Companion.encodeUtf8
import okio.Source
import okio.Timeout

/**

import okhttp3.internal.closeQuietly
import okhttp3.internal.concurrent.Lockable
import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.concurrent.assertLockNotHeld
import okhttp3.internal.concurrent.notifyAll
import okhttp3.internal.concurrent.wait
import okhttp3.internal.concurrent.withLock
import okhttp3.internal.connection.BufferedSocket
import okhttp3.internal.http2.ErrorCode.REFUSED_STREAM

                    } finally {
                        this.connectionState.set(0);
                    }
                    throw se;
                } finally {
                    transport.notifyAll();
                }
            }
        }
    }

    /**
     * @param transport
     * @param sess
     * @param response
     * @throws IOException
     */

                    logger.debug("delay={}", delay);
                }
                Thread.sleep(delay);
            } while (delay > 2);

            synchronized (t) {
                t.notifyAll();
            }
            //System.out.println("numComplete=" + t.numComplete + ",numThreads=" + t.numThreads);
        }

        for (ti = 0; ti < t.numThreads; ti++) {
            threads[ti].join();

                        }
                        doSkip();
                    } else {
                        doRecv(response);
                        response.isReceived = true;
                        notifyAll();
                    }
                }
            } catch (final Exception ex) {
                final String msg = ex.getMessage();

            } catch (final SmbException se) {
                logoff(true);
                connectionState = 0;
                throw se;
            } finally {
                transport.notifyAll();
            }
        }
    }

    void logoff(final boolean inError) {
        synchronized (transport()) {

            if (connectionState != 2) { // not-connected
                return;