* block until that read completes. It is possible to time out while waiting for that.
     */
    @Throws(IOException::class)
    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      check(fileOperator != null)

      val source: Int =
        synchronized(this@Relay) {
          // We need new data from upstream.
          while (true) {
            val upstreamPos = ******@****.***amPos

  var b = addressOffset

  var i = pos
  while (i < limit) {
    if (b == address.size) return false // Too many groups.

    // Read a delimiter.
    if (b != addressOffset) {
      if (input[i] != '.') return false // Wrong delimiter.
      i++
    }

    // Read 1 or more decimal digits for a value in 0..255.
    var value = 0
    val groupOffset = i
    while (i < limit) {
      val c = input[i]

      return hex.decodeHex().toResponseBody(mediaType)
    }

    fun exhaust(reader: Reader): String {
      val builder = StringBuilder()
      val buf = CharArray(10)
      var read: Int
      while (reader.read(buf).also { read = it } != -1) {
        builder.appendRange(buf, 0, read)
      }
      return builder.toString()
    }
  }

 *  Fix: Include the header `Accept: text/event-stream` for SSE calls. This header is not added if
    the request already contains an `Accept` header.

 *  Fix: Don't crash with a `NullPointerException` if a server sends a close while we're sending a
    ping. OkHttp had a race condition bug.


## Version 4.6.0

_2020-04-28_

 *  Fix: Follow HTTP 307 and 308 redirects on methods other than GET and POST. We're reluctant to

 *     .build();
 * ```
 *
 * ## Force a Cache Response
 *
 * Sometimes you'll want to show resources if they are available immediately, but not otherwise.
 * This can be used so your application can show *something* while waiting for the latest data to be
 * downloaded. To restrict a request to locally-cached resources, add the `only-if-cached`
 * directive:
 *
 * ```java
 * Request request = new Request.Builder()

    fun chunkedBody(
      body: Buffer,
      maxChunkSize: Int,
    ) = apply {
      removeHeader("Content-Length")
      headers.add(CHUNKED_BODY_HEADER)

      val bytesOut = Buffer()
      while (!body.exhausted()) {
        val chunkSize = minOf(body.size, maxChunkSize.toLong())
        bytesOut.writeHexadecimalUnsignedLong(chunkSize)
        bytesOut.writeUtf8("\r\n")
        bytesOut.write(body, chunkSize)

    // 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,

    connection.setFixedLengthStreamingMode(1024 * 1024 * 1024) // 1 GB
    connection.connect()
    val out = connection.outputStream
    val data = ByteArray(1024 * 1024)
    var i = 0
    while (i < 1024) {
      try {
        out.write(data)
        out.flush()
        if (i == 513) {
          // pause slightly after halfway to make result more predictable
          Thread.sleep(100)
        }

      object : Comparator<String> {
        override fun compare(
          a: String,
          b: String,
        ): Int {
          var i = 4
          val limit = minOf(a.length, b.length)
          while (i < limit) {
            val charA = a[i]
            val charB = b[i]
            if (charA != charB) return if (charA < charB) -1 else 1
            i++
          }
          val lengthA = a.length

in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall...