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

  /** The low-level TCP socket. */
  private var rawSocket: Socket? = null

  /**
   * The application layer socket. Either an [SSLSocket] layered over [rawSocket], or [rawSocket]
   * itself if this connection does not use SSL.
   */
  internal var socket: Socket? = null
  private var handshake: Handshake? = null
  private var protocol: Protocol? = null

    return delegate.supportedCipherSuites
  }

  @Throws(IOException::class)
  override fun createSocket(
    socket: Socket,
    host: String,
    port: Int,
    autoClose: Boolean,
  ): SSLSocket {
    val sslSocket = delegate.createSocket(socket, host, port, autoClose) as SSLSocket
    return configureSocket(sslSocket)
  }

  @Throws(IOException::class)

We can't rely on application threads to read data from the socket. Application threads are transient: sometimes they're reading and writing and sometimes they're off doing application-layer things. But the socket is permanent, and it needs constant attention: we dispatch all incoming frames so the connection is good-to-go when the application layer needs it.

So we have a dedicated thread for every socket that just reads frames and dispatches them.

                                            "address": {
                                                "pipe": {
                                                    "path": "./var/run/secrets/workload-spiffe-uds/socket"
                                                }
                                            },
                                            "health_check_config": {}
                                        },

        do {
/* These Socket constructors attempt to connect before SO_TIMEOUT can be applied
            if (localAddr == null) {
                socket = new Socket( address.getHostAddress(), 139 );
            } else {
                socket = new Socket( address.getHostAddress(), 139, localAddr, localPort );
            }
            socket.setSoTimeout( SO_TIMEOUT );
*/

  val connectionPool: RealConnectionPool,
  override val route: Route,
  /** The low-level TCP socket. */
  private var rawSocket: Socket?,
  /**
   * The application layer socket. Either an [SSLSocket] layered over [rawSocket], or [rawSocket]
   * itself if this connection does not use SSL.
   */
  private var socket: Socket?,
  private var handshake: Handshake?,
  private var protocol: Protocol?,

    val sslSocket =
      sslSocketFactory.createSocket(
        socket,
        socket.inetAddress.hostAddress,
        socket.port,
        true,
      ) as SSLSocket
    sslSocket.useClientMode = false
    Platform.get().configureTlsExtensions(sslSocket, null, listOf(Protocol.HTTP_2))
    sslSocket.startHandshake()
    return sslSocket
  }

  override fun onStream(stream: Http2Stream) {

  private fun readAndWriteFrames() {
    check(socket == null)
    val socket = serverSocket!!.accept()!!
    this.socket = socket

    // Bail out now if this instance was closed while waiting for the socket to accept.
    synchronized(this) {
      if (executor.isShutdown) {
        socket.close()
        return
      }
    }
    val outputStream = socket.getOutputStream()

      serverSocketChannel.configureBlocking(true);
      serverSocketChannel.socket().bind(address);
    }

    @Override public int getLocalPort() {
      return 1; // A white lie. There is no local port.
    }

    @Override public SocketAddress getLocalSocketAddress() {
      return endpoint;
    }

    @Override public Socket accept() throws IOException {
      try {

  /** Returns the route used by this connection. */
  fun route(): Route

  /**
   * Returns the socket that this connection is using. Returns an
   * [SSL socket][javax.net.ssl.SSLSocket] if this connection is HTTPS. If this is an HTTP/2
   * connection the socket may be shared by multiple concurrent calls.
   */
  fun socket(): Socket

  /**
   * Returns the TLS handshake used to establish this connection, or null if the connection is not