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