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.MogrifyHelper
  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          :ok <- MediaProxy.verify_request_path_and_url(conn, url) do
  17       proxy_opts = Config.get([:media_proxy, :proxy_opts], [])
  18       ReverseProxy.call(conn, url, proxy_opts)
  19     else
  20       {:enabled, false} ->
  21         send_resp(conn, 404, Plug.Conn.Status.reason_phrase(404))
  22
  23       {:error, :invalid_signature} ->
  24         send_resp(conn, 403, Plug.Conn.Status.reason_phrase(403))
  25
  26       {:wrong_filename, filename} ->
  27         redirect(conn, external: MediaProxy.build_url(sig64, url64, filename))
  28     end
  29   end
  30
  31   def preview(conn, %{"sig" => sig64, "url" => url64}) do
  32     with {_, true} <- {:enabled, MediaProxy.preview_enabled?()},
  33          {:ok, url} <- MediaProxy.decode_url(sig64, url64),
  34          :ok <- MediaProxy.verify_request_path_and_url(conn, url) do
  35       handle_preview(conn, url)
  36     else
  37       {:enabled, false} ->
  38         send_resp(conn, 404, Plug.Conn.Status.reason_phrase(404))
  39
  40       {:error, :invalid_signature} ->
  41         send_resp(conn, 403, Plug.Conn.Status.reason_phrase(403))
  42
  43       {:wrong_filename, filename} ->
  44         redirect(conn, external: MediaProxy.build_preview_url(sig64, url64, filename))
  45     end
  46   end
  47
  48   defp handle_preview(conn, url) do
  49     with {:ok, %{status: status} = head_response} when status in 200..299 <-
  50            Tesla.head(url, opts: [adapter: [timeout: preview_head_request_timeout()]]) do
  51       content_type = Tesla.get_header(head_response, "content-type")
  52       handle_preview(content_type, conn, url)
  53     else
  54       {_, %{status: status}} ->
  55         send_resp(conn, :failed_dependency, "Can't fetch HTTP headers (HTTP #{status}).")
  56
  57       {:error, :recv_response_timeout} ->
  58         send_resp(conn, :failed_dependency, "HEAD request timeout.")
  59
  60       _ ->
  61         send_resp(conn, :failed_dependency, "Can't fetch HTTP headers.")
  62     end
  63   end
  64
  65   defp thumbnail_max_dimensions(params) do
  66     config = Config.get([:media_preview_proxy], [])
  67
  68     thumbnail_max_width =
  69       if w = params["thumbnail_max_width"] do
  70         String.to_integer(w)
  71       else
  72         Keyword.fetch!(config, :thumbnail_max_width)
  73       end
  74
  75     thumbnail_max_height =
  76       if h = params["thumbnail_max_height"] do
  77         String.to_integer(h)
  78       else
  79         Keyword.fetch!(config, :thumbnail_max_height)
  80       end
  81
  82     {thumbnail_max_width, thumbnail_max_height}
  83   end
  84
  85   defp thumbnail_binary(url, body, params) do
  86     {thumbnail_max_width, thumbnail_max_height} = thumbnail_max_dimensions(params)
  87
  88     with true <- Config.get([:media_preview_proxy, :enable_eimp]),
  89          {:ok, [type: image_type, width: source_width, height: source_height]} <-
  90            :eimp.identify(body),
  91          scale_factor <-
  92            Enum.max([source_width / thumbnail_max_width, source_height / thumbnail_max_height]),
  93          {:ok, thumbnail_binary} =
  94            :eimp.convert(body, image_type, [
  95              {:scale, {round(source_width / scale_factor), round(source_height / scale_factor)}}
  96            ]) do
  97       {:ok, thumbnail_binary}
  98     else
  99       _ ->
 100         mogrify_dimensions = "#{thumbnail_max_width}x#{thumbnail_max_height}"
 101
 102         with {:ok, path} <- MogrifyHelper.store_as_temporary_file(url, body),
 103              %Mogrify.Image{} <-
 104                MogrifyHelper.in_place_resize_to_limit(path, mogrify_dimensions),
 105              {:ok, thumbnail_binary} <- File.read(path),
 106              _ <- File.rm(path) do
 107           {:ok, thumbnail_binary}
 108         else
 109           _ -> :error
 110         end
 111     end
 112   end
 113
 114   defp handle_preview("image/" <> _ = content_type, %{params: params} = conn, url) do
 115     with {:ok, %{status: status, body: image_contents}} when status in 200..299 <-
 116            url
 117            |> MediaProxy.url()
 118            |> Tesla.get(opts: [adapter: [timeout: preview_timeout()]]),
 119          {:ok, thumbnail_binary} <- thumbnail_binary(url, image_contents, params) do
 120       conn
 121       |> put_resp_header("content-type", content_type)
 122       |> send_resp(200, thumbnail_binary)
 123     else
 124       {_, %{status: _}} ->
 125         send_resp(conn, :failed_dependency, "Can't fetch the image.")
 126
 127       {:error, :recv_response_timeout} ->
 128         send_resp(conn, :failed_dependency, "Downstream timeout.")
 129
 130       _ ->
 131         send_resp(conn, :failed_dependency, "Can't handle image preview.")
 132     end
 133   end
 134
 135   defp handle_preview(content_type, conn, _url) do
 136     send_resp(conn, :unprocessable_entity, "Unsupported content type: #{content_type}.")
 137   end
 138
 139   defp preview_head_request_timeout do
 140     Config.get([:media_preview_proxy, :proxy_opts, :head_request_max_read_duration]) ||
 141       preview_timeout()
 142   end
 143
 144   defp preview_timeout do
 145     Config.get([:media_preview_proxy, :proxy_opts, :max_read_duration]) ||
 146       Config.get([:media_proxy, :proxy_opts, :max_read_duration]) ||
 147       ReverseProxy.max_read_duration_default()
 148   end
 149 end