@mentra/bluetooth-sdk 0.1.8 → 0.1.10

package/android/src/main/java/com/mentra/bluetoothsdk/photoreceiver/LocalPhotoUploadServer.kt

@@ -1,6 +1,7 @@
 package com.mentra.bluetoothsdk.photoreceiver
 
 import android.content.Context
+import com.mentra.bluetoothsdk.debug.BleTraceLogger
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -12,6 +13,7 @@ import java.io.BufferedInputStream
 import java.io.ByteArrayOutputStream
 import java.io.EOFException
 import java.io.File
+import java.io.FileOutputStream
 import java.io.InputStream
 import java.io.OutputStream
 import java.net.InetSocketAddress
@@ -20,6 +22,9 @@ import java.net.Socket
 import java.net.SocketException
 import java.nio.charset.StandardCharsets
 import java.util.Locale
+import java.util.UUID
+import java.util.concurrent.Semaphore
+import org.json.JSONObject
 
 data class PhotoUpload(
     val requestId: String?,
@@ -38,21 +43,40 @@ class LocalPhotoUploadServer(
     private var serverSocket: ServerSocket? = null
     private var serverJob: Job? = null
     private val uploadDir = File(appContext.cacheDir, "mentra-photo-uploads")
+    private val clientSlots = Semaphore(MAX_ACTIVE_CLIENTS)
 
     @Volatile
     var running: Boolean = false
         private set
 
+    val activePort: Int?
+        get() = serverSocket
+            ?.takeIf { running && !it.isClosed }
+            ?.localPort
+
     fun start(port: Int): Int {
+        val activeSocket = serverSocket
+        if (running && activeSocket != null && !activeSocket.isClosed && activeSocket.localPort == port) {
+            onLog("Already listening on 0.0.0.0:${activeSocket.localPort}")
+            return activeSocket.localPort
+        }
         stop()
         uploadDir.mkdirs()
         val socket = ServerSocket()
-        socket.reuseAddress = true
-        socket.bind(InetSocketAddress("0.0.0.0", port))
-        serverSocket = socket
-        running = true
-        serverJob = scope.launch {
-            acceptLoop(socket)
+        try {
+            socket.reuseAddress = true
+            socket.bind(InetSocketAddress("0.0.0.0", port))
+            serverSocket = socket
+            running = true
+            serverJob = scope.launch {
+                acceptLoop(socket)
+            }
+        } catch (error: Throwable) {
+            try {
+                socket.close()
+            } catch (_: Throwable) {
+            }
+            throw error
         }
         onLog("Listening on 0.0.0.0:${socket.localPort}")
         return socket.localPort
@@ -78,7 +102,17 @@ class LocalPhotoUploadServer(
         while (scope.isActive && !socket.isClosed) {
             try {
                 val client = socket.accept()
-                scope.launch { handleClient(client) }
+                if (!clientSlots.tryAcquire()) {
+                    rejectClient(client)
+                    continue
+                }
+                scope.launch {
+                    try {
+                        handleClient(client)
+                    } finally {
+                        clientSlots.release()
+                    }
+                }
             } catch (error: SocketException) {
                 if (running) onLog("Accept failed: ${error.message}")
             } catch (error: Throwable) {
@@ -89,33 +123,78 @@ class LocalPhotoUploadServer(
 
     private fun handleClient(socket: Socket) {
         socket.use { client ->
+            val requestStartMs = System.currentTimeMillis()
             client.soTimeout = 20_000
             val input = BufferedInputStream(client.getInputStream())
             val output = client.getOutputStream()
+            var request: HttpRequest? = null
+            var requestId: String? = null
+            var contentLength: Long? = null
+
+            traceWifiInput(
+                "photo_receiver_connection",
+                client,
+                requestStartMs,
+                mutableMapOf(
+                    "timestampMs" to requestStartMs,
+                ),
+            )
+
+            fun respond(status: Int, body: String) {
+                writeJson(output, status, body)
+                traceWifiOutput(
+                    "photo_receiver_response",
+                    client,
+                    requestStartMs,
+                    mutableMapOf(
+                        "method" to request?.method,
+                        "path" to request?.path,
+                        "requestId" to requestId,
+                        "contentLength" to contentLength,
+                        "statusCode" to status,
+                        "success" to (status in 200..299),
+                        "responseBytes" to body.toByteArray(StandardCharsets.UTF_8).size,
+                        "durationMs" to (System.currentTimeMillis() - requestStartMs),
+                    ),
+                )
+            }
+
             try {
                 val headerBytes = readHeaders(input)
                 val headerText = headerBytes.toString(StandardCharsets.ISO_8859_1)
-                val request = HttpRequest.parse(headerText)
+                request = HttpRequest.parse(headerText)
                 onLog("${request.method} ${request.path} from ${client.inetAddress.hostAddress}")
+                contentLength = request.headers["content-length"]?.toLongOrNull()
+                traceWifiInput(
+                    "photo_receiver_request",
+                    client,
+                    requestStartMs,
+                    mutableMapOf(
+                        "method" to request.method,
+                        "path" to request.path,
+                        "contentType" to request.headers["content-type"].orEmpty(),
+                        "contentLength" to contentLength,
+                        "userAgent" to request.headers["user-agent"].orEmpty(),
+                    ),
+                )
 
                 if (request.method == "GET" && (request.path == "/" || request.path == "/health")) {
-                    writeJson(output, 200, """{"ok":true,"service":"mentra-photo-upload-receiver"}""")
+                    respond(200, """{"ok":true,"service":"mentra-photo-upload-receiver"}""")
                     return
                 }
 
                 if (request.method != "POST" || request.path != "/upload") {
-                    writeJson(output, 404, """{"ok":false,"error":"not_found"}""")
+                    respond(404, """{"ok":false,"error":"not_found"}""")
                     return
                 }
 
                 val contentType = request.headers["content-type"].orEmpty()
-                val contentLength = request.headers["content-length"]?.toLongOrNull()
                 if (contentLength == null || contentLength <= 0) {
-                    writeJson(output, 411, """{"ok":false,"error":"content_length_required"}""")
+                    respond(411, """{"ok":false,"error":"content_length_required"}""")
                     return
                 }
                 if (contentLength > MAX_UPLOAD_BYTES) {
-                    writeJson(output, 413, """{"ok":false,"error":"upload_too_large"}""")
+                    respond(413, """{"ok":false,"error":"upload_too_large"}""")
                     return
                 }
                 if (request.headers["expect"]?.contains("100-continue", ignoreCase = true) == true) {
@@ -124,35 +203,80 @@ class LocalPhotoUploadServer(
                 }
 
                 onLog("headers contentType=$contentType contentLength=$contentLength userAgent=${request.headers["user-agent"].orEmpty()}")
-                val body = readExact(input, contentLength.toInt())
                 val boundary = multipartBoundary(contentType)
                 if (boundary == null) {
-                    writeJson(output, 400, """{"ok":false,"error":"multipart_boundary_required"}""")
+                    respond(400, """{"ok":false,"error":"multipart_boundary_required"}""")
                     return
                 }
-                val parsed = parseMultipart(body, boundary)
-                val photoBytes = parsed.files["photo"] ?: parsed.files.values.firstOrNull()
-                if (photoBytes == null) {
-                    writeJson(output, 400, """{"ok":false,"error":"photo_field_required"}""")
+                val parsed = parseMultipart(ContentLengthInputStream(input, contentLength), boundary)
+                val photoPart = parsed.files["photo"] ?: parsed.files.values.firstOrNull()
+                if (photoPart == null) {
+                    parsed.deleteFiles()
+                    respond(400, """{"ok":false,"error":"photo_field_required"}""")
                     return
                 }
 
-                val requestId = parsed.fields["requestId"] ?: parsed.fields["request_id"]
+                requestId = parsed.fields["requestId"] ?: parsed.fields["request_id"]
                 val file = File(uploadDir, "${safeFilePart(requestId ?: "photo-${System.currentTimeMillis()}")}.jpg")
-                file.writeBytes(photoBytes)
-                onLog("upload fields=${parsed.fields.keys.joinToString(",")} requestId=${requestId.orEmpty()} bytes=${photoBytes.size} saved=${file.absolutePath}")
-                onUpload(
-                    PhotoUpload(
-                        requestId = requestId,
-                        photoFile = file,
-                        byteCount = photoBytes.size,
-                        fields = parsed.fields,
+                try {
+                    moveFile(photoPart.file, file)
+                } finally {
+                    parsed.deleteFilesExcept(file)
+                }
+                onLog("upload fields=${parsed.fields.keys.joinToString(",")} requestId=${requestId.orEmpty()} bytes=${photoPart.byteCount} saved=${file.absolutePath}")
+                val upload = PhotoUpload(
+                    requestId = requestId,
+                    photoFile = file,
+                    byteCount = photoPart.byteCount,
+                    fields = parsed.fields,
+                )
+                traceWifiInput(
+                    "photo_receiver_upload_received",
+                    client,
+                    requestStartMs,
+                    mutableMapOf(
+                        "method" to request.method,
+                        "path" to request.path,
+                        "requestId" to requestId,
+                        "source" to parsed.fields["source"],
+                        "contentLength" to contentLength,
+                        "photoBytes" to photoPart.byteCount,
+                        "savedFileName" to file.name,
+                        "durationMs" to (System.currentTimeMillis() - requestStartMs),
                     ),
                 )
-                writeJson(output, 200, """{"ok":true,"requestId":"${jsonEscape(requestId.orEmpty())}","bytes":${photoBytes.size}}""")
+                respond(200, """{"ok":true,"requestId":${jsonString(requestId.orEmpty())},"bytes":${photoPart.byteCount}}""")
+                try {
+                    onUpload(upload)
+                } catch (callbackError: Throwable) {
+                    onLog("upload callback failed: ${callbackError.message ?: callbackError::class.java.simpleName}")
+                }
             } catch (error: Throwable) {
                 onLog("request failed: ${error.message ?: error::class.java.simpleName}")
-                writeJson(output, 500, """{"ok":false,"error":"${jsonEscape(error.message ?: "server_error")}"}""")
+                traceWifiInput(
+                    "photo_receiver_request_error",
+                    client,
+                    requestStartMs,
+                    mutableMapOf(
+                        "method" to request?.method,
+                        "path" to request?.path,
+                        "requestId" to requestId,
+                        "contentLength" to contentLength,
+                        "durationMs" to (System.currentTimeMillis() - requestStartMs),
+                        "errorClass" to error::class.java.simpleName,
+                        "errorMessage" to (error.message ?: error::class.java.simpleName),
+                    ),
+                )
+                respond(500, """{"ok":false,"error":${jsonString(error.message ?: "server_error")}}""")
+            }
+        }
+    }
+
+    private fun rejectClient(socket: Socket) {
+        socket.use { client ->
+            try {
+                writeJson(client.getOutputStream(), 503, """{"ok":false,"error":"too_many_connections"}""")
+            } catch (_: Throwable) {
             }
         }
     }
@@ -177,17 +301,6 @@ class LocalPhotoUploadServer(
         }
     }
 
-    private fun readExact(input: InputStream, length: Int): ByteArray {
-        val body = ByteArray(length)
-        var offset = 0
-        while (offset < length) {
-            val read = input.read(body, offset, length - offset)
-            if (read == -1) throw EOFException("Socket closed after $offset of $length body bytes")
-            offset += read
-        }
-        return body
-    }
-
     private fun writeJson(output: OutputStream, status: Int, body: String) {
         val reason = when (status) {
             200 -> "OK"
@@ -195,6 +308,7 @@ class LocalPhotoUploadServer(
             404 -> "Not Found"
             411 -> "Length Required"
             413 -> "Payload Too Large"
+            503 -> "Service Unavailable"
             else -> "Internal Server Error"
         }
         val bytes = body.toByteArray(StandardCharsets.UTF_8)
@@ -229,47 +343,154 @@ class LocalPhotoUploadServer(
 
     private data class ParsedMultipart(
         val fields: Map<String, String>,
-        val files: Map<String, ByteArray>,
+        val files: Map<String, StreamedFile>,
+    ) {
+        fun deleteFiles() {
+            files.values.forEach { it.file.delete() }
+        }
+
+        fun deleteFilesExcept(keptFile: File) {
+            files.values.forEach { part ->
+                if (part.file.absolutePath != keptFile.absolutePath) {
+                    part.file.delete()
+                }
+            }
+        }
+    }
+
+    private data class StreamedFile(
+        val file: File,
+        val byteCount: Int,
     )
 
-    private fun parseMultipart(body: ByteArray, boundary: String): ParsedMultipart {
-        val text = body.toString(StandardCharsets.ISO_8859_1)
+    private fun parseMultipart(input: InputStream, boundary: String): ParsedMultipart {
         val marker = "--$boundary"
+        val delimiter = "\r\n$marker".toByteArray(StandardCharsets.ISO_8859_1)
         val fields = mutableMapOf<String, String>()
-        val files = mutableMapOf<String, ByteArray>()
-        var cursor = 0
+        val files = mutableMapOf<String, StreamedFile>()
+        val tempFiles = mutableListOf<File>()
 
-        while (true) {
-            val markerStart = text.indexOf(marker, cursor)
-            if (markerStart < 0) break
-            var partStart = markerStart + marker.length
-            if (text.startsWith("--", partStart)) break
-            if (text.startsWith("\r\n", partStart)) partStart += 2
-
-            val headerEnd = text.indexOf("\r\n\r\n", partStart)
-            if (headerEnd < 0) break
-            val dataStart = headerEnd + 4
-            val nextMarker = text.indexOf("\r\n$marker", dataStart)
-            if (nextMarker < 0) break
-
-            val headerBlock = text.substring(partStart, headerEnd)
-            val disposition = headerBlock.lineSequence()
-                .firstOrNull { it.startsWith("Content-Disposition:", ignoreCase = true) }
-                .orEmpty()
-            val name = Regex("""name="([^"]+)"""").find(disposition)?.groupValues?.get(1)
-            val filename = Regex("""filename="([^"]*)"""").find(disposition)?.groupValues?.get(1)
-            if (name != null) {
-                val bytes = body.copyOfRange(dataStart, nextMarker)
-                if (filename != null) {
-                    files[name] = bytes
+        try {
+            val firstLine = readAsciiLine(input)
+            if (firstLine == "$marker--") {
+                return ParsedMultipart(fields = fields, files = files)
+            }
+            if (firstLine != marker) {
+                throw IllegalArgumentException("multipart_boundary_missing")
+            }
+
+            var done = false
+            while (!done) {
+                val headerBlock = readPartHeaders(input)
+                val disposition = headerBlock.lineSequence()
+                    .firstOrNull { it.startsWith("Content-Disposition:", ignoreCase = true) }
+                    .orEmpty()
+                val name = Regex("""name="([^"]+)"""").find(disposition)?.groupValues?.get(1)
+                val filename = Regex("""filename="([^"]*)"""").find(disposition)?.groupValues?.get(1)
+                if (name == null) {
+                    streamPartTo(input, delimiter, DiscardOutputStream)
+                } else if (filename != null) {
+                    val tempFile = File(uploadDir, "upload-${System.currentTimeMillis()}-${UUID.randomUUID()}.tmp")
+                    tempFiles += tempFile
+                    val byteCount = FileOutputStream(tempFile).use { fileOutput ->
+                        streamPartTo(input, delimiter, fileOutput)
+                    }
+                    files.put(name, StreamedFile(tempFile, byteCount.toInt()))?.file?.delete()
                 } else {
-                    fields[name] = bytes.toString(StandardCharsets.UTF_8).trim()
+                    val fieldOutput = LimitedByteArrayOutputStream(MAX_FIELD_BYTES)
+                    streamPartTo(input, delimiter, fieldOutput)
+                    fields[name] = fieldOutput.toByteArray().toString(StandardCharsets.UTF_8).trim()
                 }
+                done = readBoundarySuffix(input)
+            }
+
+            return ParsedMultipart(fields = fields, files = files)
+        } catch (error: Throwable) {
+            tempFiles.forEach { it.delete() }
+            throw error
+        }
+    }
+
+    private fun readAsciiLine(input: InputStream): String {
+        val out = ByteArrayOutputStream()
+        while (true) {
+            val byte = input.read()
+            if (byte == -1) throw EOFException("Socket closed before multipart line completed")
+            if (byte == '\n'.code) {
+                val bytes = out.toByteArray()
+                val length = if (bytes.isNotEmpty() && bytes.last() == '\r'.code.toByte()) bytes.size - 1 else bytes.size
+                return String(bytes, 0, length, StandardCharsets.ISO_8859_1)
+            }
+            out.write(byte)
+            if (out.size() > MAX_PART_HEADER_BYTES) throw IllegalArgumentException("multipart line too large")
+        }
+    }
+
+    private fun readPartHeaders(input: InputStream): String {
+        val out = ByteArrayOutputStream()
+        val delimiter = byteArrayOf(13, 10, 13, 10)
+        var matched = 0
+        while (true) {
+            val byte = input.read()
+            if (byte == -1) throw EOFException("Socket closed before multipart headers completed")
+            out.write(byte)
+            matched = if (byte.toByte() == delimiter[matched]) {
+                matched + 1
+            } else if (byte.toByte() == delimiter[0]) {
+                1
+            } else {
+                0
+            }
+            if (matched == delimiter.size) {
+                val bytes = out.toByteArray()
+                return String(bytes, 0, bytes.size - delimiter.size, StandardCharsets.ISO_8859_1)
+            }
+            if (out.size() > MAX_PART_HEADER_BYTES) throw IllegalArgumentException("multipart headers too large")
+        }
+    }
+
+    private fun streamPartTo(input: InputStream, delimiter: ByteArray, output: OutputStream): Long {
+        val tail = ArrayDeque<Byte>()
+        var byteCount = 0L
+        while (true) {
+            val next = input.read()
+            if (next == -1) throw EOFException("Socket closed before multipart boundary completed")
+            tail.addLast(next.toByte())
+            if (tail.size > delimiter.size) {
+                output.write(tail.removeFirst().toInt() and 0xff)
+                byteCount += 1
             }
-            cursor = nextMarker + 2
+            if (tail.size == delimiter.size && tailMatches(tail, delimiter)) {
+                output.flush()
+                return byteCount
+            }
+        }
+    }
+
+    private fun tailMatches(tail: ArrayDeque<Byte>, delimiter: ByteArray): Boolean {
+        if (tail.size != delimiter.size) return false
+        tail.forEachIndexed { index, byte ->
+            if (byte != delimiter[index]) return false
         }
+        return true
+    }
 
-        return ParsedMultipart(fields = fields, files = files)
+    private fun readBoundarySuffix(input: InputStream): Boolean {
+        val first = input.read()
+        if (first == -1) throw EOFException("Socket closed after multipart boundary")
+        return when (first) {
+            '-'.code -> {
+                val second = input.read()
+                if (second != '-'.code) throw IllegalArgumentException("invalid multipart closing boundary")
+                true
+            }
+            '\r'.code -> {
+                val second = input.read()
+                if (second != '\n'.code) throw IllegalArgumentException("invalid multipart boundary separator")
+                false
+            }
+            else -> throw IllegalArgumentException("invalid multipart boundary suffix")
+        }
     }
 
     private fun multipartBoundary(contentType: String): String? {
@@ -286,12 +507,116 @@ class LocalPhotoUploadServer(
         return value.replace(Regex("[^A-Za-z0-9._-]"), "_").ifBlank { "photo" }
     }
 
-    private fun jsonEscape(value: String): String {
-        return value.replace("\\", "\\\\").replace("\"", "\\\"")
+    private fun jsonString(value: String): String {
+        return JSONObject.quote(value)
+    }
+
+    private fun moveFile(source: File, destination: File) {
+        if (destination.exists()) {
+            destination.delete()
+        }
+        if (!source.renameTo(destination)) {
+            source.copyTo(destination, overwrite = true)
+            source.delete()
+        }
+    }
+
+    private fun traceWifiInput(
+        type: String,
+        client: Socket,
+        startMs: Long,
+        values: MutableMap<String, Any?> = mutableMapOf(),
+    ) {
+        traceWifi("wifi_to_phone", "wifi_http_input", type, client, startMs, values)
+    }
+
+    private fun traceWifiOutput(
+        type: String,
+        client: Socket,
+        startMs: Long,
+        values: MutableMap<String, Any?> = mutableMapOf(),
+    ) {
+        traceWifi("phone_to_wifi", "wifi_http_output", type, client, startMs, values)
+    }
+
+    private fun traceWifi(
+        direction: String,
+        layer: String,
+        type: String,
+        client: Socket,
+        startMs: Long,
+        values: MutableMap<String, Any?>,
+    ) {
+        val payload = JSONObject()
+        putJson(payload, "type", type)
+        putJson(payload, "remoteHost", client.inetAddress?.hostAddress)
+        putJson(payload, "remotePort", client.port)
+        putJson(payload, "localHost", client.localAddress?.hostAddress)
+        putJson(payload, "localPort", client.localPort)
+        putJson(payload, "startMs", startMs)
+        values.forEach { (key, value) -> putJson(payload, key, value) }
+        try {
+            BleTraceLogger.logJson(direction, layer, payload, null)
+        } catch (_: Throwable) {
+        }
+    }
+
+    private fun putJson(payload: JSONObject, key: String, value: Any?) {
+        if (value == null) return
+        try {
+            payload.put(key, value)
+        } catch (_: Throwable) {
+        }
     }
 
     companion object {
         private const val MAX_HEADER_BYTES = 64 * 1024
+        private const val MAX_PART_HEADER_BYTES = 64 * 1024
+        private const val MAX_FIELD_BYTES = 64 * 1024
         private const val MAX_UPLOAD_BYTES = 25L * 1024L * 1024L
+        private const val MAX_ACTIVE_CLIENTS = 2
+    }
+}
+
+private object DiscardOutputStream : OutputStream() {
+    override fun write(b: Int) {
+    }
+}
+
+private class LimitedByteArrayOutputStream(
+    private val maxBytes: Int,
+) : ByteArrayOutputStream() {
+    override fun write(b: Int) {
+        if (size() + 1 > maxBytes) throw IllegalArgumentException("multipart field too large")
+        super.write(b)
+    }
+
+    override fun write(b: ByteArray, off: Int, len: Int) {
+        if (size() + len > maxBytes) throw IllegalArgumentException("multipart field too large")
+        super.write(b, off, len)
+    }
+}
+
+private class ContentLengthInputStream(
+    private val input: InputStream,
+    private var remainingBytes: Long,
+) : InputStream() {
+    override fun read(): Int {
+        if (remainingBytes <= 0) return -1
+        val byte = input.read()
+        if (byte != -1) {
+            remainingBytes -= 1
+        }
+        return byte
+    }
+
+    override fun read(buffer: ByteArray, offset: Int, length: Int): Int {
+        if (remainingBytes <= 0) return -1
+        val readLength = minOf(length.toLong(), remainingBytes).toInt()
+        val byteCount = input.read(buffer, offset, readLength)
+        if (byteCount > 0) {
+            remainingBytes -= byteCount.toLong()
+        }
+        return byteCount
     }
 }