*/
class Http1ExchangeCodec(
  /** The client that configures this stream. May be null for HTTPS proxy tunnels. */
  private val client: OkHttpClient?,
  override val carrier: ExchangeCodec.Carrier,
  private val source: BufferedSource,
  private val sink: BufferedSink,
) : ExchangeCodec {
  private var state = STATE_IDLE
  private val headersReader = HeadersReader(source)

  internal var hasFailure: Boolean = false
    private set

  internal val connection: RealConnection
    get() = codec.carrier as? RealConnection ?: error("no connection for CONNECT tunnels")

  internal val isCoalescedConnection: Boolean
    get() = finder.routePlanner.address.url.host != codec.carrier.route.address.url.host

  @Throws(IOException::class)
  fun writeRequestHeaders(request: Request) {
    try {

import okio.Sink
import okio.Source

/** Encodes HTTP requests and decodes HTTP responses. */
interface ExchangeCodec {
  /** The connection or CONNECT tunnel that owns this codec. */
  val carrier: Carrier

  /** Returns an output stream where the request body can be streamed. */
  @Throws(IOException::class)
  fun createRequestBody(
    request: Request,
    contentLength: Long,
  ): Sink

import okhttp3.internal.immutableListOf
import okio.Sink
import okio.Source

/** Encode requests and responses using HTTP/2 frames. */
class Http2ExchangeCodec(
  client: OkHttpClient,
  override val carrier: Carrier,
  private val chain: RealInterceptorChain,
  private val http2Connection: Http2Connection,
) : ExchangeCodec {
  @Volatile private var stream: Http2Stream? = null

  private val protocol: Protocol =

  internal val routes: List<Route>?,
  private val attempt: Int,
  private val tunnelRequest: Request?,
  internal val connectionSpecIndex: Int,
  internal val isTlsFallback: Boolean,
) : RoutePlanner.Plan, ExchangeCodec.Carrier {
  /** True if this connect was canceled; typically because it lost a race. */
  @Volatile private var canceled = false

  // These properties are initialized by connect() and never reassigned.

  private var refusedStreamCount = 0

  /**
   * The maximum number of concurrent streams that can be carried by this connection. If
   * `allocations.size() < allocationLimit` then new streams can be created on this connection.
   */
  internal var allocationLimit = 1
    private set

  /** Current calls carried by this connection. */
  val calls = mutableListOf<Reference<RealCall>>()

HSPLokhttp3/internal/http2/Http2ExchangeCodec;->createRequestBody(Lokhttp3/Request;J)Lokio/Sink;
HSPLokhttp3/internal/http2/Http2ExchangeCodec;->finishRequest()V
HSPLokhttp3/internal/http2/Http2ExchangeCodec;->getCarrier()Lokhttp3/internal/http/ExchangeCodec$Carrier;

pagexl.com

// Paywhirl, Inc : https://paywhirl.com/
// Submitted by Daniel Netzer <******@****.***>
*.paywhirl.com

// pcarrier.ca Software Inc: https://pcarrier.ca/
// Submitted by Pierre Carrier <pc@rrier.ca>
bar0.net
bar1.net
bar2.net
rdv.to

// .pl domains (grandfathered)
art.pl
gliwice.pl
krakow.pl
poznan.pl
wroc.pl

canon canva-apps.cn canva-apps.com capebreton.museum capetown capital capitalone capoo.jp car caracal.mythic-beasts.com caravan carbonia-iglesias.it carboniaiglesias.it cards care career careers cargo.aero carrara-massa.it carraramassa.it carrd.co carrier.museum cars cartoonart.museum casa casacam.net casadelamoneda.museum case caserta.it cash casino casino.hu castle.museum castres.museum cat cat.ax catania.it catanzaro.it catering catering.aero catfood.jp catholic catholic.edu.au caxias.br cb.it cba...

    }
    final CyclicBarrier barrier =
        new CyclicBarrier(
            6 // for the setter threads
                + 50 // for the listeners
                + 50 // for the blocking get threads,
                + 1); // for the main thread
    final ExecutorService executor = Executors.newFixedThreadPool(barrier.getParties());