zf

http.ex (41580B)

---

 defmodule Mint.HTTP do
   @moduledoc """
   Processless HTTP connection data structure and functions.
 
   Single interface for `Mint.HTTP1` and `Mint.HTTP2` with support for version
   negotiation and proxies.
 
   ## Usage
 
   To establish a connection with a given server, use `connect/4`. This will
   return an opaque data structure that represents the connection
   to the server. To send a request, you can use `request/5`. Sending a request
   does not take care of the response to that request, instead we use `Mint.HTTP.stream/2`
   to process the response, which we will look at in just a bit. The connection is a
   wrapper around a TCP (`:gen_tcp` module) or SSL (`:ssl` module) socket that is
   set in **active mode** (with `active: :once`). This means that TCP/SSL messages
   will be delivered to the process that started the connection.
 
   The process that owns the connection is responsible for receiving the messages
   (for example, a GenServer is responsible for defining `handle_info/2`). However,
   `Mint.HTTP` makes it easy to identify TCP/SSL messages that are coming from the
   connection with the server with the `stream/2` function. This function takes the
   connection and a term and returns `:unknown` if the term is not a TCP/SSL message
   belonging to the connection. If the term *is* a message for the connection, then
   a response and a new connection are returned. It's important to store the new
   returned connection data structure over the old one since the connection is an
   immutable data structure.
 
   Let's see an example of a common workflow of connecting to a server, sending a
   request, and processing the response. We start by using `connect/3` to connect
   to a server.
 
       {:ok, conn} = Mint.HTTP.connect(:http, "httpbin.org", 80)
 
   `conn` is a data structure that represents the connection.
 
   To send a request, we use `request/5`.
 
       {:ok, conn, request_ref} = Mint.HTTP.request(conn, "GET", "/", [], nil)
 
   As you can see, sending a request returns a new updated `conn` struct and a
   `request_ref`. The updated connection struct is returned because the connection
   is an immutable structure keeping the connection state, so every action we do on it must return a new,
   possibly updated, connection that we're responsible for storing over the old
   one. `request_ref` is a unique reference that can be used to identify which
   request a given response belongs to.
 
   Now that we sent our request, we're responsible for receiving the messages that
   the TCP/SSL socket will send to our process. For example, in a GenServer
   we would do that with a `handle_info/2` callback. In our case, we're going to
   use a simple `receive`. `Mint.HTTP` provides a way to tell if a message comes
   from the socket wrapped by our connection or not: the `stream/2` function. If
   the message we pass to it is not destined for our connection, this function returns
   `:unknown`. Otherwise, it returns an updated connection and one or more responses.
 
       receive do
         message ->
           case Mint.HTTP.stream(conn, message) do
             :unknown -> handle_normal_message(message)
             {:ok, conn, responses} -> handle_responses(conn, responses)
           end
       end
 
   `responses` is a list of possible responses. The most common responses are:
 
     * `{:status, request_ref, status_code}` for the status code
     * `{:headers, request_ref, headers}` for the response headers
     * `{:data, request_ref, binary}` for pieces of the response body
     * `{:done, request_ref}` for the end of the response
 
   As you can see, all responses have the unique request reference as the second
   element of the tuple, so that we know which request the response belongs to.
   See `t:Mint.Types.response/0` for the full list of responses returned by `Mint.HTTP.stream/2`.
 
   ## Architecture
 
   A processless architecture like the one here requires a few modifications to how
   we use this HTTP client. Usually, you will want to create this data structure
   in a process that acts as *connection manager*. Sometimes, you might want to
   have a single process responsible for multiple connections, either to just one
   host or multiple hosts. For more discussion on architectures based off of this
   HTTP client, see the [*Architecture*](architecture.html) page in the docs.
 
   ## SSL certificates
 
   When using SSL, you can pass in your own CA certificate store or use one provided by Mint. Mint
   doesn't ship with the certificate store itself, but it has an optional dependency on
   [CAStore](https://github.com/elixir-mint/castore), which provides an up-to-date certificate store. If
   you don't want to use your own certificate store, just add `:castore` to your dependencies.
 
   Starting [from OTP
   25](https://www.erlang.org/blog/my-otp-25-highlights/#ca-certificates-can-be-fetched-from-the-os-standard-place),
   you can also load certificates from a file
   ([`:public_key.cacerts_load/1`](https://www.erlang.org/doc/man/public_key.html#cacerts_load-1))
   or from the OS
   ([`:public_key.cacerts_load/0`](https://www.erlang.org/doc/man/public_key.html#cacerts_load-0)).
   You can then use the certificates with
   [`:public_key.cacerts_get/0`](https://www.erlang.org/doc/man/public_key.html#cacerts_get-0):
 
       Mint.connect(:https, host, port, transport_opts: [cacerts: :public_key.cacerts_get()])
 
   ## Mode
 
   By default Mint operates in **active mode** meaning that the process that started the
   connection receives socket messages. Mint also supports **passive mode**, where no messages
   are sent to the process and the process needs to fetch data out of the socket manually.
   The mode can be controlled at connection time through the `:mode` option in `connect/4`
   or changed dynamically through `set_mode/2`. Passive mode is generally only recommended
   for special use cases.
   """
 
   import Mint.Core.Util
 
   alias Mint.{Types, TunnelProxy, UnsafeProxy}
   alias Mint.Core.Transport
 
   @behaviour Mint.Core.Conn
 
   @opaque t() :: Mint.HTTP1.t() | Mint.HTTP2.t()
 
   @doc """
   Macro to check that a given received `message` is intended for the given connection `conn`.
 
   This guard is useful in `receive` loops or in callbacks that handle generic messages (such as a
   `c:GenServer.handle_info/2` callback) so that you don't have to hand the `message` to
   `Mint.HTTP.stream/2` and check for the `:unknown_message` return value.
 
   This macro can be used in guards.
 
   **Note**: this macro is only available if you compile Mint with Elixir 1.10.0 or greater (and
   OTP 21+, which is required by Elixir 1.10.0 and on).
 
   ## Examples
 
       require Mint.HTTP
 
       {:ok, conn, request_ref} = Mint.HTTP.request(conn, "POST", "/", headers, "")
 
       receive do
         message when Mint.HTTP.is_connection_message(conn, message) ->
           Mint.HTTP.stream(conn, message)
 
         other ->
           # This message is related to something else or to some other connection
       end
 
   """
   define_is_connection_message_guard()
 
   @doc """
   Creates a new connection to a given server.
 
   Creates a new connection struct and establishes the connection to the given server,
   identified by the given `host` and `port` combination. Both HTTP and HTTPS are supported
   by passing respectively `:http` and `:https` as the `scheme`.
 
   The connection struct wraps a socket, which is created once the connection
   is established inside this function. If HTTP is used, then the created socket is a TCP
   socket and the `:gen_tcp` module is used to create that socket. If HTTPS is used, then
   the created socket is an SSL socket and the `:ssl` module is used to create that socket.
   The socket is created in active mode (with `active: :once`), which is why it is important
   to know the type of the socket: messages from the socket will be delivered directly to the
   process that creates the connection and tagged appropriately by the socket module (see the
   `:gen_tcp` and `:ssl` modules). See `stream/2` for more information on the messages and
   how to process them and on the socket mode.
 
   ## Options
 
     * `:hostname` - (string) explicitly provide the hostname used for the `Host` header,
       hostname verification, SNI, and so on. **Required when `address` is not a string.**
 
     * `:transport_opts` - (keyword) options to be given to the transport being used.
       These options will be merged with some default options that cannot be overridden.
       For more details, refer to the "Transport options" section below.
 
     * `:mode` - (`:active` or `:passive`) whether to set the socket to active or
       passive mode. See the "Mode" section in the module documentation and `set_mode/2`.
 
     * `:protocols` - (list of atoms) a list of protocols to try when connecting to the
       server. The possible values in the list are `:http1` for HTTP/1 and HTTP/1.1 and
       `:http2` for HTTP/2. If only one protocol is present in the list, then the connection
       will be forced to use that protocol. If both `:http1` and `:http2` are present in the
       list, then Mint will negotiate the protocol. See the section "Protocol negotiation"
       below for more information. Defaults to `[:http1, :http2]`.
 
     * `:proxy_headers` - a list of headers (`t:Mint.Types.headers/0`) to pass when using
       a proxy. They will be used for the `CONNECT` request in tunnel proxies or merged
       with every request for forward proxies.
 
   The following options are HTTP/1-specific and will force the connection
   to be an HTTP/1 connection.
 
     * `:proxy` - a `{scheme, address, port, opts}` tuple that identifies a proxy to
       connect to. See the "Proxying" section below for more information.
 
   The following options are HTTP/2-specific and will only be used on HTTP/2 connections.
 
     * `:client_settings` - (keyword) a list of client HTTP/2 settings to send to the
       server. See `Mint.HTTP2.put_settings/2` for more information. This is only used
       in HTTP/2 connections.
 
   ## Protocol negotiation
 
   If both `:http1` and `:http2` are present in the list passed in the `:protocols` option,
   the protocol negotiation happens in the following way:
 
     * If the scheme used to connect to the server is `:http`, then HTTP/1 or HTTP/1.1 is used.
 
     * If the scheme is `:https`, then ALPN negotiation is used to determine the right
       protocol. This means that the server will decide whether to use HTTP/1 or
       HTTP/2. If the server doesn't support protocol negotiation, we will fall back to
       HTTP/1. If the server negotiates a protocol that we don't know how to handle,
       `{:error, {:bad_alpn_protocol, protocol}}` is returned.
 
   ## Proxying
 
   You can set up proxying through the `:proxy` option, which is a tuple
   `{scheme, address, port, opts}` that identifies the proxy to connect to.
   Once a proxied connection is returned, the proxy is transparent to you and you
   can use the connection like a normal HTTP/1 connection.
 
   If the `scheme` is `:http`, we will connect to the host in the most compatible
   way, supporting older proxy servers. Data will be sent in clear text.
 
   If the connection scheme is `:https`, we will connect to the host with a tunnel
   through the proxy. Using `:https` for both the proxy and the connection scheme
   is not supported, it is recommended to use `:https` for the end host connection
   instead of the proxy.
 
   ## Transport options
 
   The options specified in `:transport_opts` are passed to the module that
   implements the socket interface: `:gen_tcp` when the scheme is `:http`, and
   `:ssl` when the scheme is `:https`. Please refer to the documentation for those
   modules, as well as for `:inet.setopts/2`, for a detailed description of all
   available options.
 
   The behaviour of some options is modified by Mint, as described below.
 
   A special case is the `:timeout` option, which is passed to the transport
   module's `connect` function to limit the amount of time to wait for the
   network connection to be established.
 
   Common options for `:http` and `:https`:
 
     * `:active` - controlled by the `:mode` option. Cannot be overridden.
 
     * `:mode` - set to `:binary`. Cannot be overridden.
 
     * `:packet` - set to `:raw`. Cannot be overridden.
 
     * `:timeout` - connect timeout in milliseconds. Defaults to `30_000` (30
       seconds), and may be overridden by the caller. Set to `:infinity` to
       disable the connect timeout.
 
   Options for `:https` only:
 
     * `:alpn_advertised_protocols` - managed by Mint. Cannot be overridden.
 
     * `:cacertfile` - if `:verify` is set to `:verify_peer` (the default) and
       no CA trust store is specified using the `:cacertfile` or `:cacerts`
       option, Mint will attempt to use the trust store from the
       [CAStore](https://github.com/elixir-mint/castore) package or raise an
       exception if this package is not available. Due to caching the
       `:cacertfile` option is more efficient than `:cacerts`.
 
     * `:ciphers` - defaults to the lists returned by
       `:ssl.filter_cipher_suites(:ssl.cipher_suites(:all, version), [])`
       where `version` is each value in the `:versions` setting. This list is
       then filtered according to the blocklist in
       [RFC7540 appendix A](https://tools.ietf.org/html/rfc7540#appendix-A);
       May be overridden by the caller. See the "Supporting older cipher suites"
       section below for some examples.
 
     * `:depth` - defaults to `4`. May be overridden by the caller.
 
     * `:partial_chain` - unless a custom `:partial_chain` function is specified,
       Mint will enable its own partial chain handler, which accepts server
       certificate chains containing a certificate that was issued by a
       CA certificate in the CA trust store, even if that certificate is not
       last in the chain. This improves interoperability with some servers
       (for example, with a cross-signed intermediate CA or some misconfigured servers),
       but is a less strict interpretation of the TLS specification than the
       Erlang/OTP default behaviour.
 
     * `:reuse_sessions` - defaults to `true`. May be overridden by the caller. If
       `:"tlsv1.3"` is the only TLS version specified, `:reuse_sessions` will be
       removed from the options.
 
     * `:secure_renegotiate` - defaults to `true`. May be overridden by the
       caller. If `:"tlsv1.3"` is the only TLS version specified, `:secure_renegotiate`
       will be removed from the options.
 
     * `:server_name_indication` - defaults to specified destination hostname.
       May be overridden by the caller.
 
     * `:verify` - defaults to `:verify_peer`. May be overridden by the caller.
 
     * `:verify_fun` - unless a custom `:verify_fun` is specified, or `:verify`
       is set to `:verify_none`, Mint will enable hostname verification with
       support for wildcards in the server's 'SubjectAltName' extension, similar
       to the behaviour implemented in
       `:public_key.pkix_verify_hostname_match_fun(:https)` in recent Erlang/OTP
       releases. This improves compatibility with recently issued wildcard
       certificates also on older Erlang/OTP releases.
 
     * `:versions` - defaults to `[:"tlsv1.2"]` (TLS v1.2 only). May be
       overridden by the caller.
 
   ### Supporting older cipher suites
 
   By default only a small list of modern cipher suites is enabled, in compliance
   with the HTTP/2 specification. Some servers, in particular HTTP/1 servers, may
   not support any of these cipher suites, resulting in TLS handshake failures or
   closed connections.
 
   To select the default cipher suites of Erlang/OTP (including for example
   AES-CBC), use the following `:transport_opts`:
 
       # Erlang/OTP 20.3 or later:
       transport_opts: [ciphers: :ssl.cipher_suites(:default, :"tlsv1.2")]
       # Older versions:
       transport_opts: [ciphers: :ssl.cipher_suites()]
 
   Recent Erlang/OTP releases do not enable RSA key exchange by default, due to
   known weaknesses. If necessary, you can build a cipher list with RSA exchange
   and use it in `:transport_opts`:
 
       ciphers =
         :ssl.cipher_suites(:all, :"tlsv1.2")
         |> :ssl.filter_cipher_suites(
           key_exchange: &(&1 == :rsa),
           cipher: &(&1 in [:aes_256_gcm, :aes_128_gcm, :aes_256_cbc, :aes_128_cbc])
         )
         |> :ssl.append_cipher_suites(:ssl.cipher_suites(:default, :"tlsv1.2"))
 
   ## Examples
 
       {:ok, conn} = Mint.HTTP.connect(:http, "httpbin.org", 80)
 
   Using a proxy:
 
       proxy = {:http, "myproxy.example.com", 80, []}
       {:ok, conn} = Mint.HTTP.connect(:https, "httpbin.org", 443, proxy: proxy)
 
   Forcing the connection to be an HTTP/2 connection:
 
       {:ok, conn} = Mint.HTTP.connect(:https, "httpbin.org", 443, protocols: [:http2])
 
   Enable all default cipher suites of Erlang/OTP (release 20.3 or later):
 
       opts = [transport_opts: [ciphers: :ssl.cipher_suites(:default, :"tlsv1.2")]]
       {:ok, conn} = Mint.HTTP.connect(:https, "httpbin.org", 443, opts)
 
   """
   @spec connect(Types.scheme(), Types.address(), :inet.port_number(), keyword()) ::
           {:ok, t()} | {:error, Types.error()}
   def connect(scheme, address, port, opts \\ []) do
     case Keyword.fetch(opts, :proxy) do
       {:ok, {proxy_scheme, proxy_address, proxy_port, proxy_opts}} ->
         case scheme_to_transport(scheme) do
           Transport.TCP ->
             proxy = {proxy_scheme, proxy_address, proxy_port}
             host = {scheme, address, port}
             opts = Keyword.merge(opts, proxy_opts)
             UnsafeProxy.connect(proxy, host, opts)
 
           Transport.SSL ->
             proxy = {proxy_scheme, proxy_address, proxy_port, proxy_opts}
             host = {scheme, address, port, opts}
             TunnelProxy.connect(proxy, host)
         end
 
       :error ->
         Mint.Negotiate.connect(scheme, address, port, opts)
     end
   end
 
   @doc false
   @spec upgrade(
           module(),
           Mint.Types.socket(),
           Types.scheme(),
           String.t(),
           :inet.port_number(),
           keyword()
         ) :: {:ok, t()} | {:error, Types.error()}
   def upgrade(old_transport, transport_state, scheme, hostname, port, opts),
     do: Mint.Negotiate.upgrade(old_transport, transport_state, scheme, hostname, port, opts)
 
   @doc """
   Returns the protocol used by the current connection.
 
   ## Examples
 
       iex> Mint.HTTP.protocol(%Mint.HTTP1{})
       :http1
 
       iex> Mint.HTTP.protocol(%Mint.HTTP2{})
       :http2
   """
   if Version.compare(System.version(), "1.7.0") in [:eq, :gt] do
     @doc since: "1.4.0"
   end
 
   @spec protocol(t()) :: :http1 | :http2
   def protocol(%Mint.HTTP1{}), do: :http1
   def protocol(%Mint.HTTP2{}), do: :http2
   def protocol(%Mint.UnsafeProxy{state: internal_conn}), do: protocol(internal_conn)
 
   @doc false
   @impl true
   @spec initiate(
           module(),
           Types.socket(),
           String.t(),
           :inet.port_number(),
           keyword()
         ) :: {:ok, t()} | {:error, Types.error()}
   def initiate(transport, transport_state, hostname, port, opts),
     do: Mint.Negotiate.initiate(transport, transport_state, hostname, port, opts)
 
   @doc """
   Closes the given connection.
 
   This function closes the socket wrapped by the given connection. Once the socket
   is closed, the connection goes into the "closed" state and `open?/1` returns `false`.
   You can throw away a closed connection.
 
   Closing a connection does not guarantee that data that is in flight gets delivered
   to the server.
 
   Always returns `{:ok, conn}` where `conn` is the updated connection.
 
   ## Examples
 
       {:ok, conn} = Mint.HTTP.close(conn)
 
   """
   @impl true
   @spec close(t()) :: {:ok, t()}
   def close(conn), do: conn_module(conn).close(conn)
 
   @doc """
   Checks whether the connection is open.
 
   This function returns `true` if the connection is open, `false` otherwise. It should
   be used to check that a connection is open before sending requests or performing
   operations that involve talking to the server.
 
   The `type` argument can be used to tell whether the connection is closed only for reading,
   only for writing, or for both. In HTTP/1, a closed connection is always closed for
   both reading and writing. In HTTP/2, the connection can be closed only for writing but
   not for reading, meaning that you cannot send any more data to the server but you can
   still receive data from the server. See the "Closed connection" section in the module
   documentation of `Mint.HTTP2`.
 
   If a connection is not open for reading and writing, it has become useless and you should
   get rid of it. If you still need a connection to the server, start a new connection
   with `connect/4`.
 
   ## Examples
 
       {:ok, conn} = Mint.HTTP.connect(:http, "httpbin.org", 80)
       Mint.HTTP.open?(conn)
       #=> true
 
   """
   @impl true
   @spec open?(t(), :read | :write | :read_write) :: boolean()
   def open?(conn, type \\ :read_write), do: conn_module(conn).open?(conn, type)
 
   @doc """
   Sends a request to the connected server.
 
   This function sends a new request to the server that `conn` is connected to.
   `method` is a string representing the method for the request, such as `"GET"`
   or `"POST"`. `path` is the path on the host to send the request to. `headers`
   is a list of request headers in the form `{header_name, header_value}` with
   `header_name` and `header_value` being strings. `body` can have one of three
   values:
 
     * `nil` - no body is sent with the request.
 
     * iodata - the body to send for the request.
 
     * `:stream` - when the value of the body is `:stream` the request
       body can be streamed on the connection. See `stream_request_body/3`.
       In HTTP/1, you can't open a request if the body of another request is
       streaming.
 
   If the request is sent correctly, this function returns `{:ok, conn, request_ref}`.
   `conn` is an updated connection that should be stored over the old connection.
   `request_ref` is a unique reference that can be used to match on responses for this
   request that are returned by `stream/2`. See `stream/2` for more information.
 
   If there's an error with sending the request, `{:error, conn, reason}` is returned.
   `reason` is the cause of the error. `conn` is an updated connection. It's important
   to store the returned connection over the old connection in case of errors too, because
   the state of the connection might change when there are errors as well. An error when
   sending a request **does not** necessarily mean that the connection is closed. Use
   `open?/1` to verify that the connection is open.
 
   Requests can be pipelined so the full response does not have to received
   before the next request can be sent. It is up to users to verify that the
   server supports pipelining and that the request is safe to pipeline.
 
   In HTTP/1, you can't open a request if the body of another request is streaming.
   See `Mint.HTTP1.request/5` for more information.
 
   For a quick discussion on HTTP/2 streams and requests, see the `Mint.HTTP2` module and
   `Mint.HTTP2.request/5`.
 
   ## The `content-length` header
 
   If you don't set the `content-length` header and you send a body with the request (that
   is, not `nil` and not `:stream`), then Mint will add a default `content-length` header
   to your request. If you're using HTTP/2 and streaming the request, you may provide the
   `content-length` header yourself. If you're using HTTP/1, Mint will do chunked
   transfer-encoding when a content-length is not provided (see `Mint.HTTP1.request/5`).
 
   ## Examples
 
       Mint.HTTP.request(conn, "GET", "/", _headers = [], _body = nil)
       Mint.HTTP.request(conn, "POST", "/path", [{"content-type", "application/json"}], "{}")
 
   """
   @impl true
   @spec request(
           t(),
           method :: String.t(),
           path :: String.t(),
           Types.headers(),
           body :: iodata() | nil | :stream
         ) ::
           {:ok, t(), Types.request_ref()}
           | {:error, t(), Types.error()}
 
   def request(conn, method, path, headers, body),
     do: conn_module(conn).request(conn, method, path, headers, body)
 
   @doc """
   Streams a chunk of the request body on the connection or signals the end of the body.
 
   If a request is opened (through `request/5`) with the body as `:stream`, then the
   body can be streamed through this function. The function takes a `conn`, a
   `request_ref` returned by `request/5` to identify the request to stream the body for,
   and a chunk of body to stream. The value of chunk can be:
 
     * iodata - a chunk of iodata is transmitted to the server as part of the body
       of the request. If the chunk is empty, in HTTP/1 it's a no-op, while in HTTP/2
       a `DATA` frame will be sent.
 
     * `:eof` - signals the end of the streaming of the request body for the given
       request. Usually the server won't send any reply until this is sent.
 
     * `{:eof, trailing_headers}` - sends **trailing headers** and signals the end
       of the streaming of the request body for the given request. This behaves the
       same way as `:eof` but first sends the trailing headers. See the "Trailing headers"
       section below.
 
   This function always returns an updated connection to be stored over the old connection.
 
   For information about transfer encoding and content length in HTTP/1, see
   `Mint.HTTP1.stream_request_body/3`.
 
   ## Trailing headers
 
   HTTP trailing headers can be sent after the body of a request. The behaviour is slightly
   different for HTTP/1 and HTTP/2.
 
   In HTTP/1, trailing headers are only supported if the transfer encoding is set to
   `chunked`. See `Mint.HTTP1.stream_request_body/3` for more information on chunked
   transfer encoding.
 
   In HTTP/2, trailing headers behave like normal headers. You don't need to care
   about the transfer encoding.
 
   ### The `trailer` header
 
   As specified in [section 4.4 of RFC 7230](https://tools.ietf.org/html/rfc7230#section-4.4),
   in HTTP/1 you need to specify which headers you're going to send as trailing
   headers using the `trailer` header. The `trailer` header applies to both HTTP/1
   and HTTP/2. See the examples below for more information.
 
   ### The `te` header
 
   As specified in  [section 4.3 of RFC 7230](https://tools.ietf.org/html/rfc7230#section-4.3),
   the `te` (or `TE`) header is used to specify which transfer-encodings the client
   is willing to accept (besides `chunked`). Mint supports decoding of trailing headers,
   but if you want to notify the server that you are accepting trailing headers,
   use the `trailers` value in the `te` header. For example:
 
       Mint.HTTP.request(conn, "GET", "/", [{"te", "trailers"}], "some body")
 
   Note that the `te` header can also be used to communicate which encodings you
   support to the server.
 
   ## Examples
 
   Let's see an example of streaming an empty JSON object (`{}`) by streaming one curly
   brace at a time.
 
       headers = [{"content-type", "application/json"}, {"content-length", "2"}]
       {:ok, conn, request_ref} = Mint.HTTP.request(conn, "POST", "/", headers, :stream)
       {:ok, conn} = Mint.HTTP.stream_request_body(conn, request_ref, "{")
       {:ok, conn} = Mint.HTTP.stream_request_body(conn, request_ref, "}")
       {:ok, conn} = Mint.HTTP.stream_request_body(conn, request_ref, :eof)
 
   Here's an example of sending trailing headers:
 
       headers = [{"content-type", "application/json"}, {"trailer", "my-trailer, x-expires"}]
       {:ok, conn, request_ref} = Mint.HTTP.request(conn, "POST", "/", headers, :stream)
 
       {:ok, conn} = Mint.HTTP.stream_request_body(conn, request_ref, "{}")
 
       trailing_headers = [{"my-trailer", "xxx"}, {"x-expires", "10 days"}]
       {:ok, conn} = Mint.HTTP.stream_request_body(conn, request_ref, {:eof, trailing_headers})
 
   """
   @impl true
   @spec stream_request_body(
           t(),
           Types.request_ref(),
           iodata() | :eof | {:eof, trailing_headers :: Types.headers()}
         ) ::
           {:ok, t()} | {:error, t(), Types.error()}
   def stream_request_body(conn, ref, body),
     do: conn_module(conn).stream_request_body(conn, ref, body)
 
   @doc """
   Streams the next batch of responses from the given message.
 
   This function processes a "message" which can be any term, but should be
   a message received by the process that owns the connection. **Processing**
   a message means that this function will parse it and check if it's a message
   that is directed to this connection, that is, a TCP/SSL message received on the
   connection's socket. If it is, then this function will parse the message,
   turn it into a list of responses, and possibly take action given the responses.
   As an example of an action that this function could perform, if the server sends
   a ping request this function will transparently take care of pinging the server back.
 
   If there's no error, this function returns `{:ok, conn, responses}` where `conn` is
   the updated connection and `responses` is a list of responses. See the "Responses"
   section below. If there's an error, `{:error, conn, reason, responses}` is returned,
   where `conn` is the updated connection, `reason` is the error reason, and `responses`
   is a list of responses that were correctly parsed before the error.
 
   If the given `message` is not from the connection's socket,
   this function returns `:unknown`.
 
   ## Socket mode
 
   Mint sets the socket in `active: :once` mode. This means that a single socket
   message at a time is delivered to the process that owns the connection. After
   a message is delivered, then no other messages are delivered (we say the socket
   goes in *passive* mode). When `stream/2` is called to process the message that
   was received, Mint sets the socket back to `active: :once`. This is good to know
   in order to understand how the socket is handled by Mint, but in normal usage
   it just means that you will process one message at a time with `stream/2` and not
   pay too much attention to the socket mode.
 
   Mint also supports passive mode to avoid receiving messages. See the "Mode" section
   in the module documentation.
 
   ## Responses
 
   Each possible response returned by this function is a tuple with two or more elements.
   The first element is always an atom that identifies the kind of response. The second
   element is a unique reference `t:Mint.Types.request_ref/0` that identifies the request
   that the response belongs to. This is the term returned by `request/5`. After these
   two elements, there can be response-specific terms as well, documented below.
 
   These are the possible responses that can be returned.
 
     * `{:status, request_ref, status_code}` - returned when the server replied
       with a response status code. The status code is a non-negative integer.
       You can have zero or more `1xx` `:status` and `:headers` responses for a
       single request, but they all precede a single non-`1xx` `:status` response.
 
     * `{:headers, request_ref, headers}` - returned when the server replied
       with a list of headers. Headers are in the form `{header_name, header_value}`
       with `header_name` and `header_value` being strings. A single `:headers` response
       will come after the `:status` response. A single `:headers` response may come
       after all the `:data` responses if **trailing headers** are present.
 
     * `{:data, request_ref, binary}` - returned when the server replied with
       a chunk of response body (as a binary). The request shouldn't be considered done
       when a piece of body is received because multiple chunks could be received. The
       request is done when the `:done` response is returned.
 
     * `{:done, request_ref}` - returned when the server signaled the request
       as done. When this is received, the response body and headers can be considered
       complete and it can be assumed that no more responses will be received for this
       request. This means that for example, you can stop holding on to the request ref
       for this request.
 
     * `{:error, request_ref, reason}` - returned when there is an error that
       only affects the request and not the whole connection. For example, if the
       server sends bad data on a given request, that request will be closed and an error
       for that request will be returned among the responses, but the connection will
       remain alive and well.
 
     * `{:pong, request_ref}` - returned when a server replies to a ping
       request sent by the client. This response type is HTTP/2-specific
       and will never be returned by an HTTP/1 connection. See `Mint.HTTP2.ping/2`
       for more information.
 
     * `{:push_promise, request_ref, promised_request_ref, headers}` - returned when
       the server sends a server push to the client. This response type is HTTP/2 specific
       and will never be returned by an HTTP/1 connection. See `Mint.HTTP2` for more
       information on server pushes.
 
   ## Examples
 
   Let's assume we have a function called `receive_next_and_stream/1` that takes
   a connection and then receives the next message, calls `stream/2` with that message
   as an argument, and then returns the result of `stream/2`:
 
       defp receive_next_and_stream(conn) do
         receive do
           message -> Mint.HTTP.stream(conn, message)
         end
       end
 
   Now, we can see an example of a workflow involving `stream/2`.
 
       {:ok, conn, request_ref} = Mint.HTTP.request(conn, "GET", "/", _headers = [])
 
       {:ok, conn, responses} = receive_next_and_stream(conn)
       responses
       #=> [{:status, ^request_ref, 200}]
 
       {:ok, conn, responses} = receive_next_and_stream(conn)
       responses
       #=> [{:headers, ^request_ref, [{"Content-Type", "application/json"}]},
       #=>  {:data, ^request_ref, "{"}]
 
       {:ok, conn, responses} = receive_next_and_stream(conn)
       responses
       #=> [{:data, ^request_ref, "}"}, {:done, ^request_ref}]
 
   """
   @impl true
   @spec stream(t(), term()) ::
           {:ok, t(), [Types.response()]}
           | {:error, t(), Types.error(), [Types.response()]}
           | :unknown
   def stream(conn, message), do: conn_module(conn).stream(conn, message)
 
   @doc """
   Returns the number of open requests.
 
   Open requests are requests that have not yet received a `:done` response.
   This function returns the number of open requests for both HTTP/1 and HTTP/2,
   but for HTTP/2 only client-initiated requests are considered as open requests.
   See `Mint.HTTP2.open_request_count/1` for more information.
 
   ## Examples
 
       {:ok, conn, _ref} = Mint.HTTP.request(conn, "GET", "/", [])
       Mint.HTTP.open_request_count(conn)
       #=> 1
 
   """
   @impl true
   @spec open_request_count(t()) :: non_neg_integer()
   def open_request_count(conn), do: conn_module(conn).open_request_count(conn)
 
   @doc """
   Receives data from the socket in a blocking way.
 
   By default Mint operates in active mode, meaning that messages are delivered
   to the process that started the connection. However, Mint also supports passive
   mode (see the "Mode" section in the module documentation).
 
   In passive mode, you'll need to manually get bytes out of the socket. You can
   do that with this function.
 
   `byte_count` is the number of bytes you want out of the socket. If `byte_count`
   is `0`, all available bytes will be returned.
 
   `timeout` is the maximum time to wait before returning an error.
 
   This function will raise an error if the socket is in active mode.
 
   ## Examples
 
       {:ok, conn, responses} = Mint.HTTP.recv(conn, 0, 5000)
 
   """
   @impl true
   @spec recv(t(), non_neg_integer(), timeout()) ::
           {:ok, t(), [Types.response()]}
           | {:error, t(), Types.error(), [Types.response()]}
   def recv(conn, byte_count, timeout), do: conn_module(conn).recv(conn, byte_count, timeout)
 
   @doc """
   Changes the mode of the underlying socket.
 
   To use the connection in *active mode*, where the process that started the
   connection receives socket messages, set the mode to `:active` (see also `stream/2`).
   To use the connection in *passive mode*, where you need to manually receive data
   from the socket, set the mode to `:passive` (see also `recv/3`).
 
   The mode can also be controlled at connection time by the `:mode` option passed
   to `connect/4`.
 
   Note that if you're switching from active to passive mode, you still might have
   socket messages in the process mailbox that you need to consume before doing
   any other operation on the connection.
 
   See the "Mode" section in the module documentation for more information on modes.
 
   ## Examples
 
       {:ok, conn} = Mint.HTTP.set_mode(conn, :passive)
 
   """
   @impl true
   @spec set_mode(t(), :active | :passive) :: {:ok, t()} | {:error, Types.error()}
   def set_mode(conn, mode), do: conn_module(conn).set_mode(conn, mode)
 
   @doc """
   Changes the *controlling process* of the given connection to `new_pid`.
 
   The **controlling process** is a concept that comes from the Erlang TCP and
   SSL implementations. The controlling process of a connection is the process
   that started the connection and that receives the messages for that connection.
   You can change the controlling process of a connection through this function.
 
   This function also takes care of "transferring" all the connection messages
   that are in the mailbox of the current controlling process to the new
   controlling process.
 
   Remember that the connection is a data structure, so if you
   change the controlling process it doesn't mean you "transferred" the
   connection data structure itself to the other process, which you have
   to do manually (for example by sending the connection data structure to the
   new controlling process). If you do that, be careful of race conditions
   and be sure to retrieve the connection in the new controlling process
   before accepting connection messages in the new controlling process.
   In fact, this function is guaranteed to return the connection unchanged,
   so you are free to ignore the connection entry returned in `{:ok, conn}`.
 
   ## Examples
 
       send(new_pid, {:conn, conn})
       {:ok, conn} = Mint.HTTP.controlling_process(conn, new_pid)
 
       # In the "new_pid" process
       receive do
         {:conn, conn} ->
           # Will receive connection messages.
       end
 
   """
   @impl true
   @spec controlling_process(t(), pid()) :: {:ok, t()} | {:error, Types.error()}
   def controlling_process(conn, new_pid), do: conn_module(conn).controlling_process(conn, new_pid)
 
   @doc """
   Assigns a new private key and value in the connection.
 
   This storage is meant to be used to associate metadata with the connection and
   it can be useful when handling multiple connections.
 
   The given `key` must be an atom, while the given `value` can be an arbitrary
   term. The return value of this function is an updated connection.
 
   See also `get_private/3` and `delete_private/2`.
 
   ## Examples
 
   Let's see an example of putting a value and then getting it:
 
       conn = Mint.HTTP.put_private(conn, :client_name, "Mint")
       Mint.HTTP.get_private(conn, :client_name)
       #=> "Mint"
 
   """
   @impl true
   @spec put_private(t(), atom(), term()) :: t()
   def put_private(conn, key, value), do: conn_module(conn).put_private(conn, key, value)
 
   @doc """
   Gets a private value from the connection.
 
   Retrieves a private value previously set with `put_private/3` from the connection.
   `key` is the key under which the value to retrieve is stored. `default` is a default
   value returned in case there's no value under the given key.
 
   See also `put_private/3` and `delete_private/2`.
 
   ## Examples
 
       conn = Mint.HTTP.put_private(conn, :client_name, "Mint")
 
       Mint.HTTP.get_private(conn, :client_name)
       #=> "Mint"
 
       Mint.HTTP.get_private(conn, :non_existent)
       #=> nil
 
   """
   @impl true
   @spec get_private(t(), atom(), term()) :: term()
   def get_private(conn, key, default \\ nil),
     do: conn_module(conn).get_private(conn, key, default)
 
   @doc """
   Deletes a value in the private store.
 
   Deletes the private value stored under `key` in the connection. Returns the
   updated connection.
 
   See also `put_private/3` and `get_private/3`.
 
   ## Examples
 
       conn = Mint.HTTP.put_private(conn, :client_name, "Mint")
 
       Mint.HTTP.get_private(conn, :client_name)
       #=> "Mint"
 
       conn = Mint.HTTP.delete_private(conn, :client_name)
       Mint.HTTP.get_private(conn, :client_name)
       #=> nil
 
   """
   @impl true
   @spec delete_private(t(), atom()) :: t()
   def delete_private(conn, key), do: conn_module(conn).delete_private(conn, key)
 
   @doc """
   Gets the socket associated with the connection.
 
   Do not use the returned socket to change its internal state. Only read information from the socket.
   For instance, use `:ssl.connection_information/2` to retrieve TLS-specific information from the
   socket.
   """
   @impl true
   @spec get_socket(t()) :: Mint.Types.socket()
   def get_socket(conn), do: conn_module(conn).get_socket(conn)
 
   @doc """
   Gets the proxy headers associated with the connection in the `CONNECT` method.
 
   When using tunnel proxy and HTTPs, the only way to exchange data with
   the proxy is through headers in the `CONNECT` method.
   """
   if Version.compare(System.version(), "1.7.0") in [:eq, :gt] do
     @doc since: "1.4.0"
   end
 
   @impl true
   @spec get_proxy_headers(t()) :: Mint.Types.headers()
   def get_proxy_headers(conn), do: conn_module(conn).get_proxy_headers(conn)
 
   ## Helpers
 
   defp conn_module(%UnsafeProxy{}), do: UnsafeProxy
   defp conn_module(%Mint.HTTP1{}), do: Mint.HTTP1
   defp conn_module(%Mint.HTTP2{}), do: Mint.HTTP2
 end