## Origin { #origin }

An origin is the combination of protocol (`http`, `https`), domain (`myapp.com`, `localhost`, `localhost.tiangolo.com`), and port (`80`, `443`, `8080`).

So, all these are different origins:

* `http://localhost`
* `https://localhost`
* `http://localhost:8080`

Even if they are all in `localhost`, they use different protocols or ports, so, they are different "origins".

## Steps { #steps }

    assertThat(cacheControl.toString()).isEqualTo(header)
  }

  @Test
  @Throws(Exception::class)
  fun parseIgnoreCacheControlExtensions() {
    // Example from http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.6
    val header = "private, community=\"UCI\""
    val cacheControl =
      parse(
        Headers
          .Builder()
          .set("Cache-Control", header)

| rename              | no        |

MinIO supports following FTP/SFTP based protocols to access and manage data.

- Secure File Transfer Protocol (SFTP) – Defined by the Internet Engineering Task Force (IETF) as an
  extended version of SSH 2.0, allowing file transfer over SSH and for use with Transport Layer
  Security (TLS) and VPN applications.

- File Transfer Protocol over SSL/TLS (FTPS) – Encrypted FTP communication via TLS certificates.

  @Test
  @Throws(Exception::class)
  fun webSocketConnectionIsReleased() {
    // This test assumes HTTP/1.1 pooling semantics.
    client =
      client
        .newBuilder()
        .protocols(Arrays.asList(Protocol.HTTP_1_1))
        .build()
    webServer.enqueue(
      MockResponse
        .Builder()
        .code(HttpURLConnection.HTTP_NOT_FOUND)
        .body("not found!")
        .build(),

has been replaced with a new synthetic header, `OkHttp-Selected-Protocol`.

##### Changes

 * New: Support for `HTTP-draft-09/2.0`.
 * New: Support for `spdy/3.1`. Dropped support for `spdy/3`.
 * New: Use ALPN on Android platforms that support it (4.4+)
 * New: CacheControl model and parser.
 * New: Protocol selection in MockWebServer.
 * Fix: Route selection shouldn't use TLS modes that we know will fail.

Addresses specify a webserver (like `github.com`) and all of the **static** configuration necessary to connect to that server: the port number, HTTPS settings, and preferred network protocols (like HTTP/2).

        throw UnknownServiceException(
          "CLEARTEXT communication to $host not permitted by network security policy",
        )
      }
    } else {
      if (Protocol.H2_PRIOR_KNOWLEDGE in route.address.protocols) {
        throw UnknownServiceException("H2_PRIOR_KNOWLEDGE cannot be used with HTTPS")
      }
    }

    val tunnelRequest =
      when {

    platform.assumeHttp2Support()
    setsNegotiatedProtocolHeader(Protocol.HTTP_2)
  }

  private fun setsNegotiatedProtocolHeader(protocol: Protocol) {
    enableProtocol(protocol)
    server.enqueue(
      MockResponse(body = "A"),
    )
    client =
      client
        .newBuilder()
        .protocols(Arrays.asList(protocol, Protocol.HTTP_1_1))
        .build()

  ): Request? {
    // Does the client allow redirects?
    if (!client.followRedirects) return null

    val location = userResponse.header("Location") ?: return null
    // Don't follow redirects to unsupported protocols.
    val url = userResponse.request.url.resolve(location) ?: return null

    // If configured, don't follow redirects between SSL and non-SSL.
    val sameScheme = url.scheme == userResponse.request.url.scheme

  }

  @Test
  fun fromJavaNetUrlUnsupportedScheme() {
    // java.net.MalformedURLException: unknown protocol: mailto
    platform.assumeNotAndroid()

    // Accessing an URL protocol that was not enabled. The URL protocol mailto is not tested and
    // might not work as expected. It can be enabled by adding the --enable-url-protocols=mailto
    // option to the native-image command.
    platform.assumeNotGraalVMImage()