using Microsoft.AspNetCore.RateLimiting; using EmptyEntity = PrivaPub.Api.Mastodon.Entities.EmptyEntity; using MediaUploadEntity = PrivaPub.Api.Mastodon.Entities.MediaUploadEntity; using MediaUploadMetaEntity = PrivaPub.Api.Mastodon.Entities.MediaUploadMetaEntity; using MediaUploadMetaFocusEntity = PrivaPub.Api.Mastodon.Entities.MediaUploadMetaFocusEntity; using MediaUploadMetaOriginalEntity = PrivaPub.Api.Mastodon.Entities.MediaUploadMetaOriginalEntity; using PrivaPub.Infrastructure.Statistics; using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; using MongoDB.Entities; using PrivaPub.Api.Mastodon.Infrastructure; using PrivaPub.Domain.Media; using PrivaPub.Models.Media; using PrivaPub.Infrastructure; using PrivaPub.Infrastructure.Jobs; using System.Globalization; namespace PrivaPub.Api.Mastodon.Controllers { public class MediaController( IMediaService mediaService, IMediaProxy mediaProxy, IJobQueue jobs, IInteractionLedger ledger = default) : MastodonController { const long UploadLimit = 100L * 1024 * 1024; [HttpPost(ApiPaths.Media.POST_Upload), HttpPost(ApiPaths.Media.POST_UploadV2), Scope("write:media"), EnableRateLimiting(RateLimiting.Uploads), RequestSizeLimit(UploadLimit), RequestFormLimits(MultipartBodyLengthLimit = UploadLimit)] public async Task Upload(CancellationToken token) { if (!Request.HasFormContentType) return Error(StatusCodes.Status422UnprocessableEntity, "Validation failed: File can't be blank"); var form = await Request.ReadFormAsync(token); // v2 may answer before audio or video is processed (202, its url null until then), as Mastodon does; v1 waits var later = Request.Path.StartsWithSegments("/api/v2/media"); var outcome = await mediaService.Upload(Me, form.Files["file"], form["description"], form["focus"], later, token); if (!outcome.Ok) return Error(outcome.Status, outcome.Error); if (outcome.Attachment.ProcessingState != "pending") return Json(View(outcome.Attachment)); await jobs.EnqueueMany(new[] { ProcessMediaJob.JobFor(outcome.Attachment, new Uri(Me.BaseAddress).Host) }, token); return new JsonResult(View(outcome.Attachment)) { StatusCode = StatusCodes.Status202Accepted }; } [HttpGet(ApiPaths.Media.GET_M_Get), Scope("write:media")] public async Task Get(string id, CancellationToken token) { var attachment = await DB.Default.Find().Match(m => m.ID == id && m.OwnerAvatarId == MyId && m.TrashedAt == null && m.ProfileOfAvatarId == null).ExecuteFirstAsync(token); return attachment?.ProcessingState switch { null when attachment == default => NotFoundError(), "pending" => new JsonResult(View(attachment)) { StatusCode = StatusCodes.Status206PartialContent }, "failed" => Error(StatusCodes.Status422UnprocessableEntity, attachment.ProcessingError ?? "Validation failed: The file could not be processed"), _ => Json(View(attachment)) }; } // Mastodon 4.4: a persona's own upload, while nothing holds it (not posted, not scheduled, not a profile picture), goes to // the trash as the janitor would take it [HttpDelete(ApiPaths.Media.DELETE_M_Delete), Scope("write:media")] public async Task Delete(string id, CancellationToken token) { var attachment = await DB.Default.Find().Match(m => m.ID == id && m.OwnerAvatarId == MyId && m.TrashedAt == null && m.ProfileOfAvatarId == null).ExecuteFirstAsync(token); if (attachment == default) return NotFoundError(); if (attachment.PostId != null || attachment.ScheduledStatusId != null) return Error(StatusCodes.Status422UnprocessableEntity, "Media attachment is currently used by a status"); await mediaService.Trash(m => m.ID == attachment.ID && m.PostId == null && m.ScheduledStatusId == null, "deleted by its owner", token); return Json(new EmptyEntity()); } // as on Mastodon, only media not posted yet: a posted one's description and focus change by editing its post (media_attributes) [HttpPut(ApiPaths.Media.PUT_M_Update), Scope("write:media")] public async Task Update(string id, CancellationToken token) { var attachment = await DB.Default.Find().Match(m => m.ID == id && m.OwnerAvatarId == MyId && m.TrashedAt == null && m.ProfileOfAvatarId == null && m.PostId == null).ExecuteFirstAsync(token); if (attachment == default) return NotFoundError(); if (Params.Has("description")) attachment.Description = Params.Get("description")?.Trim() is { Length: > 0 } description ? description[..Math.Min(description.Length, 1500)] : default; if (FocalPoint.Parse(Params.Get("focus")) is { } focus) attachment.Focus = focus; await DB.Default.SaveAsync(attachment, token); return Json(View(attachment)); } [HttpGet(ApiPaths.Media.GET_M_Proxy), AllowAnonymous, EnableRateLimiting(RateLimiting.Proxy), ApiExplorerSettings(IgnoreApi = true)] public async Task Proxy(string signature, string encoded, CancellationToken token) { var url = mediaProxy.Verified(signature, encoded); if (url == default || mediaProxy.Refuses(url)) return NotFound(); Response.Headers["X-Content-Type-Options"] = "nosniff"; Response.Headers["Content-Security-Policy"] = "default-src 'none'; sandbox"; if (mediaProxy.Cached(url) is { Path: not null } cached && Serve(cached.Path, cached.ContentType) is { } hit) { ledger?.Count(Interactions.HostOf(url), "media:hit"); return hit; } if (Request.Headers.Range.Count == 0) { var (outcome, path, contentType) = await mediaProxy.Download(url, token); if (outcome == ProxyOutcome.Cached && Serve(path, contentType) is { } fetched) return fetched; if (outcome == ProxyOutcome.Failed) return NotFound(); } return await Stream(url, token); } // a cached file, opened before it is answered: trimmed meanwhile, what is open still reads; cached by browsers only // once there is something to cache IActionResult Serve(string path, string contentType) { var file = default(FileStream); try { file = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete, 64 * 1024, useAsync: true); } catch (IOException) { return default; } Response.Headers["Cache-Control"] = "public, max-age=604800"; return File(file, contentType, enableRangeProcessing: true); } async Task Stream(string url, CancellationToken token) { var range = System.Net.Http.Headers.RangeHeaderValue.TryParse(Request.Headers.Range.ToString(), out var asked) ? asked : default; using var upstream = await mediaProxy.Open(url, range, token); if (upstream == default) return NotFound(); if (upstream.IsSuccessStatusCode) Response.Headers["Cache-Control"] = "public, max-age=604800"; Response.StatusCode = (int)upstream.StatusCode; Response.ContentType = upstream.Content.Headers.ContentType?.ToString() ?? "application/octet-stream"; if (upstream.Content.Headers.ContentLength is { } length) Response.ContentLength = length; if (upstream.Content.Headers.ContentRange is { } contentRange) Response.Headers.ContentRange = contentRange.ToString(); Response.Headers.AcceptRanges = "bytes"; await upstream.Content.CopyToAsync(Response.Body, token); return new EmptyResult(); } object View(MediaAttachment attachment) => View(mediaService, attachment); internal static object View(IMediaService media, MediaAttachment attachment) => new MediaUploadEntity { Id = attachment.ID, Type = attachment.Kind, Url = media.Url(attachment.FilePath), PreviewUrl = media.Url(attachment.PreviewPath ?? attachment.FilePath), RemoteUrl = default(string), TextUrl = default(string), Meta = new MediaUploadMetaEntity { Original = attachment.Width.HasValue && attachment.Height > 0 ? new MediaUploadMetaOriginalEntity { Width = attachment.Width, Height = attachment.Height, Size = $"{attachment.Width}x{attachment.Height}", Aspect = (double)attachment.Width / attachment.Height.Value } : default, Focus = attachment.Focus is { Length: 2 } ? new MediaUploadMetaFocusEntity { X = attachment.Focus[0], Y = attachment.Focus[1] } : default }, Description = attachment.Description, Blurhash = attachment.Blurhash }; } }