From 98f301f5fd2bf59ed6e6bde84bc15af328d522b3 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 12 Oct 2026 15:58:48 +0000 Subject: [PATCH] fix(server): answer every chunk request and out-of-range archive.json policies The chunk endpoint raised the request body limit only before reading a chunk. A chunk sent again after a lost answer, or to an unknown or finished upload, was left unread above Kestrel's 1 MiB default, so Kestrel closed the connection instead of delivering the answer. The limit is now raised before any answer, to the larger of the upload's and the server's chunk size, and never lowered. PUT /api/v1/archive/settings answered 500 when archive.json held a thumbnail size or proxy quality out of range, which the admin API cannot set. It now answers 409 archive_policy with the policy to correct in details (Server.Error.ArchivePolicy). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- i18n/en/Server.resx | 1 + i18n/it/Server.it.resx | 1 + src/Titano.Server/Api/ArchiveEndpoints.cs | 15 +++++++++++- src/Titano.Server/Api/UploadEndpoints.cs | 3 ++- src/Titano.Server/Storage/UploadService.cs | 7 ++++-- tests/Titano.Server.Tests/Api/AdminTests.cs | 16 +++++++++++++ .../Storage/UploadTests.cs | 23 +++++++++++++++++++ 7 files changed, 62 insertions(+), 4 deletions(-) diff --git a/i18n/en/Server.resx b/i18n/en/Server.resx index 84cf4086..3166661a 100644 --- a/i18n/en/Server.resx +++ b/i18n/en/Server.resx @@ -29,6 +29,7 @@ Another program is changing the archive's settings; try again shortly.long The archive's archive.json is damaged, from a newer Titano or of another archive; check the archive folder.long The archive is offline or read-only; try again when it is back.long + The archive's archive.json has a thumbnail or proxy setting Titano cannot use; correct it in the archive folder.long Its photos are the archive's root folder, which never moves to the trash.long Wrong user name or password.long The request is not valid.long diff --git a/i18n/it/Server.it.resx b/i18n/it/Server.it.resx index b0aa9af3..fc9c78d1 100644 --- a/i18n/it/Server.it.resx +++ b/i18n/it/Server.it.resx @@ -27,6 +27,7 @@ Un altro programma sta modificando le impostazioni dell'archivio; riprova tra poco. Il file archive.json dell'archivio è danneggiato, di un Titano più recente o di un altro archivio; controlla la cartella dell'archivio. L'archivio non è raggiungibile o è di sola lettura; riprova quando torna disponibile. + Il file archive.json dell'archivio ha un'impostazione delle miniature o dei proxy che Titano non può usare; correggila nella cartella dell'archivio. Le sue foto sono la cartella principale dell'archivio, che non va mai nel cestino. Nome utente o password errati. La richiesta non è valida. diff --git a/src/Titano.Server/Api/ArchiveEndpoints.cs b/src/Titano.Server/Api/ArchiveEndpoints.cs index 953df725..c71e1df6 100644 --- a/src/Titano.Server/Api/ArchiveEndpoints.cs +++ b/src/Titano.Server/Api/ArchiveEndpoints.cs @@ -67,7 +67,9 @@ public static class ArchiveEndpoints /// Writes the name, templates and proxy policy into the archive's archive.json through the archive engine (so a /// restart and the proxy jobs see them), then into the index. 503 archive_offline while the archive cannot be /// written; 409 archive_busy while another process holds its settings; 409 archive_manifest when its - /// archive.json is damaged, written by a newer Titano or of another archive (nothing is written). + /// archive.json is damaged, written by a newer Titano or of another archive; 409 archive_policy when it holds a + /// thumbnail or proxy setting this API cannot set and Titano cannot use (details: thumbnailPolicy or + /// proxyPolicy, the property to correct in the file). Nothing is written. /// private static async Task UpdateAsync(HttpContext context, Caller caller, ArchiveSettingsDto request, TitanoDatabase db, ServerArchive archive, [FromServices] ArchiveService? archives, AuditLog audit) @@ -99,6 +101,17 @@ public static class ArchiveEndpoints { return ApiErrors.Conflict(context, "archive_manifest"); } + catch (ArgumentException ex) + { + // The request's fields were checked above: what fails is a value read from archive.json (a thumbnail size, or a + // proxy quality, written by hand or by another tool), which the admin corrects in the file, not in this form. + return ApiErrors.Conflict(context, "archive_policy", ex.ParamName switch + { + "thumbnailLongEdge" => "thumbnailPolicy", + "proxyLongEdge" => "proxyPolicy", + var other => other, + }); + } catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) { // ArchiveOfflineException included: nothing was written. diff --git a/src/Titano.Server/Api/UploadEndpoints.cs b/src/Titano.Server/Api/UploadEndpoints.cs index 56755b08..74bd66f0 100644 --- a/src/Titano.Server/Api/UploadEndpoints.cs +++ b/src/Titano.Server/Api/UploadEndpoints.cs @@ -54,7 +54,8 @@ public static class UploadEndpoints /// /// Chunks are the only large request bodies; every other endpoint keeps Kestrel's small default limit. The service - /// raises it to the chunk size of this upload (fixed when it started) before it reads the body. + /// raises it before any answer to at least the chunk size of this upload (fixed when it started) and of this server, + /// so a body it leaves unread can still be drained. /// private static async Task ChunkAsync(HttpContext context, Caller caller, Guid id, int index, UploadService service) { diff --git a/src/Titano.Server/Storage/UploadService.cs b/src/Titano.Server/Storage/UploadService.cs index 22f799bc..a468bad2 100644 --- a/src/Titano.Server/Storage/UploadService.cs +++ b/src/Titano.Server/Storage/UploadService.cs @@ -101,14 +101,17 @@ public sealed class UploadService( public async Task> ReceiveChunkAsync(Caller caller, Guid id, int index, HttpRequest request, CancellationToken cancellationToken) { var upload = await db.Uploads.GetAsync(id, cancellationToken); + // A body left unread by an answer below is drained after it: one of a chunk's size must not count as too large, or + // Kestrel would close the connection while the client still sends it and the client would never see the answer. The + // upload keeps the chunk size it started with: a smaller setting since a restart must not refuse its chunks (413). + if (request.HttpContext.Features.Get() is { IsReadOnly: false, MaxRequestBodySize: { } current } limit) + limit.MaxRequestBodySize = Math.Max(current, Math.Max(upload?.ChunkSize ?? 0, options.ChunkSizeBytes)); if (upload is null || upload.UserId != caller.Id) return Fail(404, "not_found", "upload"); if (upload.State != UploadState.Receiving) return Fail(409, "upload_state"); if (index < 0 || index >= upload.ChunkCount) return Fail(400, "chunk_out_of_range"); var expected = Math.Min(upload.ChunkSize, upload.Size - (long)index * upload.ChunkSize); if (request.ContentLength is { } announced && announced != expected) return Fail(400, "chunk_size", expected.ToString(CultureInfo.InvariantCulture)); if (upload.HasChunk(index)) return new ChunkReceived(index, UploadRules.ReceivedChunks(upload)); - // The upload keeps the chunk size it started with: a smaller setting since a restart must not refuse its chunks (413). - if (request.HttpContext.Features.Get() is { IsReadOnly: false } limit) limit.MaxRequestBodySize = upload.ChunkSize; if (_chunksInFlight.AddOrUpdate(caller.Id, 1, (_, n) => n + 1) > options.ConcurrentChunksPerUser) { diff --git a/tests/Titano.Server.Tests/Api/AdminTests.cs b/tests/Titano.Server.Tests/Api/AdminTests.cs index ea8aebd3..744d20a2 100644 --- a/tests/Titano.Server.Tests/Api/AdminTests.cs +++ b/tests/Titano.Server.Tests/Api/AdminTests.cs @@ -177,5 +177,21 @@ public sealed class AdminTests(TestContext context) { await File.WriteAllBytesAsync(path, saved, context.Cancellation); } + + // A policy this form cannot set, written out of range by another tool, is named so the admin can correct the file. + var current = Titano.Core.Archiving.ManifestStore.ReadArchive(path); + foreach (var (odd, property) in new[] + { + (current with { ThumbnailPolicy = new Titano.Core.Archiving.ThumbnailPolicy { LongEdge = 2048 } }, "thumbnailPolicy"), + (current with { ProxyPolicy = current.ProxyPolicy with { Quality = 0 } }, "proxyPolicy"), + }) + { + Titano.Core.Archiving.ManifestStore.WriteArchive(path, odd); + var before = await File.ReadAllBytesAsync(path, context.Cancellation); + using var refused = await admin.PutAsJsonAsync("/api/v1/archive/settings", changed with { ProxyLongEdge = 1280 }, ProtocolJson.Default.ArchiveSettingsDto); + Assert.Equal(property, (await refused.ExpectErrorAsync(HttpStatusCode.Conflict, "archive_policy")).Details); + Assert.SequenceEqual(before, await File.ReadAllBytesAsync(path, context.Cancellation)); + } + await File.WriteAllBytesAsync(path, saved, context.Cancellation); } } diff --git a/tests/Titano.Server.Tests/Storage/UploadTests.cs b/tests/Titano.Server.Tests/Storage/UploadTests.cs index aea2324e..b449139f 100644 --- a/tests/Titano.Server.Tests/Storage/UploadTests.cs +++ b/tests/Titano.Server.Tests/Storage/UploadTests.cs @@ -170,6 +170,29 @@ public sealed class UploadTests(TestContext context) await oversized.ExpectErrorAsync(HttpStatusCode.BadRequest, "chunk_size"); } + [Test] + public async Task AnswersThatLeaveALargeChunkUnreadReachTheClient() + { + // Chunks far above the 1 MiB other requests may send: more than the connection buffers while the server reads nothing. + const int large = 32 * 1024 * 1024; + await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = large); + var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader"); + var data = Uploads.Photo(24 * 1024 * 1024, 16); + var id = (await Uploads.StartAsync(uploader, data)).UploadId!.Value; + using (var first = await Uploads.PutChunkAsync(uploader, id, 0, data)) await first.ExpectAsync(HttpStatusCode.OK); + + // The client lost the answer and sends the chunk again: the same answer, not a closed connection. + using (var again = await Uploads.PutChunkAsync(uploader, id, 0, data)) + { + await again.ExpectAsync(HttpStatusCode.OK); + Assert.SequenceEqual([0], (await again.ReadAsync(ProtocolJson.Default.ChunkReceived)).Received); + } + using (var unknown = await Uploads.PutChunkAsync(uploader, Guid.CreateVersion7(), 0, data)) await unknown.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found"); + using (var complete = await uploader.PostAsync($"/api/v1/uploads/{id}/complete", null)) await complete.ExpectAsync(HttpStatusCode.OK); + using var late = await Uploads.PutChunkAsync(uploader, id, 0, data); + await late.ExpectErrorAsync(HttpStatusCode.Conflict, "upload_state"); + } + [Test] public async Task RenderUploadsNeedTheEditPermission() {