sync: import Gitea changes for v1.5.3

JohnnWi · JohnnWi · commit 3078770b4c7e · 2026-04-30T17:15:07.000+02:00
diff --git a/HomelabAndroid/app/build.gradle.kts b/HomelabAndroid/app/build.gradle.kts
@@ -14,8 +14,8 @@ android {
         applicationId = "com.homelab.app"
         minSdk = 26
         targetSdk = 36
-        versionCode = 33
-        versionName = "1.5.2"
+        versionCode = 34
+        versionName = "1.5.3"
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         
         vectorDrawables {
diff --git a/HomelabAndroid/app/src/main/java/com/homelab/app/data/remote/api/MaltrailApi.kt b/HomelabAndroid/app/src/main/java/com/homelab/app/data/remote/api/MaltrailApi.kt
@@ -1,6 +1,7 @@
 package com.homelab.app.data.remote.api
 
 import kotlinx.serialization.json.JsonElement
+import okhttp3.ResponseBody
 import retrofit2.http.GET
 import retrofit2.http.Header
 import retrofit2.http.Query
@@ -18,5 +19,5 @@ interface MaltrailApi {
         @Header("X-Homelab-Service") service: String = "Maltrail",
         @Header("X-Homelab-Instance-Id") instanceId: String,
         @Query("date") date: String
-    ): JsonElement
+    ): ResponseBody
 }
diff --git a/HomelabAndroid/app/src/main/java/com/homelab/app/data/repository/MaltrailRepository.kt b/HomelabAndroid/app/src/main/java/com/homelab/app/data/repository/MaltrailRepository.kt
@@ -15,6 +15,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonNull
@@ -34,7 +35,7 @@ data class MaltrailCountPoint(
 ) {
     val apiDate: String
         get() = Instant.ofEpochSecond(timestamp)
-            .atZone(ZoneOffset.UTC)
+            .atZone(ZoneId.systemDefault())
             .toLocalDate()
             .format(DateTimeFormatter.ISO_LOCAL_DATE)
 
@@ -149,7 +150,7 @@ class MaltrailRepository @Inject constructor(
     }
 
     suspend fun getEvents(instanceId: String, date: String): List<MaltrailEvent> {
-        return parseEvents(api.getEvents(instanceId = instanceId, date = date))
+        return parseEvents(api.getEvents(instanceId = instanceId, date = date).string())
     }
 
     suspend fun getSummary(instanceId: String): MaltrailSummary {
@@ -236,6 +237,11 @@ class MaltrailRepository @Inject constructor(
         }.sortedByDescending { it.timestamp }
     }
 
+    private fun parseEvents(raw: String): List<MaltrailEvent> {
+        val jsonEvents = runCatching { parseEvents(Json.parseToJsonElement(raw)) }.getOrDefault(emptyList())
+        return jsonEvents.ifEmpty { parseTextEvents(raw) }
+    }
+
     private fun parseEvents(element: JsonElement): List<MaltrailEvent> {
         return extractObjectArray(element, "events", "data", "items", "results").mapIndexed { index, obj ->
             val raw = obj.toFlatStringMap()
@@ -263,6 +269,109 @@ class MaltrailRepository @Inject constructor(
         }
     }
 
+    private fun parseTextEvents(raw: String): List<MaltrailEvent> {
+        return raw.lineSequence()
+            .map { it.trim() }
+            .filter { it.isNotBlank() }
+            .mapIndexedNotNull { index, line ->
+                val parts = splitLogLine(line)
+                if (parts.size < 10) {
+                    return@mapIndexedNotNull MaltrailEvent(
+                        id = "raw-$index-${line.hashCode()}",
+                        timestamp = null,
+                        source = null,
+                        destination = null,
+                        protocolName = null,
+                        trail = null,
+                        severity = null,
+                        sensor = null,
+                        info = line,
+                        rawFields = mapOf("raw" to line)
+                    )
+                }
+
+                val hasSplitTimestamp = parts.getOrNull(0)?.matches(Regex("\\d{4}-\\d{2}-\\d{2}")) == true &&
+                    parts.getOrNull(1)?.contains(":") == true
+                val offset = if (hasSplitTimestamp) 1 else 0
+                val timestamp = if (hasSplitTimestamp) "${parts[0]} ${parts[1]}" else parts[0]
+                val sensor = parts.getOrNull(1 + offset)
+                val source = parts.getOrNull(2 + offset)
+                val sourcePort = parts.getOrNull(3 + offset)
+                val destination = parts.getOrNull(4 + offset)
+                val destinationPort = parts.getOrNull(5 + offset)
+                val protocol = parts.getOrNull(6 + offset)
+                val trailType = parts.getOrNull(7 + offset)
+                val trail = parts.getOrNull(8 + offset)
+                val info = parts.drop(9 + offset).joinToString(" ").ifBlank { null }
+                val rawFields = linkedMapOf(
+                    "timestamp" to timestamp,
+                    "sensor" to sensor,
+                    "src_ip" to source,
+                    "src_port" to sourcePort,
+                    "dst_ip" to destination,
+                    "dst_port" to destinationPort,
+                    "protocol" to protocol,
+                    "type" to trailType,
+                    "trail" to trail,
+                    "info" to info
+                ).mapNotNull { (key, value) -> value?.takeIf { it.isNotBlank() }?.let { key to it } }.toMap()
+
+                MaltrailEvent(
+                    id = "$timestamp|$source|$destination|$trail|$index",
+                    timestamp = timestamp,
+                    source = source,
+                    destination = destination,
+                    protocolName = protocol,
+                    trail = trail,
+                    severity = inferSeverity(info, trailType),
+                    sensor = sensor,
+                    info = info,
+                    rawFields = rawFields
+                )
+            }
+            .toList()
+    }
+
+    private fun splitLogLine(line: String): List<String> {
+        val result = mutableListOf<String>()
+        val current = StringBuilder()
+        var inQuotes = false
+        var escaping = false
+
+        for (char in line) {
+            when {
+                escaping -> {
+                    current.append(char)
+                    escaping = false
+                }
+                char == '\\' && inQuotes -> escaping = true
+                char == '"' -> inQuotes = !inQuotes
+                char.isWhitespace() && !inQuotes -> {
+                    if (current.isNotEmpty()) {
+                        result += current.toString()
+                        current.clear()
+                    }
+                }
+                else -> current.append(char)
+            }
+        }
+
+        if (current.isNotEmpty()) {
+            result += current.toString()
+        }
+        return result
+    }
+
+    private fun inferSeverity(info: String?, trailType: String?): String? {
+        val value = "${info.orEmpty()} ${trailType.orEmpty()}".lowercase(Locale.ROOT)
+        return when {
+            "malware" in value || "ransom" in value || "trojan" in value -> "high"
+            "malicious" in value || "attack" in value || "scanner" in value -> "medium"
+            "suspicious" in value -> "low"
+            else -> null
+        }
+    }
+
     private fun extractObjectArray(element: JsonElement, vararg keys: String): List<JsonObject> {
         when (element) {
             is JsonArray -> return element.mapNotNull { it as? JsonObject }
diff --git a/HomelabSwift/Homelab/Info.plist b/HomelabSwift/Homelab/Info.plist
@@ -53,9 +53,9 @@
 	<key>CFBundlePackageType</key>
 	<string>$(PRODUCT_BUNDLE_TYPE)</string>
 	<key>CFBundleShortVersionString</key>
-	<string>1.5.2</string>
+	<string>1.5.3</string>
 	<key>CFBundleVersion</key>
-	<string>33</string>
+	<string>34</string>
 	<key>LSApplicationQueriesSchemes</key>
 	<array>
 		<string>tailscale</string>
diff --git a/HomelabSwift/Homelab/Models/Maltrail/MaltrailModels.swift b/HomelabSwift/Homelab/Models/Maltrail/MaltrailModels.swift
@@ -71,7 +71,6 @@ enum MaltrailDateFormatting {
         let formatter = DateFormatter()
         formatter.calendar = Calendar(identifier: .gregorian)
         formatter.locale = Locale(identifier: "en_US_POSIX")
-        formatter.timeZone = TimeZone(secondsFromGMT: 0)
         formatter.dateFormat = "yyyy-MM-dd"
         return formatter.string(from: date)
     }
diff --git a/HomelabSwift/Homelab/Networking/Maltrail/MaltrailAPIClient.swift b/HomelabSwift/Homelab/Networking/Maltrail/MaltrailAPIClient.swift
@@ -182,8 +182,18 @@ actor MaltrailAPIClient {
     }
 
     private func parseEvents(from data: Data) throws -> [MaltrailEvent] {
-        let json = try JSONSerialization.jsonObject(with: data)
-        let rows = eventRows(from: json)
+        if let json = try? JSONSerialization.jsonObject(with: data) {
+            let rows = eventRows(from: json)
+            if !rows.isEmpty {
+                return parseEventRows(rows)
+            }
+        }
+
+        let raw = String(data: data, encoding: .utf8) ?? ""
+        return parseTextEvents(raw)
+    }
+
+    private func parseEventRows(_ rows: [[String: Any]]) -> [MaltrailEvent] {
         return rows.enumerated().map { index, row in
             let raw = row.reduce(into: [String: String]()) { partial, item in
                 if let text = Self.stringValue(item.value), !text.isEmpty {
@@ -207,6 +217,117 @@ actor MaltrailAPIClient {
         }
     }
 
+    private func parseTextEvents(_ raw: String) -> [MaltrailEvent] {
+        raw.split(whereSeparator: \.isNewline)
+            .map { String($0).trimmingCharacters(in: .whitespacesAndNewlines) }
+            .filter { !$0.isEmpty }
+            .enumerated()
+            .map { index, line in
+                let parts = splitLogLine(line)
+                guard parts.count >= 10 else {
+                    return MaltrailEvent(
+                        id: "raw-\(index)-\(line.hashValue)",
+                        timestamp: nil,
+                        source: nil,
+                        destination: nil,
+                        protocolName: nil,
+                        trail: nil,
+                        severity: nil,
+                        sensor: nil,
+                        info: line,
+                        rawFields: ["raw": line]
+                    )
+                }
+
+                let hasSplitTimestamp = parts.indices.contains(1)
+                    && parts[0].range(of: #"^\d{4}-\d{2}-\d{2}$"#, options: .regularExpression) != nil
+                    && parts[1].contains(":")
+                let offset = hasSplitTimestamp ? 1 : 0
+                let timestamp = hasSplitTimestamp ? "\(parts[0]) \(parts[1])" : parts[0]
+                let sensor = parts[safe: 1 + offset]
+                let source = parts[safe: 2 + offset]
+                let sourcePort = parts[safe: 3 + offset]
+                let destination = parts[safe: 4 + offset]
+                let destinationPort = parts[safe: 5 + offset]
+                let protocolName = parts[safe: 6 + offset]
+                let trailType = parts[safe: 7 + offset]
+                let trail = parts[safe: 8 + offset]
+                let infoPartsStart = 9 + offset
+                let info = parts.indices.contains(infoPartsStart)
+                    ? parts[infoPartsStart...].joined(separator: " ").nonEmptyValue
+                    : nil
+                let rawFields = [
+                    "timestamp": timestamp,
+                    "sensor": sensor,
+                    "src_ip": source,
+                    "src_port": sourcePort,
+                    "dst_ip": destination,
+                    "dst_port": destinationPort,
+                    "protocol": protocolName,
+                    "type": trailType,
+                    "trail": trail,
+                    "info": info
+                ].compactMapValues { $0?.nonEmptyValue }
+
+                return MaltrailEvent(
+                    id: "\(timestamp)|\(source ?? "")|\(destination ?? "")|\(trail ?? "")|\(index)",
+                    timestamp: timestamp,
+                    source: source,
+                    destination: destination,
+                    protocolName: protocolName,
+                    trail: trail,
+                    severity: inferSeverity(info: info, trailType: trailType),
+                    sensor: sensor,
+                    info: info,
+                    rawFields: rawFields
+                )
+            }
+    }
+
+    private func splitLogLine(_ line: String) -> [String] {
+        var result: [String] = []
+        var current = ""
+        var inQuotes = false
+        var escaping = false
+
+        for character in line {
+            if escaping {
+                current.append(character)
+                escaping = false
+            } else if character == "\\" && inQuotes {
+                escaping = true
+            } else if character == "\"" {
+                inQuotes.toggle()
+            } else if character.isWhitespace && !inQuotes {
+                if !current.isEmpty {
+                    result.append(current)
+                    current.removeAll(keepingCapacity: true)
+                }
+            } else {
+                current.append(character)
+            }
+        }
+
+        if !current.isEmpty {
+            result.append(current)
+        }
+        return result
+    }
+
+    private func inferSeverity(info: String?, trailType: String?) -> String? {
+        let value = "\(info ?? "") \(trailType ?? "")".lowercased()
+        if value.contains("malware") || value.contains("ransom") || value.contains("trojan") {
+            return "high"
+        }
+        if value.contains("malicious") || value.contains("attack") || value.contains("scanner") {
+            return "medium"
+        }
+        if value.contains("suspicious") {
+            return "low"
+        }
+        return nil
+    }
+
     private func eventRows(from json: Any) -> [[String: Any]] {
         if let rows = json as? [[String: Any]] {
             return rows
@@ -408,3 +529,16 @@ actor MaltrailAPIClient {
         return .custom(error.localizedDescription)
     }
 }
+
+private extension Array {
+    subscript(safe index: Int) -> Element? {
+        indices.contains(index) ? self[index] : nil
+    }
+}
+
+private extension String {
+    var nonEmptyValue: String? {
+        let trimmed = trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? nil : trimmed
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,6 @@ enum MaltrailDateFormatting {`
`71`	`71`	`let formatter = DateFormatter()`
`72`	`72`	`formatter.calendar = Calendar(identifier: .gregorian)`
`73`	`73`	`formatter.locale = Locale(identifier: "en_US_POSIX")`
`74`		`- formatter.timeZone = TimeZone(secondsFromGMT: 0)`
`75`	`74`	`formatter.dateFormat = "yyyy-MM-dd"`
`76`	`75`	`return formatter.string(from: date)`
`77`	`76`	`}`