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.ReverseProxy
  11   alias Pleroma.Web.MediaProxy
  12
  13   def remote(conn, %{"sig" => sig64, "url" => url64}) do
  14     with {_, true} <- {:enabled, MediaProxy.enabled?()},
  15          {:ok, url} <- MediaProxy.decode_url(sig64, url64),
  16          {_, false} <- {:in_banned_urls, MediaProxy.in_banned_urls(url)},
  17          :ok <- MediaProxy.verify_request_path_and_url(conn, url) do
  18       ReverseProxy.call(conn, url, media_proxy_opts())
  19     else
  20       {:enabled, false} ->
  21         send_resp(conn, 404, Plug.Conn.Status.reason_phrase(404))
  22
  23       {:in_banned_urls, true} ->
  24         send_resp(conn, 404, Plug.Conn.Status.reason_phrase(404))
  25
  26       {:error, :invalid_signature} ->
  27         send_resp(conn, 403, Plug.Conn.Status.reason_phrase(403))
  28
  29       {:wrong_filename, filename} ->
  30         redirect(conn, external: MediaProxy.build_url(sig64, url64, filename))
  31     end
  32   end
  33
  34   def preview(conn, %{"sig" => sig64, "url" => url64}) do
  35     with {_, true} <- {:enabled, MediaProxy.preview_enabled?()},
  36          {:ok, url} <- MediaProxy.decode_url(sig64, url64),
  37          :ok <- MediaProxy.verify_request_path_and_url(conn, url) do
  38       handle_preview(conn, url)
  39     else
  40       {:enabled, false} ->
  41         send_resp(conn, 404, Plug.Conn.Status.reason_phrase(404))
  42
  43       {:error, :invalid_signature} ->
  44         send_resp(conn, 403, Plug.Conn.Status.reason_phrase(403))
  45
  46       {:wrong_filename, filename} ->
  47         redirect(conn, external: MediaProxy.build_preview_url(sig64, url64, filename))
  48     end
  49   end
  50
  51   defp handle_preview(conn, url) do
  52     with {:ok, %{status: status} = head_response} when status in 200..299 <-
  53            Tesla.head(url,
  54              opts: [adapter: [timeout: preview_head_request_timeout(), follow_redirect: true]]
  55            ) do
  56       content_type = Tesla.get_header(head_response, "content-type")
  57       handle_preview(content_type, conn, url)
  58     else
  59       {_, %{status: status}} ->
  60         send_resp(conn, :failed_dependency, "Can't fetch HTTP headers (HTTP #{status}).")
  61
  62       {:error, :recv_response_timeout} ->
  63         send_resp(conn, :failed_dependency, "HEAD request timeout.")
  64
  65       _ ->
  66         send_resp(conn, :failed_dependency, "Can't fetch HTTP headers.")
  67     end
  68   end
  69
  70   # TODO: find a workaround so avatar_static and banner_static can work.
  71   # Those only permit GIFs for animation, so we have to permit a way to
  72   # allow those to get real static variants.
  73   defp handle_preview("image/gif" = _content_type, conn, url) do
  74     mediaproxy_url = url |> MediaProxy.url()
  75
  76     redirect(conn, external: mediaproxy_url)
  77   end
  78
  79   defp handle_preview("image/png" <> _ = _content_type, conn, url) do
  80     handle_png_preview(conn, url)
  81   end
  82
  83   defp handle_preview("image/" <> _ = _content_type, conn, url) do
  84     handle_jpeg_preview(conn, url)
  85   end
  86
  87   defp handle_preview("video/" <> _ = _content_type, conn, url) do
  88     handle_video_preview(conn, url)
  89   end
  90
  91   defp handle_preview(content_type, conn, _url) do
  92     send_resp(conn, :unprocessable_entity, "Unsupported content type: #{content_type}.")
  93   end
  94
  95   defp handle_png_preview(%{params: params} = conn, url) do
  96     quality = Config.get!([:media_preview_proxy, :image_quality])
  97
  98     with {thumbnail_max_width, thumbnail_max_height} <- thumbnail_max_dimensions(params),
  99          {:ok, thumbnail_binary} <-
 100            MediaHelper.image_resize(
 101              url,
 102              %{
 103                max_width: thumbnail_max_width,
 104                max_height: thumbnail_max_height,
 105                quality: quality,
 106                format: "png"
 107              }
 108            ) do
 109       conn
 110       |> put_preview_response_headers()
 111       |> send_resp(200, thumbnail_binary)
 112     else
 113       _ ->
 114         send_resp(conn, :failed_dependency, "Can't handle preview.")
 115     end
 116   end
 117
 118   defp handle_jpeg_preview(%{params: params} = conn, url) do
 119     quality = Config.get!([:media_preview_proxy, :image_quality])
 120
 121     with {thumbnail_max_width, thumbnail_max_height} <- thumbnail_max_dimensions(params),
 122          {:ok, thumbnail_binary} <-
 123            MediaHelper.image_resize(
 124              url,
 125              %{max_width: thumbnail_max_width, max_height: thumbnail_max_height, quality: quality}
 126            ) do
 127       conn
 128       |> put_preview_response_headers()
 129       |> send_resp(200, thumbnail_binary)
 130     else
 131       _ ->
 132         send_resp(conn, :failed_dependency, "Can't handle preview.")
 133     end
 134   end
 135
 136   defp handle_video_preview(conn, url) do
 137     with {:ok, thumbnail_binary} <-
 138            MediaHelper.video_framegrab(url) do
 139       conn
 140       |> put_preview_response_headers()
 141       |> send_resp(200, thumbnail_binary)
 142     else
 143       _ ->
 144         send_resp(conn, :failed_dependency, "Can't handle preview.")
 145     end
 146   end
 147
 148   defp put_preview_response_headers(conn) do
 149     conn
 150     |> put_resp_header("content-type", "image/jpeg")
 151     |> put_resp_header("content-disposition", "inline; filename=\"preview.jpg\"")
 152     |> put_resp_header("cache-control", "max-age=0, private, must-revalidate")
 153   end
 154
 155   defp thumbnail_max_dimensions(params) do
 156     config = Config.get([:media_preview_proxy], [])
 157
 158     thumbnail_max_width =
 159       if w = params["thumbnail_max_width"] do
 160         String.to_integer(w)
 161       else
 162         Keyword.fetch!(config, :thumbnail_max_width)
 163       end
 164
 165     thumbnail_max_height =
 166       if h = params["thumbnail_max_height"] do
 167         String.to_integer(h)
 168       else
 169         Keyword.fetch!(config, :thumbnail_max_height)
 170       end
 171
 172     {thumbnail_max_width, thumbnail_max_height}
 173   end
 174
 175   defp preview_head_request_timeout do
 176     Keyword.get(media_preview_proxy_opts(), :head_request_max_read_duration) ||
 177       Keyword.get(media_proxy_opts(), :max_read_duration) ||
 178       ReverseProxy.max_read_duration_default()
 179   end
 180
 181   defp media_proxy_opts do
 182     Config.get([:media_proxy, :proxy_opts], [])
 183   end
 184
 185   defp media_preview_proxy_opts do
 186     Config.get([:media_preview_proxy, :proxy_opts], [])
 187   end
 188 end