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