fix: correct HTTP status codes and add StatusPages safety net

- Change 500→403 for share code race conditions (consumed/disappeared)
- Change 401→403 for account mismatch (authenticated but not authorized)
- Add StatusPages with handlers for BadRequest, PayloadTooLarge, and
  unhandled exceptions as a global safety net
- Rethrow JVM Errors in Throwable handler to avoid masking OOM etc.
- Add ErrorHandlingFlowTest for StatusPages behavior (413, 404)

Author: d4rken

build.gradle.kts

@@ -25,6 +25,7 @@ dependencies {
     implementation("io.ktor:ktor-serialization-kotlinx-json:$ktorVersion")
     implementation("io.ktor:ktor-server-content-negotiation:$ktorVersion")
     implementation("io.ktor:ktor-server-body-limit:$ktorVersion")
+    implementation("io.ktor:ktor-server-status-pages:$ktorVersion")
     testImplementation("io.ktor:ktor-server-test-host:$ktorVersion")
     testImplementation("io.ktor:ktor-client-content-negotiation:$ktorVersion")
 

src/main/kotlin/eu/darken/octi/kserver/Server.kt

@@ -2,8 +2,10 @@ package eu.darken.octi.kserver
 
 import eu.darken.octi.kserver.account.AccountRoute
 import eu.darken.octi.kserver.account.share.ShareRoute
+import eu.darken.octi.kserver.common.debug.logging.Logging.Priority.ERROR
 import eu.darken.octi.kserver.common.debug.logging.Logging.Priority.INFO
 import eu.darken.octi.kserver.common.debug.logging.Logging.Priority.WARN
+import eu.darken.octi.kserver.common.debug.logging.asLog
 import eu.darken.octi.kserver.common.debug.logging.log
 import eu.darken.octi.kserver.common.debug.logging.logTag
 import eu.darken.octi.kserver.common.installCallLogging
@@ -13,12 +15,17 @@ import eu.darken.octi.kserver.device.DeviceRoute
 import eu.darken.octi.kserver.module.ModuleRoute
 import eu.darken.octi.kserver.myip.MyIpRoute
 import eu.darken.octi.kserver.status.StatusRoute
+import io.ktor.http.*
 import io.ktor.serialization.kotlinx.json.*
 import io.ktor.server.application.*
 import io.ktor.server.engine.*
 import io.ktor.server.netty.*
 import io.ktor.server.plugins.contentnegotiation.*
+import io.ktor.server.plugins.*
+import io.ktor.server.plugins.statuspages.*
+import io.ktor.server.response.*
 import io.ktor.server.routing.*
+import kotlin.coroutines.cancellation.CancellationException
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.modules.SerializersModule
 import javax.inject.Inject
@@ -46,6 +53,28 @@ class Server @Inject constructor(
                 })
             }
 
+            install(StatusPages) {
+                exception<CancellationException> { _, cause -> throw cause }
+                exception<BadRequestException> { call, cause ->
+                    log(TAG, WARN) { "Bad request: ${cause.message}" }
+                    if (!call.response.isCommitted) {
+                        call.respond(HttpStatusCode.BadRequest, "Bad request")
+                    }
+                }
+                exception<PayloadTooLargeException> { call, _ ->
+                    if (!call.response.isCommitted) {
+                        call.respond(HttpStatusCode.PayloadTooLarge)
+                    }
+                }
+                exception<Throwable> { call, cause ->
+                    if (cause is Error) throw cause
+                    log(TAG, ERROR) { "Unhandled exception: ${cause.asLog()}" }
+                    if (!call.response.isCommitted) {
+                        call.respond(HttpStatusCode.InternalServerError, "Internal server error")
+                    }
+                }
+            }
+
             config.rateLimit
                 ?.let { installRateLimit(it) }
                 ?: log(TAG, WARN) { "rateLimit is not configured" }

src/main/kotlin/eu/darken/octi/kserver/account/AccountRoute.kt

@@ -87,15 +87,15 @@ class AccountRoute @Inject constructor(
         val account = if (share != null) {
             if (!shareRepo.consumeShare(shareCode!!)) {
                 log(TAG, ERROR) { "create($callInfo): Failed to consume Share" }
-                call.respond(HttpStatusCode.InternalServerError, "ShareCode was already consumed")
+                call.respond(HttpStatusCode.Forbidden, "ShareCode was already consumed")
                 return
             }
             log(TAG, INFO) { "create($callInfo): Share was valid, let's add the device" }
             val resolved = accountRepo.getAccount(share.accountId)
             if (resolved == null) {
                 log(TAG, ERROR) { "create($callInfo): Account ${share.accountId} disappeared, restoring share" }
                 shareRepo.restoreShare(share)
-                call.respond(HttpStatusCode.InternalServerError, "Account no longer exists")
+                call.respond(HttpStatusCode.Forbidden, "Account no longer exists")
                 return
             }
             resolved

src/main/kotlin/eu/darken/octi/kserver/module/ModuleRoute.kt

@@ -80,7 +80,7 @@ class ModuleRoute @Inject constructor(
 
         if (callerDevice.accountId != target.accountId) {
             log(TAG, ERROR) { "Devices don't share the same account: $callerDevice and $target" }
-            call.respond(HttpStatusCode.Unauthorized, "Devices don't share the same account")
+            call.respond(HttpStatusCode.Forbidden, "Devices don't share the same account")
             return null
         }
 

src/test/kotlin/eu/darken/octi/kserver/common/ErrorHandlingFlowTest.kt

@@ -0,0 +1,30 @@
+package eu.darken.octi.kserver.common
+
+import eu.darken.octi.*
+import io.kotest.matchers.shouldBe
+import io.ktor.client.request.*
+import io.ktor.http.*
+import org.junit.jupiter.api.Test
+
+class ErrorHandlingFlowTest : TestRunner() {
+
+    @Test
+    fun `oversized payload returns 413`() = runTest2 {
+        val creds = createDevice()
+        http.post {
+            url { takeFrom("/v1/account") }
+            addDeviceId(creds.deviceId)
+            contentType(ContentType.Application.OctetStream)
+            setBody("a".repeat((128 * 1024) + 1))
+        }.apply {
+            status shouldBe HttpStatusCode.PayloadTooLarge
+        }
+    }
+
+    @Test
+    fun `unknown route returns 404`() = runTest2 {
+        http.get("/v1/nonexistent").apply {
+            status shouldBe HttpStatusCode.NotFound
+        }
+    }
+}

src/test/kotlin/eu/darken/octi/kserver/module/ModuleFlowTest.kt

@@ -71,7 +71,7 @@ class ModuleFlowTest : TestRunner() {
         val creds1 = createDevice()
         val creds2 = createDevice()
         readModuleRaw(creds1, "abc", creds2.deviceId).apply {
-            status shouldBe HttpStatusCode.Unauthorized
+            status shouldBe HttpStatusCode.Forbidden
             bodyAsText() shouldBe "Devices don't share the same account"
         }
     }
@@ -133,7 +133,7 @@ class ModuleFlowTest : TestRunner() {
         val creds1 = createDevice()
         val creds2 = createDevice()
         writeModule(creds2, "abc", creds1.deviceId, "test").apply {
-            status shouldBe HttpStatusCode.Unauthorized
+            status shouldBe HttpStatusCode.Forbidden
             bodyAsText() shouldBe "Devices don't share the same account"
         }
         writeModule(creds2, "abc", creds1.deviceId, "test")
@@ -191,7 +191,7 @@ class ModuleFlowTest : TestRunner() {
         val creds1 = createDevice()
         val creds2 = createDevice()
         deleteModuleRaw(creds2, "abc", creds1.deviceId).apply {
-            status shouldBe HttpStatusCode.Unauthorized
+            status shouldBe HttpStatusCode.Forbidden
             bodyAsText() shouldBe "Devices don't share the same account"
         }
     }