/**
   * If true, no new exchanges can be created on this connection. It is necessary to set this to
   * true when removing a connection from the pool; otherwise a racing caller might get it from the
   * pool when it shouldn't. Symmetrically, this must always be checked before returning a
   * connection from the pool.
   *
   * Once true this is always true. Guarded by this.
   */
  var noNewExchanges = false

  /** True if this call still has a request body open. */
  private var requestBodyOpen = false

  /** True if this call still has a response body open. */
  private var responseBodyOpen = false

  /** True if there are more exchanges expected for this call. */
  private var expectMoreExchanges = true

    bytesOut.read(fullBuffer, bytesOut.size)

    // Copy back all but what we're truncating.
    fullBuffer.read(bytesOut, lastFrame.start + length)
    outFrames.add(OutFrame(lastFrame.sequence, lastFrame.start, true))
    return writer
  }

  fun takeFrame(): InFrame = inFrames.take()

  fun play() {
    check(serverSocket == null)
    serverSocket = ServerSocket()
    serverSocket!!.reuseAddress = false

    ```kotlin
    val response: Response = call.execute()
    val multipartReader = MultipartReader(response.body!!)

    multipartReader.use {
      while (true) {
        val part = multipartReader.nextPart() ?: break
        process(part.headers, part.body)
      }
    }
    ```

 *  New: `MediaType.parameter()` gets a parameter like `boundary` from a media type like

        }
        "private".equals(directive, ignoreCase = true) -> {
          isPrivate = true
        }
        "public".equals(directive, ignoreCase = true) -> {
          isPublic = true
        }
        "must-revalidate".equals(directive, ignoreCase = true) -> {
          mustRevalidate = true
        }
        "max-stale".equals(directive, ignoreCase = true) -> {

    // Make an SSL Tunnel on the first message pair of each SSL + proxy connection.
    val url = route.address.url
    val requestLine = "CONNECT ${url.toHostHeader(includeDefaultPort = true)} HTTP/1.1"
    while (true) {
      val source = this.source!!
      val sink = this.sink!!
      val tunnelCodec =
        Http1ExchangeCodec(
          // No client for CONNECT tunnels:
          client = null,

    }
  }

  /** Returns true if [certificate] matches [ipAddress]. */
  private fun verifyIpAddress(
    ipAddress: String,
    certificate: X509Certificate,
  ): Boolean {
    val canonicalIpAddress = ipAddress.toCanonicalHost()

    return getSubjectAltNames(certificate, ALT_IPA_NAME).any {
      canonicalIpAddress == it.toCanonicalHost()
    }
  }

  /** Returns true if [certificate] matches [hostname]. */

            rawSocket,
            rawSocket.inetAddress.hostAddress,
            rawSocket.port,
            true,
          ) as SSLSocket
        sslSocket.use {
          sslSocket.useClientMode = false
          sslSocket.wantClientAuth = true
          sslSocket.startHandshake()
          return@submit sslSocket.session.handshake()
        }
      }
    }
  }

            socketConnectTimeoutMillis = 10_000,
            socketReadTimeoutMillis = 10_000,
            pingIntervalMillis = 10_000,
            retryOnConnectionFailure = false,
            fastFallback = true,
            address = address,
            routeDatabase = RouteDatabase(),
            connectionUser = user,
          ),
          taskRunner,
        )
      },
    )
  }

    object : Runnable {
      override fun run() {
        var incrementedRunCallCount = false
        while (true) {
          val task =
            ******@****.***ck {
              if (!incrementedRunCallCount) {
                incrementedRunCallCount = true
                runCallCount++
              }
              awaitTaskToRun()
            } ?: return