git.squeep.com Git - akkoma/blob - lib/pleroma/web/media_proxy/media_proxy_controller.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.MediaProxy.MediaProxyController do
   6   use Pleroma.Web, :controller
   7
   8   alias Pleroma.Config
   9   alias Pleroma.Helpers.MediaHelper
  10   alias Pleroma.Helpers.UriHelper
  11   alias Pleroma.ReverseProxy
  12   alias Pleroma.Web.MediaProxy
  13   alias Plug.Conn
  14
  15   @min_content_length_for_preview 100 * 1024
  16
  17   def remote(conn, %{"sig" => sig64, "url" => url64}) do
  18     with {_, true} <- {:enabled, MediaProxy.enabled?()},
  19          {:ok, url} <- MediaProxy.decode_url(sig64, url64),
  20          {_, false} <- {:in_banned_urls, MediaProxy.in_banned_urls(url)},
  21          :ok <- MediaProxy.verify_request_path_and_url(conn, url) do
  22       ReverseProxy.call(conn, url, media_proxy_opts())
  23     else
  24       {:enabled, false} ->
  25         send_resp(conn, 404, Conn.Status.reason_phrase(404))
  26
  27       {:in_banned_urls, true} ->
  28         send_resp(conn, 404, Conn.Status.reason_phrase(404))
  29
  30       {:error, :invalid_signature} ->
  31         send_resp(conn, 403, Conn.Status.reason_phrase(403))
  32
  33       {:wrong_filename, filename} ->
  34         redirect(conn, external: MediaProxy.build_url(sig64, url64, filename))
  35     end
  36   end
  37
  38   def preview(%Conn{} = conn, %{"sig" => sig64, "url" => url64}) do
  39     with {_, true} <- {:enabled, MediaProxy.preview_enabled?()},
  40          {:ok, url} <- MediaProxy.decode_url(sig64, url64) do
  41       handle_preview(conn, url)
  42     else
  43       {:enabled, false} ->
  44         send_resp(conn, 404, Conn.Status.reason_phrase(404))
  45
  46       {:error, :invalid_signature} ->
  47         send_resp(conn, 403, Conn.Status.reason_phrase(403))
  48
  49       {:wrong_filename, filename} ->
  50         redirect(conn, external: MediaProxy.build_preview_url(sig64, url64, filename))
  51     end
  52   end
  53
  54   defp handle_preview(conn, url) do
  55     media_proxy_url = MediaProxy.url(url)
  56
  57     with {:ok, %{status: status} = head_response} when status in 200..299 <-
  58            Pleroma.HTTP.request("head", media_proxy_url, [], [], pool: :media) do
  59       content_type = Tesla.get_header(head_response, "content-type")
  60       content_length = Tesla.get_header(head_response, "content-length")
  61       content_length = content_length && String.to_integer(content_length)
  62
  63       handle_preview(content_type, content_length, conn, media_proxy_url)
  64     else
  65       # If HEAD failed, redirecting to media proxy URI doesn't make much sense; returning an error
  66       {_, %{status: status}} ->
  67         send_resp(conn, :failed_dependency, "Can't fetch HTTP headers (HTTP #{status}).")
  68
  69       {:error, :recv_response_timeout} ->
  70         send_resp(conn, :failed_dependency, "HEAD request timeout.")
  71
  72       _ ->
  73         send_resp(conn, :failed_dependency, "Can't fetch HTTP headers.")
  74     end
  75   end
  76
  77   defp handle_preview(
  78          "image/gif" = _content_type,
  79          _content_length,
  80          %{params: %{"static" => static}} = conn,
  81          media_proxy_url
  82        )
  83        when static in ["true", true] do
  84     handle_jpeg_preview(conn, media_proxy_url)
  85   end
  86
  87   defp handle_preview(
  88          _content_type,
  89          _content_length,
  90          %{params: %{"static" => static}} = conn,
  91          _media_proxy_url
  92        )
  93        when static in ["true", true] do
  94     uri_without_static_param = UriHelper.modify_uri_params(current_url(conn), %{}, ["static"])
  95     redirect(conn, external: uri_without_static_param)
  96   end
  97
  98   defp handle_preview("image/gif" = _content_type, _content_length, conn, media_proxy_url) do
  99     redirect(conn, external: media_proxy_url)
 100   end
 101
 102   defp handle_preview("image/" <> _ = _content_type, content_length, conn, media_proxy_url)
 103        when is_integer(content_length) and content_length > 0 and
 104               content_length < @min_content_length_for_preview do
 105     redirect(conn, external: media_proxy_url)
 106   end
 107
 108   defp handle_preview("image/png" <> _ = _content_type, _content_length, conn, media_proxy_url) do
 109     handle_png_preview(conn, media_proxy_url)
 110   end
 111
 112   defp handle_preview("image/" <> _ = _content_type, _content_length, conn, media_proxy_url) do
 113     handle_jpeg_preview(conn, media_proxy_url)
 114   end
 115
 116   defp handle_preview("video/" <> _ = _content_type, _content_length, conn, media_proxy_url) do
 117     handle_video_preview(conn, media_proxy_url)
 118   end
 119
 120   defp handle_preview(_unsupported_content_type, _content_length, conn, media_proxy_url) do
 121     fallback_on_preview_error(conn, media_proxy_url)
 122   end
 123
 124   defp handle_png_preview(conn, media_proxy_url) do
 125     quality = Config.get!([:media_preview_proxy, :image_quality])
 126
 127     with {thumbnail_max_width, thumbnail_max_height} <- thumbnail_max_dimensions(),
 128          {:ok, thumbnail_binary} <-
 129            MediaHelper.image_resize(
 130              media_proxy_url,
 131              %{
 132                max_width: thumbnail_max_width,
 133                max_height: thumbnail_max_height,
 134                quality: quality,
 135                format: "png"
 136              }
 137            ) do
 138       conn
 139       |> put_preview_response_headers(["image/png", "preview.png"])
 140       |> send_resp(200, thumbnail_binary)
 141     else
 142       _ ->
 143         fallback_on_preview_error(conn, media_proxy_url)
 144     end
 145   end
 146
 147   defp handle_jpeg_preview(conn, media_proxy_url) do
 148     quality = Config.get!([:media_preview_proxy, :image_quality])
 149
 150     with {thumbnail_max_width, thumbnail_max_height} <- thumbnail_max_dimensions(),
 151          {:ok, thumbnail_binary} <-
 152            MediaHelper.image_resize(
 153              media_proxy_url,
 154              %{max_width: thumbnail_max_width, max_height: thumbnail_max_height, quality: quality}
 155            ) do
 156       conn
 157       |> put_preview_response_headers()
 158       |> send_resp(200, thumbnail_binary)
 159     else
 160       _ ->
 161         fallback_on_preview_error(conn, media_proxy_url)
 162     end
 163   end
 164
 165   defp handle_video_preview(conn, media_proxy_url) do
 166     with {:ok, thumbnail_binary} <-
 167            MediaHelper.video_framegrab(media_proxy_url) do
 168       conn
 169       |> put_preview_response_headers()
 170       |> send_resp(200, thumbnail_binary)
 171     else
 172       _ ->
 173         fallback_on_preview_error(conn, media_proxy_url)
 174     end
 175   end
 176
 177   defp fallback_on_preview_error(conn, media_proxy_url) do
 178     redirect(conn, external: media_proxy_url)
 179   end
 180
 181   defp put_preview_response_headers(
 182          conn,
 183          [content_type, filename] = _content_info \\ ["image/jpeg", "preview.jpg"]
 184        ) do
 185     conn
 186     |> put_resp_header("content-type", content_type)
 187     |> put_resp_header("content-disposition", "inline; filename=\"#{filename}\"")
 188     |> put_resp_header("cache-control", ReverseProxy.default_cache_control_header())
 189   end
 190
 191   defp thumbnail_max_dimensions do
 192     config = Config.get([:media_preview_proxy], [])
 193
 194     thumbnail_max_width = Keyword.fetch!(config, :thumbnail_max_width)
 195     thumbnail_max_height = Keyword.fetch!(config, :thumbnail_max_height)
 196
 197     {thumbnail_max_width, thumbnail_max_height}
 198   end
 199
 200   defp media_proxy_opts do
 201     Config.get([:media_proxy, :proxy_opts], [])
 202   end
 203 end