use Pleroma.Web, :controller
alias Pleroma.Config
- alias Pleroma.Helpers.MogrifyHelper
+ alias Pleroma.Helpers.MediaHelper
+ alias Pleroma.Helpers.UriHelper
alias Pleroma.ReverseProxy
alias Pleroma.Web.MediaProxy
+ alias Plug.Conn
def remote(conn, %{"sig" => sig64, "url" => url64}) do
with {_, true} <- {:enabled, MediaProxy.enabled?()},
{:ok, url} <- MediaProxy.decode_url(sig64, url64),
+ {_, false} <- {:in_banned_urls, MediaProxy.in_banned_urls(url)},
:ok <- MediaProxy.verify_request_path_and_url(conn, url) do
- proxy_opts = Config.get([:media_proxy, :proxy_opts], [])
- ReverseProxy.call(conn, url, proxy_opts)
+ ReverseProxy.call(conn, url, media_proxy_opts())
else
{:enabled, false} ->
- send_resp(conn, 404, Plug.Conn.Status.reason_phrase(404))
+ send_resp(conn, 404, Conn.Status.reason_phrase(404))
+
+ {:in_banned_urls, true} ->
+ send_resp(conn, 404, Conn.Status.reason_phrase(404))
{:error, :invalid_signature} ->
- send_resp(conn, 403, Plug.Conn.Status.reason_phrase(403))
+ send_resp(conn, 403, Conn.Status.reason_phrase(403))
{:wrong_filename, filename} ->
redirect(conn, external: MediaProxy.build_url(sig64, url64, filename))
end
end
- def preview(conn, %{"sig" => sig64, "url" => url64}) do
+ def preview(%Conn{} = conn, %{"sig" => sig64, "url" => url64}) do
with {_, true} <- {:enabled, MediaProxy.preview_enabled?()},
{:ok, url} <- MediaProxy.decode_url(sig64, url64),
:ok <- MediaProxy.verify_request_path_and_url(conn, url) do
handle_preview(conn, url)
else
{:enabled, false} ->
- send_resp(conn, 404, Plug.Conn.Status.reason_phrase(404))
+ send_resp(conn, 404, Conn.Status.reason_phrase(404))
{:error, :invalid_signature} ->
- send_resp(conn, 403, Plug.Conn.Status.reason_phrase(403))
+ send_resp(conn, 403, Conn.Status.reason_phrase(403))
{:wrong_filename, filename} ->
redirect(conn, external: MediaProxy.build_preview_url(sig64, url64, filename))
end
defp handle_preview(conn, url) do
+ media_proxy_url = MediaProxy.url(url)
+
with {:ok, %{status: status} = head_response} when status in 200..299 <-
- Tesla.head(url, opts: [adapter: [timeout: preview_head_request_timeout()]]) do
+ Pleroma.HTTP.request("head", media_proxy_url, [], [], pool: :media) do
content_type = Tesla.get_header(head_response, "content-type")
- handle_preview(content_type, conn, url)
+ content_length = Tesla.get_header(head_response, "content-length")
+ content_length = content_length && String.to_integer(content_length)
+ static = conn.params["static"] in ["true", true]
+
+ cond do
+ static and content_type == "image/gif" ->
+ handle_jpeg_preview(conn, media_proxy_url)
+
+ static ->
+ drop_static_param_and_redirect(conn)
+
+ content_type == "image/gif" ->
+ redirect(conn, external: media_proxy_url)
+
+ min_content_length_for_preview() > 0 and content_length > 0 and
+ content_length < min_content_length_for_preview() ->
+ redirect(conn, external: media_proxy_url)
+
+ true ->
+ handle_preview(content_type, conn, media_proxy_url)
+ end
else
+ # If HEAD failed, redirecting to media proxy URI doesn't make much sense; returning an error
{_, %{status: status}} ->
send_resp(conn, :failed_dependency, "Can't fetch HTTP headers (HTTP #{status}).")
end
end
- defp thumbnail_max_dimensions(params) do
- config = Config.get([:media_preview_proxy], [])
-
- thumbnail_max_width =
- if w = params["thumbnail_max_width"] do
- String.to_integer(w)
- else
- Keyword.fetch!(config, :thumbnail_max_width)
- end
+ defp handle_preview("image/png" <> _ = _content_type, conn, media_proxy_url) do
+ handle_png_preview(conn, media_proxy_url)
+ end
- thumbnail_max_height =
- if h = params["thumbnail_max_height"] do
- String.to_integer(h)
- else
- Keyword.fetch!(config, :thumbnail_max_height)
- end
+ defp handle_preview("image/" <> _ = _content_type, conn, media_proxy_url) do
+ handle_jpeg_preview(conn, media_proxy_url)
+ end
- {thumbnail_max_width, thumbnail_max_height}
+ defp handle_preview("video/" <> _ = _content_type, conn, media_proxy_url) do
+ handle_video_preview(conn, media_proxy_url)
end
- defp thumbnail_binary(url, body, params) do
- {thumbnail_max_width, thumbnail_max_height} = thumbnail_max_dimensions(params)
+ defp handle_preview(_unsupported_content_type, conn, media_proxy_url) do
+ fallback_on_preview_error(conn, media_proxy_url)
+ end
- with true <- Config.get([:media_preview_proxy, :enable_eimp]),
- {:ok, [type: image_type, width: source_width, height: source_height]} <-
- :eimp.identify(body),
- scale_factor <-
- Enum.max([source_width / thumbnail_max_width, source_height / thumbnail_max_height]),
- {:ok, thumbnail_binary} =
- :eimp.convert(body, image_type, [
- {:scale, {round(source_width / scale_factor), round(source_height / scale_factor)}}
- ]) do
- {:ok, thumbnail_binary}
+ defp handle_png_preview(conn, media_proxy_url) do
+ quality = Config.get!([:media_preview_proxy, :image_quality])
+ {thumbnail_max_width, thumbnail_max_height} = thumbnail_max_dimensions()
+
+ with {:ok, thumbnail_binary} <-
+ MediaHelper.image_resize(
+ media_proxy_url,
+ %{
+ max_width: thumbnail_max_width,
+ max_height: thumbnail_max_height,
+ quality: quality,
+ format: "png"
+ }
+ ) do
+ conn
+ |> put_preview_response_headers(["image/png", "preview.png"])
+ |> send_resp(200, thumbnail_binary)
else
_ ->
- mogrify_dimensions = "#{thumbnail_max_width}x#{thumbnail_max_height}"
-
- with {:ok, path} <- MogrifyHelper.store_as_temporary_file(url, body),
- %Mogrify.Image{} <-
- MogrifyHelper.in_place_resize_to_limit(path, mogrify_dimensions),
- {:ok, thumbnail_binary} <- File.read(path),
- _ <- File.rm(path) do
- {:ok, thumbnail_binary}
- else
- _ -> :error
- end
+ fallback_on_preview_error(conn, media_proxy_url)
end
end
- defp handle_preview("image/" <> _ = content_type, %{params: params} = conn, url) do
- with {:ok, %{status: status, body: image_contents}} when status in 200..299 <-
- url
- |> MediaProxy.url()
- |> Tesla.get(opts: [adapter: [timeout: preview_timeout()]]),
- {:ok, thumbnail_binary} <- thumbnail_binary(url, image_contents, params) do
+ defp handle_jpeg_preview(conn, media_proxy_url) do
+ quality = Config.get!([:media_preview_proxy, :image_quality])
+ {thumbnail_max_width, thumbnail_max_height} = thumbnail_max_dimensions()
+
+ with {:ok, thumbnail_binary} <-
+ MediaHelper.image_resize(
+ media_proxy_url,
+ %{max_width: thumbnail_max_width, max_height: thumbnail_max_height, quality: quality}
+ ) do
conn
- |> put_resp_header("content-type", content_type)
+ |> put_preview_response_headers()
|> send_resp(200, thumbnail_binary)
else
- {_, %{status: _}} ->
- send_resp(conn, :failed_dependency, "Can't fetch the image.")
-
- {:error, :recv_response_timeout} ->
- send_resp(conn, :failed_dependency, "Downstream timeout.")
+ _ ->
+ fallback_on_preview_error(conn, media_proxy_url)
+ end
+ end
+ defp handle_video_preview(conn, media_proxy_url) do
+ with {:ok, thumbnail_binary} <-
+ MediaHelper.video_framegrab(media_proxy_url) do
+ conn
+ |> put_preview_response_headers()
+ |> send_resp(200, thumbnail_binary)
+ else
_ ->
- send_resp(conn, :failed_dependency, "Can't handle image preview.")
+ fallback_on_preview_error(conn, media_proxy_url)
end
end
- defp handle_preview(content_type, conn, _url) do
- send_resp(conn, :unprocessable_entity, "Unsupported content type: #{content_type}.")
+ defp drop_static_param_and_redirect(conn) do
+ uri_without_static_param =
+ conn
+ |> current_url()
+ |> UriHelper.modify_uri_params(%{}, ["static"])
+
+ redirect(conn, external: uri_without_static_param)
+ end
+
+ defp fallback_on_preview_error(conn, media_proxy_url) do
+ redirect(conn, external: media_proxy_url)
+ end
+
+ defp put_preview_response_headers(
+ conn,
+ [content_type, filename] = _content_info \\ ["image/jpeg", "preview.jpg"]
+ ) do
+ conn
+ |> put_resp_header("content-type", content_type)
+ |> put_resp_header("content-disposition", "inline; filename=\"#{filename}\"")
+ |> put_resp_header("cache-control", ReverseProxy.default_cache_control_header())
+ end
+
+ defp thumbnail_max_dimensions do
+ config = media_preview_proxy_config()
+
+ thumbnail_max_width = Keyword.fetch!(config, :thumbnail_max_width)
+ thumbnail_max_height = Keyword.fetch!(config, :thumbnail_max_height)
+
+ {thumbnail_max_width, thumbnail_max_height}
+ end
+
+ defp min_content_length_for_preview do
+ Keyword.get(media_preview_proxy_config(), :min_content_length, 0)
end
- defp preview_head_request_timeout do
- Config.get([:media_preview_proxy, :proxy_opts, :head_request_max_read_duration]) ||
- preview_timeout()
+ defp media_preview_proxy_config do
+ Config.get!([:media_preview_proxy])
end
- defp preview_timeout do
- Config.get([:media_preview_proxy, :proxy_opts, :max_read_duration]) ||
- Config.get([:media_proxy, :proxy_opts, :max_read_duration]) ||
- ReverseProxy.max_read_duration_default()
+ defp media_proxy_opts do
+ Config.get([:media_proxy, :proxy_opts], [])
end
end
projects / akkoma / blobdiff