override fun publish(record: LogRecord) {
              super.publish(record)

              val parameters = record.parameters
              if (sslDebug && record.loggerName == "javax.net.ssl" && parameters != null) {
                System.err.println(parameters[0])
              }
            }
          }

        if (debug) {
          handler.level = Level.ALL

          val message = record.message
          val parameters = record.parameters

          if (parameters != null && !message.startsWith("Raw") && !message.startsWith("Plaintext")) {
            if (verbose) {
              println(record.message)
              println(record.parameters[0])
            }

            // JSSE logs additional messages as parameters that are not referenced in the log message.

    System.setProperty("javax.net.debug", "")
    return OkHttpDebugLogging.enable(
      "javax.net.ssl",
      object : Handler() {
        override fun publish(record: LogRecord) {
          val param = record.parameters?.firstOrNull() as? String
          debugHandler(JsseDebugMessage(record.message, param))
        }

        override fun flush() {
        }

        override fun close() {
        }
      },
    )

import com.github.ajalt.clikt.core.CliktCommand
import com.github.ajalt.clikt.parameters.arguments.argument
import com.github.ajalt.clikt.parameters.options.default
import com.github.ajalt.clikt.parameters.options.flag
import com.github.ajalt.clikt.parameters.options.multiple
import com.github.ajalt.clikt.parameters.options.option
import com.github.ajalt.clikt.parameters.types.int
import java.security.cert.X509Certificate
import java.util.Properties

 * your application's HTTP calls.
 *
 * All start/connect/acquire events will eventually receive a matching end/release event, either
 * successful (non-null parameters), or failed (non-null throwable). The first common parameters of
 * each event pair are used to link the event in case of concurrent or repeated events e.g.
 * `dnsStart(call, domainName)` → `dnsEnd(call, domainName, inetAddressList)`.
 *

    if (matchesSocket(sslSocket)) {
      val bcSocket = sslSocket as BCSSLSocket

      val sslParameters = bcSocket.parameters

      // Enable ALPN.
      sslParameters.applicationProtocols = Platform.alpnProtocolNames(protocols).toTypedArray()

      bcSocket.parameters = sslParameters
    }
  }

  companion object {
    val factory =
      object : DeferredSocketAdapter.Factory {

    <option name="MAIN_CLASS_NAME" value="" />
    <option name="METHOD_NAME" value="" />
    <option name="TEST_OBJECT" value="tags" />
    <option name="VM_PARAMETERS" value="-ea -Djunit.jupiter.extensions.autodetection.enabled=true" />
    <option name="PARAMETERS" value="" />
    <option name="TEST_SEARCH_SCOPE">
      <value defaultName="wholeProject" />
    </option>
    <tag value="!Slow &amp; !Slowish &amp; !Remote &amp; !Android" />

            version = 2L,
            serialNumber = BigInteger.ONE,
            signature =
              AlgorithmIdentifier(
                algorithm = SHA256_WITH_RSA_ENCRYPTION,
                parameters = null,
              ),
            issuer =
              listOf(
                listOf(
                  AttributeTypeAndValue(
                    type = COMMON_NAME,

 * of which connections to keep open for future use.
 *
 * @constructor Create a new connection pool with tuning parameters appropriate for a single-user
 * application. The tuning parameters in this pool are subject to change in future OkHttp releases.
 * Currently this pool holds up to 5 idle connections which will be evicted after 5 minutes of
 * inactivity.
 */

    } ?: throw IllegalArgumentException("No such suite: $javaName")
  }
}

suspend fun fetchIanaSuites(okHttpClient: OkHttpClient): IanaSuites {
  val url = "https://www.iana.org/assignments/tls-parameters/tls-parameters-4.csv"

  val call = okHttpClient.newCall(Request(url.toHttpUrl()))

  val suites =
    call.executeAsync().use {
      if (!it.isSuccessful) {
        throw IOException("Failed ${it.code} ${it.message}")