continuwuity/src/api/client/media_legacy.rs

#![allow(deprecated)]

use axum::extract::State;
use axum_client_ip::InsecureClientIp;
use conduwuit::{
	err,
	utils::{content_disposition::make_content_disposition, math::ruma_from_usize},
	Err, Result,
};
use conduwuit_service::media::{Dim, FileMeta, CACHE_CONTROL_IMMUTABLE, CORP_CROSS_ORIGIN};
use reqwest::Url;
use ruma::{
	api::client::media::{
		create_content, get_content, get_content_as_filename, get_content_thumbnail,
		get_media_config, get_media_preview,
	},
	Mxc,
};

use crate::{client::create_content_route, Ruma, RumaResponse};

/// # `GET /_matrix/media/v3/config`
///
/// Returns max upload size.
pub(crate) async fn get_media_config_legacy_route(
	State(services): State<crate::State>,
	_body: Ruma<get_media_config::v3::Request>,
) -> Result<get_media_config::v3::Response> {
	Ok(get_media_config::v3::Response {
		upload_size: ruma_from_usize(services.server.config.max_request_size),
	})
}

/// # `GET /_matrix/media/v1/config`
///
/// This is a legacy endpoint ("/v1/") that some very old homeservers and/or
/// clients may call. conduwuit adds these for compatibility purposes.
/// See <https://spec.matrix.org/legacy/legacy/#id27>
///
/// Returns max upload size.
pub(crate) async fn get_media_config_legacy_legacy_route(
	State(services): State<crate::State>,
	body: Ruma<get_media_config::v3::Request>,
) -> Result<RumaResponse<get_media_config::v3::Response>> {
	get_media_config_legacy_route(State(services), body)
		.await
		.map(RumaResponse)
}

/// # `GET /_matrix/media/v3/preview_url`
///
/// Returns URL preview.
#[tracing::instrument(skip_all, fields(%client), name = "url_preview_legacy", level = "debug")]
pub(crate) async fn get_media_preview_legacy_route(
	State(services): State<crate::State>,
	InsecureClientIp(client): InsecureClientIp,
	body: Ruma<get_media_preview::v3::Request>,
) -> Result<get_media_preview::v3::Response> {
	let sender_user = body.sender_user.as_ref().expect("user is authenticated");

	let url = &body.url;
	let url = Url::parse(&body.url).map_err(|e| {
		err!(Request(InvalidParam(
			debug_warn!(%sender_user, %url, "Requested URL is not valid: {e}")
		)))
	})?;

	if !services.media.url_preview_allowed(&url) {
		return Err!(Request(Forbidden(
			debug_warn!(%sender_user, %url, "URL is not allowed to be previewed")
		)));
	}

	let preview = services.media.get_url_preview(&url).await.map_err(|e| {
		err!(Request(Unknown(
			debug_error!(%sender_user, %url, "Failed to fetch a URL preview: {e}")
		)))
	})?;

	serde_json::value::to_raw_value(&preview)
		.map(get_media_preview::v3::Response::from_raw_value)
		.map_err(|error| {
			err!(Request(Unknown(
				debug_error!(%sender_user, %url, "Failed to parse URL preview: {error}")
			)))
		})
}

/// # `GET /_matrix/media/v1/preview_url`
///
/// This is a legacy endpoint ("/v1/") that some very old homeservers and/or
/// clients may call. conduwuit adds these for compatibility purposes.
/// See <https://spec.matrix.org/legacy/legacy/#id27>
///
/// Returns URL preview.
pub(crate) async fn get_media_preview_legacy_legacy_route(
	State(services): State<crate::State>,
	InsecureClientIp(client): InsecureClientIp,
	body: Ruma<get_media_preview::v3::Request>,
) -> Result<RumaResponse<get_media_preview::v3::Response>> {
	get_media_preview_legacy_route(State(services), InsecureClientIp(client), body)
		.await
		.map(RumaResponse)
}

/// # `POST /_matrix/media/v1/upload`
///
/// Permanently save media in the server.
///
/// This is a legacy endpoint ("/v1/") that some very old homeservers and/or
/// clients may call. conduwuit adds these for compatibility purposes.
/// See <https://spec.matrix.org/legacy/legacy/#id27>
///
/// - Some metadata will be saved in the database
/// - Media will be saved in the media/ directory
pub(crate) async fn create_content_legacy_route(
	State(services): State<crate::State>,
	InsecureClientIp(client): InsecureClientIp,
	body: Ruma<create_content::v3::Request>,
) -> Result<RumaResponse<create_content::v3::Response>> {
	create_content_route(State(services), InsecureClientIp(client), body)
		.await
		.map(RumaResponse)
}

/// # `GET /_matrix/media/v3/download/{serverName}/{mediaId}`
///
/// Load media from our server or over federation.
///
/// - Only allows federation if `allow_remote` is true
/// - Only redirects if `allow_redirect` is true
/// - Uses client-provided `timeout_ms` if available, else defaults to 20
///   seconds
#[tracing::instrument(skip_all, fields(%client), name = "media_get_legacy", level = "debug")]
pub(crate) async fn get_content_legacy_route(
	State(services): State<crate::State>,
	InsecureClientIp(client): InsecureClientIp,
	body: Ruma<get_content::v3::Request>,
) -> Result<get_content::v3::Response> {
	let mxc = Mxc {
		server_name: &body.server_name,
		media_id: &body.media_id,
	};

	if let Some(FileMeta {
		content,
		content_type,
		content_disposition,
	}) = services.media.get(&mxc).await?
	{
		let content_disposition =
			make_content_disposition(content_disposition.as_ref(), content_type.as_deref(), None);

		Ok(get_content::v3::Response {
			file: content.expect("entire file contents"),
			content_type: content_type.map(Into::into),
			content_disposition: Some(content_disposition),
			cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
			cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
		})
	} else if !services.globals.server_is_ours(&body.server_name) && body.allow_remote {
		let response = services
			.media
			.fetch_remote_content_legacy(&mxc, body.allow_redirect, body.timeout_ms)
			.await
			.map_err(|e| {
				err!(Request(NotFound(debug_warn!(%mxc, "Fetching media failed: {e:?}"))))
			})?;

		let content_disposition = make_content_disposition(
			response.content_disposition.as_ref(),
			response.content_type.as_deref(),
			None,
		);

		Ok(get_content::v3::Response {
			file: response.file,
			content_type: response.content_type,
			content_disposition: Some(content_disposition),
			cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
			cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
		})
	} else {
		Err!(Request(NotFound("Media not found.")))
	}
}

/// # `GET /_matrix/media/v1/download/{serverName}/{mediaId}`
///
/// Load media from our server or over federation.
///
/// This is a legacy endpoint ("/v1/") that some very old homeservers and/or
/// clients may call. conduwuit adds these for compatibility purposes.
/// See <https://spec.matrix.org/legacy/legacy/#id27>
///
/// - Only allows federation if `allow_remote` is true
/// - Only redirects if `allow_redirect` is true
/// - Uses client-provided `timeout_ms` if available, else defaults to 20
///   seconds
#[tracing::instrument(skip_all, fields(%client), name = "media_get_legacy", level = "debug")]
pub(crate) async fn get_content_legacy_legacy_route(
	State(services): State<crate::State>,
	InsecureClientIp(client): InsecureClientIp,
	body: Ruma<get_content::v3::Request>,
) -> Result<RumaResponse<get_content::v3::Response>> {
	get_content_legacy_route(State(services), InsecureClientIp(client), body)
		.await
		.map(RumaResponse)
}

/// # `GET /_matrix/media/v3/download/{serverName}/{mediaId}/{fileName}`
///
/// Load media from our server or over federation, permitting desired filename.
///
/// - Only allows federation if `allow_remote` is true
/// - Only redirects if `allow_redirect` is true
/// - Uses client-provided `timeout_ms` if available, else defaults to 20
///   seconds
#[tracing::instrument(skip_all, fields(%client), name = "media_get_legacy", level = "debug")]
pub(crate) async fn get_content_as_filename_legacy_route(
	State(services): State<crate::State>,
	InsecureClientIp(client): InsecureClientIp,
	body: Ruma<get_content_as_filename::v3::Request>,
) -> Result<get_content_as_filename::v3::Response> {
	let mxc = Mxc {
		server_name: &body.server_name,
		media_id: &body.media_id,
	};

	if let Some(FileMeta {
		content,
		content_type,
		content_disposition,
	}) = services.media.get(&mxc).await?
	{
		let content_disposition = make_content_disposition(
			content_disposition.as_ref(),
			content_type.as_deref(),
			Some(&body.filename),
		);

		Ok(get_content_as_filename::v3::Response {
			file: content.expect("entire file contents"),
			content_type: content_type.map(Into::into),
			content_disposition: Some(content_disposition),
			cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
			cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
		})
	} else if !services.globals.server_is_ours(&body.server_name) && body.allow_remote {
		let response = services
			.media
			.fetch_remote_content_legacy(&mxc, body.allow_redirect, body.timeout_ms)
			.await
			.map_err(|e| {
				err!(Request(NotFound(debug_warn!(%mxc, "Fetching media failed: {e:?}"))))
			})?;

		let content_disposition = make_content_disposition(
			response.content_disposition.as_ref(),
			response.content_type.as_deref(),
			None,
		);

		Ok(get_content_as_filename::v3::Response {
			content_disposition: Some(content_disposition),
			content_type: response.content_type,
			file: response.file,
			cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
			cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
		})
	} else {
		Err!(Request(NotFound("Media not found.")))
	}
}

/// # `GET /_matrix/media/v1/download/{serverName}/{mediaId}/{fileName}`
///
/// Load media from our server or over federation, permitting desired filename.
///
/// This is a legacy endpoint ("/v1/") that some very old homeservers and/or
/// clients may call. conduwuit adds these for compatibility purposes.
/// See <https://spec.matrix.org/legacy/legacy/#id27>
///
/// - Only allows federation if `allow_remote` is true
/// - Only redirects if `allow_redirect` is true
/// - Uses client-provided `timeout_ms` if available, else defaults to 20
///   seconds
pub(crate) async fn get_content_as_filename_legacy_legacy_route(
	State(services): State<crate::State>,
	InsecureClientIp(client): InsecureClientIp,
	body: Ruma<get_content_as_filename::v3::Request>,
) -> Result<RumaResponse<get_content_as_filename::v3::Response>> {
	get_content_as_filename_legacy_route(State(services), InsecureClientIp(client), body)
		.await
		.map(RumaResponse)
}

/// # `GET /_matrix/media/v3/thumbnail/{serverName}/{mediaId}`
///
/// Load media thumbnail from our server or over federation.
///
/// - Only allows federation if `allow_remote` is true
/// - Only redirects if `allow_redirect` is true
/// - Uses client-provided `timeout_ms` if available, else defaults to 20
///   seconds
#[tracing::instrument(skip_all, fields(%client), name = "media_thumbnail_get_legacy", level = "debug")]
pub(crate) async fn get_content_thumbnail_legacy_route(
	State(services): State<crate::State>,
	InsecureClientIp(client): InsecureClientIp,
	body: Ruma<get_content_thumbnail::v3::Request>,
) -> Result<get_content_thumbnail::v3::Response> {
	let mxc = Mxc {
		server_name: &body.server_name,
		media_id: &body.media_id,
	};

	let dim = Dim::from_ruma(body.width, body.height, body.method.clone())?;
	if let Some(FileMeta {
		content,
		content_type,
		content_disposition,
	}) = services.media.get_thumbnail(&mxc, &dim).await?
	{
		let content_disposition =
			make_content_disposition(content_disposition.as_ref(), content_type.as_deref(), None);

		Ok(get_content_thumbnail::v3::Response {
			file: content.expect("entire file contents"),
			content_type: content_type.map(Into::into),
			cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
			cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
			content_disposition: Some(content_disposition),
		})
	} else if !services.globals.server_is_ours(&body.server_name) && body.allow_remote {
		let response = services
			.media
			.fetch_remote_thumbnail_legacy(&body)
			.await
			.map_err(|e| {
				err!(Request(NotFound(debug_warn!(%mxc, "Fetching media failed: {e:?}"))))
			})?;

		let content_disposition = make_content_disposition(
			response.content_disposition.as_ref(),
			response.content_type.as_deref(),
			None,
		);

		Ok(get_content_thumbnail::v3::Response {
			file: response.file,
			content_type: response.content_type,
			cross_origin_resource_policy: Some(CORP_CROSS_ORIGIN.into()),
			cache_control: Some(CACHE_CONTROL_IMMUTABLE.into()),
			content_disposition: Some(content_disposition),
		})
	} else {
		Err!(Request(NotFound("Media not found.")))
	}
}

/// # `GET /_matrix/media/v1/thumbnail/{serverName}/{mediaId}`
///
/// Load media thumbnail from our server or over federation.
///
/// This is a legacy endpoint ("/v1/") that some very old homeservers and/or
/// clients may call. conduwuit adds these for compatibility purposes.
/// See <https://spec.matrix.org/legacy/legacy/#id27>
///
/// - Only allows federation if `allow_remote` is true
/// - Only redirects if `allow_redirect` is true
/// - Uses client-provided `timeout_ms` if available, else defaults to 20
///   seconds
pub(crate) async fn get_content_thumbnail_legacy_legacy_route(
	State(services): State<crate::State>,
	InsecureClientIp(client): InsecureClientIp,
	body: Ruma<get_content_thumbnail::v3::Request>,
) -> Result<RumaResponse<get_content_thumbnail::v3::Response>> {
	get_content_thumbnail_legacy_route(State(services), InsecureClientIp(client), body)
		.await
		.map(RumaResponse)
}