* fallbacks to prevent the host machine's various IP addresses from interfering.
     */
    private val SINGLE_INET_ADDRESS_DNS =
      Dns { hostname ->
        val addresses = Dns.SYSTEM.lookup(hostname)
        listOf(addresses[0])
      }

    private operator fun Throwable?.plus(throwable: Throwable): Throwable {
      if (this != null) {
        addSuppressed(throwable)

      file.name.endsWith(".png") -> "image/png"
      else -> "text/plain"
    }

  private fun Socket.peerName(): String {
    val address = remoteSocketAddress
    return if (address is InetSocketAddress) address.hostName else address.toString()
  }

  companion object {
    val logger: Logger = Logger.getLogger(Http2Server::class.java.name)

    @JvmStatic
    fun main(args: Array<String>) {

 * does not participate in any [interceptors][Interceptor] or [event listeners][EventListener]. It
 * doesn't include the motivating request's HTTP headers or even its full URL; only the target
 * server's hostname is sent to the proxy.
 *
 * Prior to sending any CONNECT request OkHttp always calls the proxy authenticator so that it may
 * prepare preemptive authentication. OkHttp will call [authenticate] with a fake `HTTP/1.1 407

     * expired because under normal circumstances SID information never changes.
     *
     * @param authorityServerName
     *            The hostname of the server that should be queried. For maximum efficiency this should be the hostname
     *            of a domain controller however a member server will work as well and a domain controller may not

    result = 31 * result + address.hashCode()
    result = 31 * result + proxy.hashCode()
    result = 31 * result + socketAddress.hashCode()
    return result
  }

  /**
   * Returns a string with the URL hostname, socket IP address, and socket port, like one of these:
   *
   *  * `example.com:80 at 1.2.3.4:8888`
   *  * `example.com:443 via proxy [::1]:8888`
   *
   * This omits duplicate information when possible.
   */

        this.securityProvider = securityProvider;
    }

    /**
     * Gets the server hostname or address currently connected to
     * @return the server connected to
     */
    public abstract String getServer();

    /**
     * Gets the server hostname resolved through DFS (Distributed File System)
     * @return the server resolved by DFS
     */

 *
 * This may also be used for Android tests with Robolectric.
 */
open class Jdk9Platform : Platform() {
  @SuppressSignatureCheck
  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<@JvmSuppressWildcards Protocol>,
  ) {
    val sslParameters = sslSocket.sslParameters

    val names = alpnProtocolNames(protocols)

import okhttp3.testing.PlatformRule
import okhttp3.tls.HeldCertificate
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.RegisterExtension

/**
 * Tests for our hostname verifier. Most of these tests are from AOSP, which itself includes tests
 * from the Apache HTTP Client test suite.
 */
class HostnameVerifierTest {
  private val verifier = OkHostnameVerifier

  @RegisterExtension

   *
   * This will be invoked for route selection regardless of whether the client
   * is configured with a single proxy, a proxy selector, or neither.
   *
   * @param url a URL with only the scheme, hostname, and port specified.
   */
  open fun proxySelectStart(
    call: Call,
    url: HttpUrl,
  ) {
  }

  /**
   * Invoked after proxy selection.
   *

import java.util.Map;

import jcifs.DfsReferralData;

/**
 * Internal interface for DFS referral data with extended functionality.
 * Extends the public DFS referral data interface with internal operations like
 * hostname resolution and referral data manipulation for internal DFS management.
 *
 * @author mbechler
 */
public interface DfsReferralDataInternal extends DfsReferralData {

    /**