From 3565539a8fb01b02b59d96ebf469fca756d501ed Mon Sep 17 00:00:00 2001
From: Carlos Guerra <cguerrave@gmail.com>
Date: Sat, 28 Mar 2026 17:55:39 +0100
Subject: [PATCH 01/13] GPS feature webapp side: GPS mode selector, fixed mode
 lat/lon, API endpoint. Merging with Wifi client and webdav features

---
 daemon/src/config.rs                          | 52 +++++++++++++
 daemon/src/gps.rs                             | 39 ++++++++++
 daemon/src/lib.rs                             |  1 +
 daemon/src/main.rs                            | 17 +++++
 daemon/src/server.rs                          |  3 +
 .../web/src/lib/components/ConfigForm.svelte  | 73 +++++++++++++++++++
 daemon/web/src/lib/utils.svelte.ts            | 20 +++++
 daemon/web/src/routes/+page.svelte            | 51 ++++++++++++-
 8 files changed, 255 insertions(+), 1 deletion(-)
 create mode 100644 daemon/src/gps.rs

diff --git a/daemon/src/config.rs b/daemon/src/config.rs
index 7f66af0f..43c93a7e 100644
--- a/daemon/src/config.rs
+++ b/daemon/src/config.rs
@@ -36,6 +36,12 @@ pub struct Config {
     pub min_space_to_start_recording_mb: u64,
     /// Minimum disk space required to continue a recording
     pub min_space_to_continue_recording_mb: u64,
+    /// GPS mode: 0=Disabled, 1=Fixed coordinates, 2=API endpoint
+    pub gps_mode: u8,
+    /// Fixed latitude used when gps_mode=1
+    pub gps_fixed_latitude: Option<f64>,
+    /// Fixed longitude used when gps_mode=1
+    pub gps_fixed_longitude: Option<f64>,
     /// Wifi client SSID
     pub wifi_ssid: Option<String>,
     /// Wifi client password
@@ -104,6 +110,9 @@ impl Default for Config {
             enabled_notifications: vec![NotificationType::Warning, NotificationType::LowBattery],
             min_space_to_start_recording_mb: 1,
             min_space_to_continue_recording_mb: 1,
+            gps_mode: 0,
+            gps_fixed_latitude: None,
+            gps_fixed_longitude: None,
             wifi_ssid: None,
             wifi_password: None,
             wifi_security: None,
@@ -159,6 +168,49 @@ fn resolve_bin(name: &str) -> Option<String> {
     None
 }
 
+impl Config {
+    pub fn wifi_config(&self) -> wifi_station::WifiConfig {
+        let (wpa_bin, hostapd_conf, ctrl_interface) = match self.device {
+            Device::Tmobile | Device::Wingtech => (
+                Some("/usr/sbin/wpa_supplicant".into()),
+                Some("/data/configs/hostapd.conf".into()),
+                None,
+            ),
+            Device::Uz801 => (
+                Some("/system/bin/wpa_supplicant".into()),
+                Some("/data/misc/wifi/hostapd.conf".into()),
+                Some("/data/misc/wifi/sockets".into()),
+            ),
+            _ => (None, None, None),
+        };
+        wifi_station::WifiConfig {
+            wifi_enabled: self.wifi_enabled,
+            dns_servers: self.dns_servers.clone(),
+            wifi_ssid: self.wifi_ssid.clone(),
+            wifi_password: self.wifi_password.clone(),
+            security_type: self.wifi_security,
+            wpa_supplicant_bin: wpa_bin.or_else(|| resolve_bin("wpa_supplicant")),
+            hostapd_conf,
+            ctrl_interface,
+            udhcpc_hook_path: Some("/data/rayhunter/udhcpc-hook.sh".into()),
+            dhcp_lease_path: Some("/data/rayhunter/dhcp_lease".into()),
+            wpa_conf_path: Some("/data/rayhunter/wpa_sta.conf".into()),
+            iw_bin: resolve_bin("iw"),
+            udhcpc_bin: resolve_bin("udhcpc"),
+            crash_log_dir: Some("/data/rayhunter/crash-logs".into()),
+            wakelock_name: Some("rayhunter".into()),
+        }
+    }
+}
+
+fn resolve_bin(name: &str) -> Option<String> {
+    let local = format!("/data/rayhunter/bin/{name}");
+    if std::path::Path::new(&local).exists() {
+        return Some(local);
+    }
+    None
+}
+
 pub async fn parse_config<P>(path: P) -> Result<Config, RayhunterError>
 where
     P: AsRef<std::path::Path>,
diff --git a/daemon/src/gps.rs b/daemon/src/gps.rs
new file mode 100644
index 00000000..c1f01c02
--- /dev/null
+++ b/daemon/src/gps.rs
@@ -0,0 +1,39 @@
+use axum::Json;
+use axum::extract::State;
+use axum::http::StatusCode;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+use crate::server::ServerState;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct GpsData {
+    pub latitude: f64,
+    pub longitude: f64,
+    pub timestamp: String,
+}
+
+pub async fn post_gps(
+    State(state): State<Arc<ServerState>>,
+    Json(gps_data): Json<GpsData>,
+) -> Result<StatusCode, (StatusCode, String)> {
+    if state.config.gps_mode != 2 {
+        return Err((
+            StatusCode::FORBIDDEN,
+            "GPS API endpoint is disabled. Set gps_mode to 2 in configuration.".to_string(),
+        ));
+    }
+    let mut gps = state.gps_state.write().await;
+    *gps = Some(gps_data);
+    Ok(StatusCode::OK)
+}
+
+pub async fn get_gps(
+    State(state): State<Arc<ServerState>>,
+) -> Result<Json<GpsData>, StatusCode> {
+    let gps = state.gps_state.read().await;
+    match gps.as_ref() {
+        Some(data) => Ok(Json(data.clone())),
+        None => Err(StatusCode::NOT_FOUND),
+    }
+}
diff --git a/daemon/src/lib.rs b/daemon/src/lib.rs
index 18353792..ce0f83dd 100644
--- a/daemon/src/lib.rs
+++ b/daemon/src/lib.rs
@@ -6,6 +6,7 @@ pub mod diag;
 pub mod display;
 pub mod error;
 pub mod firewall;
+pub mod gps;
 pub mod key_input;
 pub mod notifications;
 pub mod pcap;
diff --git a/daemon/src/main.rs b/daemon/src/main.rs
index 80cde339..9da023d5 100644
--- a/daemon/src/main.rs
+++ b/daemon/src/main.rs
@@ -6,6 +6,7 @@ mod diag;
 mod display;
 mod error;
 mod firewall;
+mod gps;
 mod key_input;
 mod notifications;
 mod pcap;
@@ -24,6 +25,7 @@ use crate::error::RayhunterError;
 use crate::notifications::{NotificationService, run_notification_worker};
 use crate::pcap::get_pcap;
 use crate::qmdl_store::RecordingStore;
+use crate::gps::{get_gps, post_gps};
 use crate::server::{
     ServerState, debug_set_display_state, get_config, get_qmdl, get_time, get_wifi_status, get_zip,
     scan_wifi, serve_static, set_config, set_time_offset, test_notification,
@@ -79,6 +81,8 @@ fn get_router() -> AppRouter {
         .route("/api/time", get(get_time))
         .route("/api/time-offset", post(set_time_offset))
         .route("/api/debug/display-state", post(debug_set_display_state))
+        .route("/api/gps", get(get_gps))
+        .route("/api/gps", post(post_gps))
         .route("/", get(|| async { Redirect::permanent("/index.html") }))
         .route("/{*path}", get(serve_static))
 }
@@ -298,6 +302,18 @@ async fn run_with_config(
             webdav_config.into(),
         );
     }
+    let initial_gps = if config.gps_mode == 1 {
+        match (config.gps_fixed_latitude, config.gps_fixed_longitude) {
+            (Some(lat), Some(lon)) => Some(gps::GpsData {
+                latitude: lat,
+                longitude: lon,
+                timestamp: "fixed".to_string(),
+            }),
+            _ => None,
+        }
+    } else {
+        None
+    };
 
     let state = Arc::new(ServerState {
         config_path: args.config_path.clone(),
@@ -310,6 +326,7 @@ async fn run_with_config(
         ui_update_sender: Some(ui_update_tx),
         wifi_status,
         wifi_scan_lock: tokio::sync::Mutex::new(()),
+        gps_state: Arc::new(tokio::sync::RwLock::new(initial_gps)),
     });
     run_server(&task_tracker, state, shutdown_token.clone()).await;
 
diff --git a/daemon/src/server.rs b/daemon/src/server.rs
index b4422387..541ac2cb 100644
--- a/daemon/src/server.rs
+++ b/daemon/src/server.rs
@@ -26,6 +26,7 @@ use crate::config::Config;
 use crate::diag::DiagDeviceCtrlMessage;
 use crate::display::DisplayState;
 use crate::notifications::DEFAULT_NOTIFICATION_TIMEOUT;
+use crate::gps::GpsData;
 use crate::pcap::generate_pcap_data;
 use crate::qmdl_store::RecordingStore;
 
@@ -40,6 +41,7 @@ pub struct ServerState {
     pub ui_update_sender: Option<Sender<DisplayState>>,
     pub wifi_status: Arc<RwLock<wifi_station::WifiStatus>>,
     pub wifi_scan_lock: tokio::sync::Mutex<()>,
+    pub gps_state: Arc<RwLock<Option<GpsData>>>,
 }
 
 #[cfg_attr(feature = "apidocs", utoipa::path(
@@ -566,6 +568,7 @@ mod tests {
             ui_update_sender: None,
             wifi_status: Arc::new(RwLock::new(wifi_station::WifiStatus::default())),
             wifi_scan_lock: tokio::sync::Mutex::new(()),
+            gps_state: Arc::new(RwLock::new(None)),
         })
     }
 
diff --git a/daemon/web/src/lib/components/ConfigForm.svelte b/daemon/web/src/lib/components/ConfigForm.svelte
index 1facbc1d..6e44080d 100644
--- a/daemon/web/src/lib/components/ConfigForm.svelte
+++ b/daemon/web/src/lib/components/ConfigForm.svelte
@@ -668,6 +668,79 @@
                     </div>
                 </div>
 
+                <div class="border-t pt-4 mt-6 space-y-3">
+                    <h3 class="text-lg font-semibold text-gray-800 mb-4">GPS Settings</h3>
+
+                    <div>
+                        <label for="gps_mode" class="block text-sm font-medium text-gray-700 mb-1">
+                            GPS Mode
+                        </label>
+                        <select
+                            id="gps_mode"
+                            bind:value={config.gps_mode}
+                            class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue"
+                        >
+                            <option value={0}>0 - Disabled</option>
+                            <option value={1}>1 - Fixed coordinates</option>
+                            <option value={2}>2 - API Endpoint</option>
+                        </select>
+                        <p class="text-xs text-gray-500 mt-1">
+                            {#if config.gps_mode === 2}
+                                POST latitude, longitude, and timestamp to <code>/api/gps</code> from
+                                any device on the network.
+                            {:else if config.gps_mode === 1}
+                                GPS coordinates are fixed to the values below.
+                            {:else}
+                                GPS is disabled; no coordinates will be tracked.
+                            {/if}
+                        </p>
+                    </div>
+
+                    {#if config.gps_mode === 1}
+                        <div>
+                            <label
+                                for="gps_fixed_latitude"
+                                class="block text-sm font-medium text-gray-700 mb-1"
+                            >
+                                Fixed Latitude
+                            </label>
+                            <input
+                                id="gps_fixed_latitude"
+                                type="number"
+                                min="-90"
+                                max="90"
+                                step="any"
+                                required
+                                bind:value={config.gps_fixed_latitude}
+                                placeholder="e.g. 37.7749"
+                                class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue"
+                            />
+                            <p class="text-xs text-gray-500 mt-1">Decimal degrees, -90 to 90</p>
+                        </div>
+
+                        <div>
+                            <label
+                                for="gps_fixed_longitude"
+                                class="block text-sm font-medium text-gray-700 mb-1"
+                            >
+                                Fixed Longitude
+                            </label>
+                            <input
+                                id="gps_fixed_longitude"
+                                type="number"
+                                min="-180"
+                                max="180"
+                                step="any"
+                                required
+                                bind:value={config.gps_fixed_longitude}
+                                placeholder="e.g. -122.4194"
+                                class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue"
+                            />
+                            <p class="text-xs text-gray-500 mt-1">Decimal degrees, -180 to 180</p>
+                        </div>
+                    {/if}
+                </div>
+
                 <div class="flex gap-2 pt-4">
                     <button
                         type="submit"
diff --git a/daemon/web/src/lib/utils.svelte.ts b/daemon/web/src/lib/utils.svelte.ts
index a8824f0b..d30581b4 100644
--- a/daemon/web/src/lib/utils.svelte.ts
+++ b/daemon/web/src/lib/utils.svelte.ts
@@ -35,6 +35,9 @@ export interface Config {
     dns_servers: string[] | null;
     firewall_restrict_outbound: boolean;
     firewall_allowed_ports: number[] | null;
+    gps_mode: number;
+    gps_fixed_latitude: number | null;
+    gps_fixed_longitude: number | null;
 }
 
 export interface WifiStatus {
@@ -142,3 +145,20 @@ export interface TimeResponse {
 export async function get_daemon_time(): Promise<TimeResponse> {
     return JSON.parse(await req('GET', '/api/time'));
 }
+
+export interface GpsData {
+    latitude: number;
+    longitude: number;
+    timestamp: string;
+}
+
+export async function get_gps(): Promise<GpsData | null> {
+    const response = await fetch('/api/gps');
+    if (response.status === 404) {
+        return null;
+    }
+    if (response.status >= 200 && response.status < 300) {
+        return response.json();
+    }
+    throw new Error(await response.text());
+}
diff --git a/daemon/web/src/routes/+page.svelte b/daemon/web/src/routes/+page.svelte
index c2d2faa4..ede0eba7 100644
--- a/daemon/web/src/routes/+page.svelte
+++ b/daemon/web/src/routes/+page.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
     import { ManifestEntry } from '$lib/manifest.svelte';
-    import { get_manifest, get_system_stats } from '$lib/utils.svelte';
+    import { get_manifest, get_system_stats, get_gps, get_config, type GpsData } from '$lib/utils.svelte';
     import ManifestTable from '$lib/components/ManifestTable.svelte';
     import Card from '$lib/components/ManifestCard.svelte';
     import type { SystemStats } from '$lib/systemStats';
@@ -22,7 +22,13 @@
     let update_error: string | undefined = $state(undefined);
     let logview_shown: boolean = $state(false);
     let config_shown: boolean = $state(false);
+    let gps_data: GpsData | null = $state(null);
+    let gps_mode: number = $state(0);
     $effect(() => {
+        get_config().then((c) => {
+            gps_mode = c.gps_mode;
+        });
+
         const interval = setInterval(async () => {
             try {
                 // Don't update UI if browser tab isn't visible
@@ -40,6 +46,7 @@
                 current_entry = new_manifest.current_entry;
 
                 system_stats = await get_system_stats();
+                gps_data = await get_gps();
                 update_error = undefined;
                 loaded = true;
             } catch (error) {
@@ -283,6 +290,48 @@
             {/if}
             <SystemStatsTable stats={system_stats!} />
         </div>
+        {#if gps_mode !== 0}
+        <div class="bg-white border border-gray-200 drop-shadow rounded-md p-4 flex flex-col gap-2">
+            <span class="text-lg font-semibold flex flex-row items-center gap-2">
+                <svg
+                    class="w-5 h-5 text-rayhunter-blue"
+                    aria-hidden="true"
+                    xmlns="http://www.w3.org/2000/svg"
+                    width="24"
+                    height="24"
+                    fill="currentColor"
+                    viewBox="0 0 24 24"
+                >
+                    <path
+                        fill-rule="evenodd"
+                        d="M11.906 1.994a8.002 8.002 0 0 1 8.09 8.421 7.996 7.996 0 0 1-1.297 3.957.996.996 0 0 1-.133.204l-.108.129c-.178.243-.37.477-.573.699l-5.112 6.224a1 1 0 0 1-1.545 0L5.982 15.26l-.002-.002a18.146 18.146 0 0 1-.309-.38l-.133-.163a.999.999 0 0 1-.13-.202 7.995 7.995 0 0 1 6.498-12.518ZM15 9.997a3 3 0 1 1-5.999 0 3 3 0 0 1 5.999 0Z"
+                        clip-rule="evenodd"
+                    />
+                </svg>
+                GPS Status
+            </span>
+            {#if gps_data}
+                <table class="w-full text-sm">
+                    <tbody>
+                        <tr class="border-b border-gray-100">
+                            <td class="py-1 pr-4 text-gray-500 font-medium">Latitude</td>
+                            <td class="py-1 font-mono">{gps_data.latitude.toFixed(6)}</td>
+                        </tr>
+                        <tr class="border-b border-gray-100">
+                            <td class="py-1 pr-4 text-gray-500 font-medium">Longitude</td>
+                            <td class="py-1 font-mono">{gps_data.longitude.toFixed(6)}</td>
+                        </tr>
+                        <tr>
+                            <td class="py-1 pr-4 text-gray-500 font-medium">GPS Timestamp</td>
+                            <td class="py-1 font-mono">{gps_data.timestamp}</td>
+                        </tr>
+                    </tbody>
+                </table>
+            {:else}
+                <span class="text-gray-400 text-sm">Awaiting GPS data...</span>
+            {/if}
+        </div>
+        {/if}
         <div class="flex flex-col gap-2">
             <div class="flex flex-row gap-2">
                 <div class="text-xl flex-1">History</div>

From 4b3c3317104e0dbfde06f208fff0bc690beee08f Mon Sep 17 00:00:00 2001
From: Carlos Guerra <cguerrave@gmail.com>
Date: Sat, 28 Mar 2026 22:29:41 +0100
Subject: [PATCH 02/13] GPS information included in PCAP files as comment and
 with Kismet proposed standard

---
 check/src/main.rs                  |   2 +-
 daemon/src/gps.rs                  |  43 ++++++++-
 daemon/src/pcap.rs                 |  75 ++++++++++++++-
 daemon/src/qmdl_store.rs           |  37 ++++++++
 daemon/src/server.rs               |   5 +-
 daemon/web/src/lib/utils.svelte.ts |   2 +-
 lib/src/pcap.rs                    | 145 +++++++++++++++++++++++++++--
 7 files changed, 291 insertions(+), 18 deletions(-)

diff --git a/check/src/main.rs b/check/src/main.rs
index 87105341..a449030a 100644
--- a/check/src/main.rs
+++ b/check/src/main.rs
@@ -158,7 +158,7 @@ async fn pcapify(qmdl_path: &PathBuf) {
         for msg in container.into_messages().into_iter().flatten() {
             if let Ok(Some((timestamp, parsed))) = gsmtap_parser::parse(msg) {
                 pcap_writer
-                    .write_gsmtap_message(parsed, timestamp)
+                    .write_gsmtap_message(parsed, timestamp, None)
                     .await
                     .expect("failed to write");
             }
diff --git a/daemon/src/gps.rs b/daemon/src/gps.rs
index c1f01c02..d25c7a92 100644
--- a/daemon/src/gps.rs
+++ b/daemon/src/gps.rs
@@ -3,6 +3,7 @@ use axum::extract::State;
 use axum::http::StatusCode;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 
 use crate::server::ServerState;
 
@@ -13,6 +14,28 @@ pub struct GpsData {
     pub timestamp: String,
 }
 
+/// A single GPS fix recorded in the sidecar file alongside a QMDL recording.
+#[derive(Serialize, Deserialize)]
+pub struct GpsRecord {
+    /// Unix timestamp (seconds) of when this fix was received by the server.
+    pub unix_ts: u32,
+    pub lat: f64,
+    pub lon: f64,
+}
+
+/// Reads all GPS records from a sidecar file, skipping malformed lines.
+pub async fn load_gps_records(file: tokio::fs::File) -> Vec<GpsRecord> {
+    let reader = BufReader::new(file);
+    let mut lines = reader.lines();
+    let mut records = Vec::new();
+    while let Ok(Some(line)) = lines.next_line().await {
+        if let Ok(record) = serde_json::from_str::<GpsRecord>(&line) {
+            records.push(record);
+        }
+    }
+    records
+}
+
 pub async fn post_gps(
     State(state): State<Arc<ServerState>>,
     Json(gps_data): Json<GpsData>,
@@ -24,7 +47,25 @@ pub async fn post_gps(
         ));
     }
     let mut gps = state.gps_state.write().await;
-    *gps = Some(gps_data);
+    *gps = Some(gps_data.clone());
+    drop(gps);
+
+    // Append the GPS fix to the current recording's sidecar file.
+    let qmdl_store = state.qmdl_store_lock.read().await;
+    if let Some((entry_idx, _)) = qmdl_store.get_current_entry() {
+        if let Ok(mut file) = qmdl_store.open_entry_gps_for_append(entry_idx).await {
+            let unix_ts = chrono::Utc::now().timestamp() as u32;
+            let record = GpsRecord {
+                unix_ts,
+                lat: gps_data.latitude,
+                lon: gps_data.longitude,
+            };
+            if let Ok(json) = serde_json::to_string(&record) {
+                let _ = file.write_all(format!("{json}\n").as_bytes()).await;
+            }
+        }
+    }
+
     Ok(StatusCode::OK)
 }
 
diff --git a/daemon/src/pcap.rs b/daemon/src/pcap.rs
index fce37d64..e0b68095 100644
--- a/daemon/src/pcap.rs
+++ b/daemon/src/pcap.rs
@@ -1,3 +1,4 @@
+use crate::gps::{GpsRecord, load_gps_records};
 use crate::server::ServerState;
 
 use anyhow::Error;
@@ -9,7 +10,7 @@ use axum::response::{IntoResponse, Response};
 use log::error;
 use rayhunter::diag::DataType;
 use rayhunter::gsmtap_parser;
-use rayhunter::pcap::GsmtapPcapWriter;
+use rayhunter::pcap::{GsmtapPcapWriter, KismetGpsPoint};
 use rayhunter::qmdl::QmdlReader;
 use std::sync::Arc;
 use tokio::io::{AsyncRead, AsyncWrite, duplex};
@@ -56,12 +57,12 @@ pub async fn get_pcap(
         .open_entry_qmdl(entry_index)
         .await
         .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e:?}")))?;
-    // the QMDL reader should stop at the last successfully written data chunk
-    // (entry.size_bytes)
     let (reader, writer) = duplex(1024);
+    let gps_records = load_gps_records_for_entry(&state, entry_index).await;
+    drop(qmdl_store);
 
     tokio::spawn(async move {
-        if let Err(e) = generate_pcap_data(writer, qmdl_file, qmdl_size_bytes).await {
+        if let Err(e) = generate_pcap_data(writer, qmdl_file, qmdl_size_bytes, gps_records).await {
             error!("failed to generate PCAP: {e:?}");
         }
     });
@@ -71,10 +72,71 @@ pub async fn get_pcap(
     Ok((headers, body).into_response())
 }
 
+/// Loads GPS records for a recording entry.
+///
+/// - `gps_mode == 0`: returns empty vec (no GPS)
+/// - `gps_mode == 1`: returns a single synthetic record with `unix_ts = 0` (fixed coordinates)
+/// - `gps_mode == 2`: loads per-fix records from the GPS sidecar file
+pub(crate) async fn load_gps_records_for_entry(
+    state: &Arc<ServerState>,
+    entry_index: usize,
+) -> Vec<GpsRecord> {
+    if state.config.gps_mode == 0 {
+        return vec![];
+    }
+    if state.config.gps_mode == 1 {
+        let guard = state.gps_state.read().await;
+        return guard
+            .as_ref()
+            .map(|g| {
+                vec![GpsRecord {
+                    unix_ts: 0, // 0 signals fixed/synthetic to the Kismet option builder
+                    lat: g.latitude,
+                    lon: g.longitude,
+                }]
+            })
+            .unwrap_or_default();
+    }
+    // gps_mode == 2: load from sidecar
+    let qmdl_store = state.qmdl_store_lock.read().await;
+    match qmdl_store.open_entry_gps(entry_index).await {
+        Ok(file) => load_gps_records(file).await,
+        Err(_) => vec![],
+    }
+}
+
+/// Returns the GPS fix from `records` whose `unix_ts` is closest to `packet_unix_ts`.
+/// Returns `None` if `records` is empty.
+fn find_nearest_gps(records: &[GpsRecord], packet_unix_ts: u32) -> Option<KismetGpsPoint> {
+    if records.is_empty() {
+        return None;
+    }
+    let idx = records.partition_point(|r| r.unix_ts <= packet_unix_ts);
+    let record = if idx == 0 {
+        &records[0]
+    } else if idx >= records.len() {
+        &records[records.len() - 1]
+    } else {
+        let before = &records[idx - 1];
+        let after = &records[idx];
+        if packet_unix_ts - before.unix_ts <= after.unix_ts - packet_unix_ts {
+            before
+        } else {
+            after
+        }
+    };
+    Some(KismetGpsPoint {
+        latitude: record.lat,
+        longitude: record.lon,
+        timestamp_unix_secs: record.unix_ts,
+    })
+}
+
 pub async fn generate_pcap_data<R, W>(
     writer: W,
     qmdl_file: R,
     qmdl_size_bytes: usize,
+    gps_records: Vec<GpsRecord>,
 ) -> Result<(), Error>
 where
     W: AsyncWrite + Unpin + Send,
@@ -94,8 +156,11 @@ where
                 Ok(msg) => {
                     let maybe_gsmtap_msg = gsmtap_parser::parse(msg)?;
                     if let Some((timestamp, gsmtap_msg)) = maybe_gsmtap_msg {
+                        let packet_unix_ts =
+                            timestamp.to_datetime().timestamp().max(0) as u32;
+                        let gps = find_nearest_gps(&gps_records, packet_unix_ts);
                         pcap_writer
-                            .write_gsmtap_message(gsmtap_msg, timestamp)
+                            .write_gsmtap_message(gsmtap_msg, timestamp, gps.as_ref())
                             .await?;
                     }
                 }
diff --git a/daemon/src/qmdl_store.rs b/daemon/src/qmdl_store.rs
index 445a504e..1eefb662 100644
--- a/daemon/src/qmdl_store.rs
+++ b/daemon/src/qmdl_store.rs
@@ -100,6 +100,12 @@ impl ManifestEntry {
         filepath.set_extension("ndjson");
         filepath
     }
+
+    pub fn get_gps_filepath<P: AsRef<Path>>(&self, path: P) -> PathBuf {
+        let mut filepath = path.as_ref().join(&self.name);
+        filepath.set_extension("gps.ndjson");
+        filepath
+    }
 }
 
 impl RecordingStore {
@@ -263,6 +269,10 @@ impl RecordingStore {
         let analysis_file = File::create(&analysis_filepath)
             .await
             .map_err(RecordingStoreError::CreateFileError)?;
+        let gps_filepath = new_entry.get_gps_filepath(&self.path);
+        File::create(&gps_filepath)
+            .await
+            .map_err(RecordingStoreError::CreateFileError)?;
         self.manifest.entries.push(new_entry);
         self.current_entry = Some(self.manifest.entries.len() - 1);
         self.write_manifest().await?;
@@ -288,6 +298,26 @@ impl RecordingStore {
             .map_err(RecordingStoreError::ReadFileError)
     }
 
+    pub async fn open_entry_gps(&self, entry_index: usize) -> Result<File, RecordingStoreError> {
+        let entry = &self.manifest.entries[entry_index];
+        File::open(entry.get_gps_filepath(&self.path))
+            .await
+            .map_err(RecordingStoreError::ReadFileError)
+    }
+
+    pub async fn open_entry_gps_for_append(
+        &self,
+        entry_index: usize,
+    ) -> Result<File, RecordingStoreError> {
+        let entry = &self.manifest.entries[entry_index];
+        OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(entry.get_gps_filepath(&self.path))
+            .await
+            .map_err(RecordingStoreError::CreateFileError)
+    }
+
     pub async fn clear_and_open_entry_analysis(
         &mut self,
         entry_index: usize,
@@ -436,12 +466,16 @@ impl RecordingStore {
         self.write_manifest().await?;
         let qmdl_filepath = entry_to_delete.get_qmdl_filepath(&self.path);
         let analysis_filepath = entry_to_delete.get_analysis_filepath(&self.path);
+        let gps_filepath = entry_to_delete.get_gps_filepath(&self.path);
         remove_file_if_exists(&qmdl_filepath)
             .await
             .map_err(RecordingStoreError::DeleteFileError)?;
         remove_file_if_exists(&analysis_filepath)
             .await
             .map_err(RecordingStoreError::DeleteFileError)?;
+        remove_file_if_exists(&gps_filepath)
+            .await
+            .map_err(RecordingStoreError::DeleteFileError)?;
         Ok(())
     }
 
@@ -468,6 +502,9 @@ impl RecordingStore {
                 continue;
             }
 
+            let gps_filepath = entry.get_gps_filepath(&self.path);
+            remove_file_if_exists(&gps_filepath).await.ok();
+
             keep.push(false);
         }
 
diff --git a/daemon/src/server.rs b/daemon/src/server.rs
index 541ac2cb..12fc72d5 100644
--- a/daemon/src/server.rs
+++ b/daemon/src/server.rs
@@ -27,7 +27,7 @@ use crate::diag::DiagDeviceCtrlMessage;
 use crate::display::DisplayState;
 use crate::notifications::DEFAULT_NOTIFICATION_TIMEOUT;
 use crate::gps::GpsData;
-use crate::pcap::generate_pcap_data;
+use crate::pcap::{generate_pcap_data, load_gps_records_for_entry};
 use crate::qmdl_store::RecordingStore;
 
 pub struct ServerState {
@@ -345,6 +345,7 @@ pub async fn get_zip(
     };
 
     let qmdl_store_lock = state.qmdl_store_lock.clone();
+    let gps_records = load_gps_records_for_entry(&state, entry_index).await;
 
     let (reader, writer) = duplex(8192);
 
@@ -388,7 +389,7 @@ pub async fn get_zip(
                 };
 
                 if let Err(e) =
-                    generate_pcap_data(&mut entry_writer, qmdl_file_for_pcap, qmdl_size_bytes).await
+                    generate_pcap_data(&mut entry_writer, qmdl_file_for_pcap, qmdl_size_bytes, gps_records).await
                 {
                     // if we fail to generate the PCAP file, we should still continue and give the
                     // user the QMDL.
diff --git a/daemon/web/src/lib/utils.svelte.ts b/daemon/web/src/lib/utils.svelte.ts
index d30581b4..2e27d677 100644
--- a/daemon/web/src/lib/utils.svelte.ts
+++ b/daemon/web/src/lib/utils.svelte.ts
@@ -153,7 +153,7 @@ export interface GpsData {
 }
 
 export async function get_gps(): Promise<GpsData | null> {
-    const response = await fetch('/api/gps');
+    const response = await fetch('/api/gps', { cache: 'no-store' });
     if (response.status === 404) {
         return null;
     }
diff --git a/lib/src/pcap.rs b/lib/src/pcap.rs
index 7d6f1d91..da624343 100644
--- a/lib/src/pcap.rs
+++ b/lib/src/pcap.rs
@@ -6,6 +6,7 @@ use crate::gsmtap::GsmtapMessage;
 use chrono::prelude::*;
 use deku::prelude::*;
 use pcap_file_tokio::pcapng::PcapNgWriter;
+use pcap_file_tokio::pcapng::RawBlock;
 use pcap_file_tokio::pcapng::blocks::enhanced_packet::EnhancedPacketBlock;
 use pcap_file_tokio::pcapng::blocks::interface_description::InterfaceDescriptionBlock;
 use pcap_file_tokio::pcapng::blocks::section_header::{SectionHeaderBlock, SectionHeaderOption};
@@ -26,6 +27,89 @@ pub enum GsmtapPcapError {
     Deku(#[from] DekuError),
 }
 
+/// A GPS fix to embed in each PCAP packet as a Kismet-compatible custom option.
+///
+/// Set `timestamp_unix_secs = 0` to signal a fixed/synthetic coordinate (no real GPS time).
+pub struct KismetGpsPoint {
+    pub latitude: f64,
+    pub longitude: f64,
+    pub timestamp_unix_secs: u32,
+}
+
+// Block type constant for Enhanced Packet Block (pcapng spec §4.3)
+const ENHANCED_PACKET_BLOCK: u32 = 0x00000006;
+
+/// Serialises a Kismet GPS custom option into a byte buffer suitable for
+/// appending directly to an EPB body.
+///
+/// Wire layout (section is big-endian; GPS custom payload is little-endian per
+/// Kismet convention):
+///
+///   option_code  u16 BE = 2989  (custom binary, non-copyable)
+///   option_len   u16 BE = 24    (PEN 4 + payload 20)
+///   pen          u32 BE = 55922 (Kismet IANA PEN)
+///   --- custom payload (20 bytes, all fields little-endian) ---
+///   magic        u8  = 0x47
+///   version      u8  = 0x01
+///   fields_len   u16 LE = 16   (bitmask + lon + lat + ts)
+///   bitmask      u32 LE = 0x26 (lon=0x2, lat=0x4, gps_time=0x20)
+///   longitude    i32 LE fixed37 (degrees × 1e7)
+///   latitude     i32 LE fixed37 (degrees × 1e7)
+///   gps_time     u32 LE unix seconds (0 = fixed/unknown)
+///   --- end-of-options marker ---
+///   end_code     u16 BE = 0
+///   end_len      u16 BE = 0
+fn build_gps_option_bytes(gps: &KismetGpsPoint) -> Vec<u8> {
+    // --- opt_comment (code 1): human-readable GPS for Wireshark ---
+    // Format chosen to match what Kismet writes so tools see a consistent label.
+    let comment = if gps.timestamp_unix_secs == 0 {
+        format!("GPS fixed lat={:.7} lon={:.7}", gps.latitude, gps.longitude)
+    } else {
+        format!("GPS lat={:.7} lon={:.7} ts={}", gps.latitude, gps.longitude, gps.timestamp_unix_secs)
+    };
+    let comment_bytes = comment.as_bytes();
+    let comment_pad = (4 - (comment_bytes.len() % 4)) % 4;
+
+    // --- Kismet GPS custom option (code 2989) ---
+    let lon_fixed: i32 = (gps.longitude * 1e7) as i32;
+    let lat_fixed: i32 = (gps.latitude * 1e7) as i32;
+
+    // Custom payload: 20 bytes, all little-endian (Kismet convention)
+    let fields_len: u16 = 16; // bitmask(4) + lon(4) + lat(4) + ts(4)
+    let bitmask: u32 = 0x2 | 0x4 | 0x20; // lon | lat | gps_time
+    let mut payload = Vec::<u8>::with_capacity(20);
+    payload.push(0x47); // magic
+    payload.push(0x01); // version
+    payload.extend_from_slice(&fields_len.to_le_bytes());
+    payload.extend_from_slice(&bitmask.to_le_bytes());
+    payload.extend_from_slice(&lon_fixed.to_le_bytes());
+    payload.extend_from_slice(&lat_fixed.to_le_bytes());
+    payload.extend_from_slice(&gps.timestamp_unix_secs.to_le_bytes());
+    // payload is exactly 20 bytes, already 4-byte aligned
+
+    // option_len = PEN (4) + payload (20) = 24, also 4-byte aligned
+    let gps_opt_len: u16 = 24;
+
+    let mut out = Vec::new();
+
+    // opt_comment header + value + padding (big-endian section)
+    out.extend_from_slice(&1u16.to_be_bytes());                        // option_code = 1
+    out.extend_from_slice(&(comment_bytes.len() as u16).to_be_bytes()); // option_len
+    out.extend_from_slice(comment_bytes);
+    out.extend_from_slice(&[0u8; 3][..comment_pad]);                   // padding to 4-byte boundary
+
+    // Kismet GPS option header + PEN + custom payload (big-endian section, LE payload)
+    out.extend_from_slice(&2989u16.to_be_bytes()); // option_code
+    out.extend_from_slice(&gps_opt_len.to_be_bytes());
+    out.extend_from_slice(&55922u32.to_be_bytes()); // PEN
+    out.extend_from_slice(&payload);
+
+    // end-of-options marker (big-endian)
+    out.extend_from_slice(&0u16.to_be_bytes());
+    out.extend_from_slice(&0u16.to_be_bytes());
+    out
+}
+
 pub struct GsmtapPcapWriter<T>
 where
     T: AsyncWrite,
@@ -102,6 +186,7 @@ where
         &mut self,
         msg: GsmtapMessage,
         timestamp: Timestamp,
+        gps: Option<&KismetGpsPoint>,
     ) -> Result<(), GsmtapPcapError> {
         let duration = timestamp
             .to_datetime()
@@ -137,14 +222,58 @@ where
         data.extend(&ip_header.to_bytes()?);
         data.extend(&udp_header.to_bytes()?);
         data.extend(&msg_bytes);
-        let packet = EnhancedPacketBlock {
-            interface_id: 0,
-            timestamp: duration,
-            original_len: data.len() as u32,
-            data: Cow::Owned(data),
-            options: vec![],
-        };
-        self.writer.write_pcapng_block(packet).await?;
+
+        match gps {
+            None => {
+                // Fast path: delegate to the library's standard EPB writer.
+                let packet = EnhancedPacketBlock {
+                    interface_id: 0,
+                    timestamp: duration,
+                    original_len: data.len() as u32,
+                    data: Cow::Owned(data),
+                    options: vec![],
+                };
+                self.writer.write_pcapng_block(packet).await?;
+            }
+            Some(gps_point) => {
+                // GPS path: build a raw EPB body so we can append the Kismet
+                // custom option directly.  The pcap-file-tokio crate does not
+                // expose the inner option types publicly, so we must write the
+                // option bytes manually and wrap them in a RawBlock.
+                //
+                // All standard pcapng multi-byte fields are big-endian (section
+                // header declares Endianness::Big); the GPS custom payload uses
+                // little-endian per the Kismet convention.
+                let pad_len = (4 - (data.len() % 4)) % 4;
+                let ts_nanos = duration.as_nanos();
+                let ts_high = (ts_nanos >> 32) as u32;
+                let ts_low = (ts_nanos & 0xFFFFFFFF) as u32;
+
+                let gps_bytes = build_gps_option_bytes(gps_point);
+
+                // Body = EPB fixed header (20 B) + data + padding + gps options
+                let body_len = 20 + data.len() + pad_len + gps_bytes.len();
+                let mut body = Vec::<u8>::with_capacity(body_len);
+                body.extend_from_slice(&0u32.to_be_bytes());                    // interface_id
+                body.extend_from_slice(&ts_high.to_be_bytes());                 // timestamp high
+                body.extend_from_slice(&ts_low.to_be_bytes());                  // timestamp low
+                body.extend_from_slice(&(data.len() as u32).to_be_bytes());     // captured_len
+                body.extend_from_slice(&(data.len() as u32).to_be_bytes());     // original_len
+                body.extend_from_slice(&data);
+                body.extend_from_slice(&[0u8; 3][..pad_len]);                   // padding
+                body.extend_from_slice(&gps_bytes);
+
+                let block_total_len = (12 + body.len()) as u32;
+                let raw = RawBlock {
+                    type_: ENHANCED_PACKET_BLOCK,
+                    initial_len: block_total_len,
+                    body: Cow::Owned(body),
+                    trailer_len: block_total_len,
+                };
+                self.writer.write_raw_block(&raw).await?;
+            }
+        }
+
         self.ip_id = self.ip_id.wrapping_add(1);
         Ok(())
     }

From da0b1afbc8a4f0b386728fe4822bcd327d890699 Mon Sep 17 00:00:00 2001
From: Carlos Guerra <cguerrave@gmail.com>
Date: Sun, 29 Mar 2026 16:22:07 +0200
Subject: [PATCH 03/13] Kismet GPS option section per packet dcriped,
 refactoring to reduce loc

---
 daemon/src/gps.rs                             |   2 -
 daemon/src/pcap.rs                            |  57 +++----
 .../web/src/lib/components/ConfigForm.svelte  |  58 ++-----
 daemon/web/src/routes/+page.svelte            |  68 ++++----
 lib/src/pcap.rs                               | 152 +++---------------
 5 files changed, 78 insertions(+), 259 deletions(-)

diff --git a/daemon/src/gps.rs b/daemon/src/gps.rs
index d25c7a92..2d090111 100644
--- a/daemon/src/gps.rs
+++ b/daemon/src/gps.rs
@@ -14,10 +14,8 @@ pub struct GpsData {
     pub timestamp: String,
 }
 
-/// A single GPS fix recorded in the sidecar file alongside a QMDL recording.
 #[derive(Serialize, Deserialize)]
 pub struct GpsRecord {
-    /// Unix timestamp (seconds) of when this fix was received by the server.
     pub unix_ts: u32,
     pub lat: f64,
     pub lon: f64,
diff --git a/daemon/src/pcap.rs b/daemon/src/pcap.rs
index e0b68095..46417ffb 100644
--- a/daemon/src/pcap.rs
+++ b/daemon/src/pcap.rs
@@ -10,15 +10,12 @@ use axum::response::{IntoResponse, Response};
 use log::error;
 use rayhunter::diag::DataType;
 use rayhunter::gsmtap_parser;
-use rayhunter::pcap::{GsmtapPcapWriter, KismetGpsPoint};
+use rayhunter::pcap::{GpsPoint, GsmtapPcapWriter};
 use rayhunter::qmdl::QmdlReader;
 use std::sync::Arc;
 use tokio::io::{AsyncRead, AsyncWrite, duplex};
 use tokio_util::io::ReaderStream;
 
-// Streams a pcap file chunk-by-chunk to the client by reading the QMDL data
-// written so far. This is done by spawning a thread which streams chunks of
-// pcap data to a channel that's piped to the client.
 #[cfg_attr(feature = "apidocs", utoipa::path(
     get,
     path = "/api/pcap/{name}",
@@ -72,42 +69,33 @@ pub async fn get_pcap(
     Ok((headers, body).into_response())
 }
 
-/// Loads GPS records for a recording entry.
-///
-/// - `gps_mode == 0`: returns empty vec (no GPS)
-/// - `gps_mode == 1`: returns a single synthetic record with `unix_ts = 0` (fixed coordinates)
-/// - `gps_mode == 2`: loads per-fix records from the GPS sidecar file
 pub(crate) async fn load_gps_records_for_entry(
     state: &Arc<ServerState>,
     entry_index: usize,
 ) -> Vec<GpsRecord> {
-    if state.config.gps_mode == 0 {
-        return vec![];
+    // Always try the per-session sidecar first — it reflects what was actually
+    // recorded regardless of what the current gps_mode config is.
+    {
+        let qmdl_store = state.qmdl_store_lock.read().await;
+        if let Ok(file) = qmdl_store.open_entry_gps(entry_index).await {
+            let records = load_gps_records(file).await;
+            if !records.is_empty() {
+                return records;
+            }
+        }
     }
+    // Sidecar missing or empty — fall back to current config.
     if state.config.gps_mode == 1 {
         let guard = state.gps_state.read().await;
         return guard
             .as_ref()
-            .map(|g| {
-                vec![GpsRecord {
-                    unix_ts: 0, // 0 signals fixed/synthetic to the Kismet option builder
-                    lat: g.latitude,
-                    lon: g.longitude,
-                }]
-            })
+            .map(|g| vec![GpsRecord { unix_ts: 0, lat: g.latitude, lon: g.longitude }])
             .unwrap_or_default();
     }
-    // gps_mode == 2: load from sidecar
-    let qmdl_store = state.qmdl_store_lock.read().await;
-    match qmdl_store.open_entry_gps(entry_index).await {
-        Ok(file) => load_gps_records(file).await,
-        Err(_) => vec![],
-    }
+    vec![]
 }
 
-/// Returns the GPS fix from `records` whose `unix_ts` is closest to `packet_unix_ts`.
-/// Returns `None` if `records` is empty.
-fn find_nearest_gps(records: &[GpsRecord], packet_unix_ts: u32) -> Option<KismetGpsPoint> {
+fn find_nearest_gps(records: &[GpsRecord], packet_unix_ts: u32) -> Option<GpsPoint> {
     if records.is_empty() {
         return None;
     }
@@ -117,19 +105,10 @@ fn find_nearest_gps(records: &[GpsRecord], packet_unix_ts: u32) -> Option<Kismet
     } else if idx >= records.len() {
         &records[records.len() - 1]
     } else {
-        let before = &records[idx - 1];
-        let after = &records[idx];
-        if packet_unix_ts - before.unix_ts <= after.unix_ts - packet_unix_ts {
-            before
-        } else {
-            after
-        }
+        let (before, after) = (&records[idx - 1], &records[idx]);
+        if packet_unix_ts - before.unix_ts <= after.unix_ts - packet_unix_ts { before } else { after }
     };
-    Some(KismetGpsPoint {
-        latitude: record.lat,
-        longitude: record.lon,
-        timestamp_unix_secs: record.unix_ts,
-    })
+    Some(GpsPoint { latitude: record.lat, longitude: record.lon, unix_ts: record.unix_ts })
 }
 
 pub async fn generate_pcap_data<R, W>(
diff --git a/daemon/web/src/lib/components/ConfigForm.svelte b/daemon/web/src/lib/components/ConfigForm.svelte
index 6e44080d..c8a802ef 100644
--- a/daemon/web/src/lib/components/ConfigForm.svelte
+++ b/daemon/web/src/lib/components/ConfigForm.svelte
@@ -670,24 +670,16 @@
 
                 <div class="border-t pt-4 mt-6 space-y-3">
                     <h3 class="text-lg font-semibold text-gray-800 mb-4">GPS Settings</h3>
-
                     <div>
-                        <label for="gps_mode" class="block text-sm font-medium text-gray-700 mb-1">
-                            GPS Mode
-                        </label>
-                        <select
-                            id="gps_mode"
-                            bind:value={config.gps_mode}
-                            class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue"
-                        >
+                        <label for="gps_mode" class="block text-sm font-medium text-gray-700 mb-1">GPS Mode</label>
+                        <select id="gps_mode" bind:value={config.gps_mode} class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue">
                             <option value={0}>0 - Disabled</option>
                             <option value={1}>1 - Fixed coordinates</option>
                             <option value={2}>2 - API Endpoint</option>
                         </select>
                         <p class="text-xs text-gray-500 mt-1">
                             {#if config.gps_mode === 2}
-                                POST latitude, longitude, and timestamp to <code>/api/gps</code> from
-                                any device on the network.
+                                POST latitude, longitude, and timestamp to <code>/api/gps</code> from any device on the network.
                             {:else if config.gps_mode === 1}
                                 GPS coordinates are fixed to the values below.
                             {:else}
@@ -695,47 +687,19 @@
                             {/if}
                         </p>
                     </div>
-
                     {#if config.gps_mode === 1}
                         <div>
-                            <label
-                                for="gps_fixed_latitude"
-                                class="block text-sm font-medium text-gray-700 mb-1"
-                            >
-                                Fixed Latitude
-                            </label>
-                            <input
-                                id="gps_fixed_latitude"
-                                type="number"
-                                min="-90"
-                                max="90"
-                                step="any"
-                                required
-                                bind:value={config.gps_fixed_latitude}
-                                placeholder="e.g. 37.7749"
-                                class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue"
-                            />
+                            <label for="gps_fixed_latitude" class="block text-sm font-medium text-gray-700 mb-1">Fixed Latitude</label>
+                            <input id="gps_fixed_latitude" type="number" min="-90" max="90" step="any" required
+                                bind:value={config.gps_fixed_latitude} placeholder="e.g. 37.7749"
+                                class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue" />
                             <p class="text-xs text-gray-500 mt-1">Decimal degrees, -90 to 90</p>
                         </div>
-
                         <div>
-                            <label
-                                for="gps_fixed_longitude"
-                                class="block text-sm font-medium text-gray-700 mb-1"
-                            >
-                                Fixed Longitude
-                            </label>
-                            <input
-                                id="gps_fixed_longitude"
-                                type="number"
-                                min="-180"
-                                max="180"
-                                step="any"
-                                required
-                                bind:value={config.gps_fixed_longitude}
-                                placeholder="e.g. -122.4194"
-                                class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue"
-                            />
+                            <label for="gps_fixed_longitude" class="block text-sm font-medium text-gray-700 mb-1">Fixed Longitude</label>
+                            <input id="gps_fixed_longitude" type="number" min="-180" max="180" step="any" required
+                                bind:value={config.gps_fixed_longitude} placeholder="e.g. -122.4194"
+                                class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue" />
                             <p class="text-xs text-gray-500 mt-1">Decimal degrees, -180 to 180</p>
                         </div>
                     {/if}
diff --git a/daemon/web/src/routes/+page.svelte b/daemon/web/src/routes/+page.svelte
index ede0eba7..0324db43 100644
--- a/daemon/web/src/routes/+page.svelte
+++ b/daemon/web/src/routes/+page.svelte
@@ -291,46 +291,34 @@
             <SystemStatsTable stats={system_stats!} />
         </div>
         {#if gps_mode !== 0}
-        <div class="bg-white border border-gray-200 drop-shadow rounded-md p-4 flex flex-col gap-2">
-            <span class="text-lg font-semibold flex flex-row items-center gap-2">
-                <svg
-                    class="w-5 h-5 text-rayhunter-blue"
-                    aria-hidden="true"
-                    xmlns="http://www.w3.org/2000/svg"
-                    width="24"
-                    height="24"
-                    fill="currentColor"
-                    viewBox="0 0 24 24"
-                >
-                    <path
-                        fill-rule="evenodd"
-                        d="M11.906 1.994a8.002 8.002 0 0 1 8.09 8.421 7.996 7.996 0 0 1-1.297 3.957.996.996 0 0 1-.133.204l-.108.129c-.178.243-.37.477-.573.699l-5.112 6.224a1 1 0 0 1-1.545 0L5.982 15.26l-.002-.002a18.146 18.146 0 0 1-.309-.38l-.133-.163a.999.999 0 0 1-.13-.202 7.995 7.995 0 0 1 6.498-12.518ZM15 9.997a3 3 0 1 1-5.999 0 3 3 0 0 1 5.999 0Z"
-                        clip-rule="evenodd"
-                    />
-                </svg>
-                GPS Status
-            </span>
-            {#if gps_data}
-                <table class="w-full text-sm">
-                    <tbody>
-                        <tr class="border-b border-gray-100">
-                            <td class="py-1 pr-4 text-gray-500 font-medium">Latitude</td>
-                            <td class="py-1 font-mono">{gps_data.latitude.toFixed(6)}</td>
-                        </tr>
-                        <tr class="border-b border-gray-100">
-                            <td class="py-1 pr-4 text-gray-500 font-medium">Longitude</td>
-                            <td class="py-1 font-mono">{gps_data.longitude.toFixed(6)}</td>
-                        </tr>
-                        <tr>
-                            <td class="py-1 pr-4 text-gray-500 font-medium">GPS Timestamp</td>
-                            <td class="py-1 font-mono">{gps_data.timestamp}</td>
-                        </tr>
-                    </tbody>
-                </table>
-            {:else}
-                <span class="text-gray-400 text-sm">Awaiting GPS data...</span>
-            {/if}
-        </div>
+            <div class="bg-white border border-gray-200 drop-shadow rounded-md p-4 flex flex-col gap-2">
+                <span class="text-lg font-semibold flex flex-row items-center gap-2">
+                    <svg class="w-5 h-5 text-rayhunter-blue" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
+                        <path fill-rule="evenodd" d="M11.906 1.994a8.002 8.002 0 0 1 8.09 8.421 7.996 7.996 0 0 1-1.297 3.957.996.996 0 0 1-.133.204l-.108.129c-.178.243-.37.477-.573.699l-5.112 6.224a1 1 0 0 1-1.545 0L5.982 15.26l-.002-.002a18.146 18.146 0 0 1-.309-.38l-.133-.163a.999.999 0 0 1-.13-.202 7.995 7.995 0 0 1 6.498-12.518ZM15 9.997a3 3 0 1 1-5.999 0 3 3 0 0 1 5.999 0Z" clip-rule="evenodd" />
+                    </svg>
+                    GPS Status
+                </span>
+                {#if gps_data}
+                    <table class="w-full text-sm">
+                        <tbody>
+                            <tr class="border-b border-gray-100">
+                                <td class="py-1 pr-4 text-gray-500 font-medium">Latitude</td>
+                                <td class="py-1 font-mono">{gps_data.latitude.toFixed(6)}</td>
+                            </tr>
+                            <tr class="border-b border-gray-100">
+                                <td class="py-1 pr-4 text-gray-500 font-medium">Longitude</td>
+                                <td class="py-1 font-mono">{gps_data.longitude.toFixed(6)}</td>
+                            </tr>
+                            <tr>
+                                <td class="py-1 pr-4 text-gray-500 font-medium">GPS Timestamp</td>
+                                <td class="py-1 font-mono">{gps_data.timestamp}</td>
+                            </tr>
+                        </tbody>
+                    </table>
+                {:else}
+                    <span class="text-gray-400 text-sm">Awaiting GPS data...</span>
+                {/if}
+            </div>
         {/if}
         <div class="flex flex-col gap-2">
             <div class="flex flex-row gap-2">
diff --git a/lib/src/pcap.rs b/lib/src/pcap.rs
index da624343..497ede07 100644
--- a/lib/src/pcap.rs
+++ b/lib/src/pcap.rs
@@ -6,8 +6,7 @@ use crate::gsmtap::GsmtapMessage;
 use chrono::prelude::*;
 use deku::prelude::*;
 use pcap_file_tokio::pcapng::PcapNgWriter;
-use pcap_file_tokio::pcapng::RawBlock;
-use pcap_file_tokio::pcapng::blocks::enhanced_packet::EnhancedPacketBlock;
+use pcap_file_tokio::pcapng::blocks::enhanced_packet::{EnhancedPacketBlock, EnhancedPacketOption};
 use pcap_file_tokio::pcapng::blocks::interface_description::InterfaceDescriptionBlock;
 use pcap_file_tokio::pcapng::blocks::section_header::{SectionHeaderBlock, SectionHeaderOption};
 use pcap_file_tokio::{Endianness, PcapError};
@@ -27,87 +26,11 @@ pub enum GsmtapPcapError {
     Deku(#[from] DekuError),
 }
 
-/// A GPS fix to embed in each PCAP packet as a Kismet-compatible custom option.
-///
-/// Set `timestamp_unix_secs = 0` to signal a fixed/synthetic coordinate (no real GPS time).
-pub struct KismetGpsPoint {
+pub struct GpsPoint {
     pub latitude: f64,
     pub longitude: f64,
-    pub timestamp_unix_secs: u32,
-}
-
-// Block type constant for Enhanced Packet Block (pcapng spec §4.3)
-const ENHANCED_PACKET_BLOCK: u32 = 0x00000006;
-
-/// Serialises a Kismet GPS custom option into a byte buffer suitable for
-/// appending directly to an EPB body.
-///
-/// Wire layout (section is big-endian; GPS custom payload is little-endian per
-/// Kismet convention):
-///
-///   option_code  u16 BE = 2989  (custom binary, non-copyable)
-///   option_len   u16 BE = 24    (PEN 4 + payload 20)
-///   pen          u32 BE = 55922 (Kismet IANA PEN)
-///   --- custom payload (20 bytes, all fields little-endian) ---
-///   magic        u8  = 0x47
-///   version      u8  = 0x01
-///   fields_len   u16 LE = 16   (bitmask + lon + lat + ts)
-///   bitmask      u32 LE = 0x26 (lon=0x2, lat=0x4, gps_time=0x20)
-///   longitude    i32 LE fixed37 (degrees × 1e7)
-///   latitude     i32 LE fixed37 (degrees × 1e7)
-///   gps_time     u32 LE unix seconds (0 = fixed/unknown)
-///   --- end-of-options marker ---
-///   end_code     u16 BE = 0
-///   end_len      u16 BE = 0
-fn build_gps_option_bytes(gps: &KismetGpsPoint) -> Vec<u8> {
-    // --- opt_comment (code 1): human-readable GPS for Wireshark ---
-    // Format chosen to match what Kismet writes so tools see a consistent label.
-    let comment = if gps.timestamp_unix_secs == 0 {
-        format!("GPS fixed lat={:.7} lon={:.7}", gps.latitude, gps.longitude)
-    } else {
-        format!("GPS lat={:.7} lon={:.7} ts={}", gps.latitude, gps.longitude, gps.timestamp_unix_secs)
-    };
-    let comment_bytes = comment.as_bytes();
-    let comment_pad = (4 - (comment_bytes.len() % 4)) % 4;
-
-    // --- Kismet GPS custom option (code 2989) ---
-    let lon_fixed: i32 = (gps.longitude * 1e7) as i32;
-    let lat_fixed: i32 = (gps.latitude * 1e7) as i32;
-
-    // Custom payload: 20 bytes, all little-endian (Kismet convention)
-    let fields_len: u16 = 16; // bitmask(4) + lon(4) + lat(4) + ts(4)
-    let bitmask: u32 = 0x2 | 0x4 | 0x20; // lon | lat | gps_time
-    let mut payload = Vec::<u8>::with_capacity(20);
-    payload.push(0x47); // magic
-    payload.push(0x01); // version
-    payload.extend_from_slice(&fields_len.to_le_bytes());
-    payload.extend_from_slice(&bitmask.to_le_bytes());
-    payload.extend_from_slice(&lon_fixed.to_le_bytes());
-    payload.extend_from_slice(&lat_fixed.to_le_bytes());
-    payload.extend_from_slice(&gps.timestamp_unix_secs.to_le_bytes());
-    // payload is exactly 20 bytes, already 4-byte aligned
-
-    // option_len = PEN (4) + payload (20) = 24, also 4-byte aligned
-    let gps_opt_len: u16 = 24;
-
-    let mut out = Vec::new();
-
-    // opt_comment header + value + padding (big-endian section)
-    out.extend_from_slice(&1u16.to_be_bytes());                        // option_code = 1
-    out.extend_from_slice(&(comment_bytes.len() as u16).to_be_bytes()); // option_len
-    out.extend_from_slice(comment_bytes);
-    out.extend_from_slice(&[0u8; 3][..comment_pad]);                   // padding to 4-byte boundary
-
-    // Kismet GPS option header + PEN + custom payload (big-endian section, LE payload)
-    out.extend_from_slice(&2989u16.to_be_bytes()); // option_code
-    out.extend_from_slice(&gps_opt_len.to_be_bytes());
-    out.extend_from_slice(&55922u32.to_be_bytes()); // PEN
-    out.extend_from_slice(&payload);
-
-    // end-of-options marker (big-endian)
-    out.extend_from_slice(&0u16.to_be_bytes());
-    out.extend_from_slice(&0u16.to_be_bytes());
-    out
+    /// Unix timestamp of the GPS fix. 0 means fixed/synthetic (no real GPS time).
+    pub unix_ts: u32,
 }
 
 pub struct GsmtapPcapWriter<T>
@@ -186,7 +109,7 @@ where
         &mut self,
         msg: GsmtapMessage,
         timestamp: Timestamp,
-        gps: Option<&KismetGpsPoint>,
+        gps: Option<&GpsPoint>,
     ) -> Result<(), GsmtapPcapError> {
         let duration = timestamp
             .to_datetime()
@@ -223,56 +146,23 @@ where
         data.extend(&udp_header.to_bytes()?);
         data.extend(&msg_bytes);
 
-        match gps {
-            None => {
-                // Fast path: delegate to the library's standard EPB writer.
-                let packet = EnhancedPacketBlock {
-                    interface_id: 0,
-                    timestamp: duration,
-                    original_len: data.len() as u32,
-                    data: Cow::Owned(data),
-                    options: vec![],
-                };
-                self.writer.write_pcapng_block(packet).await?;
-            }
-            Some(gps_point) => {
-                // GPS path: build a raw EPB body so we can append the Kismet
-                // custom option directly.  The pcap-file-tokio crate does not
-                // expose the inner option types publicly, so we must write the
-                // option bytes manually and wrap them in a RawBlock.
-                //
-                // All standard pcapng multi-byte fields are big-endian (section
-                // header declares Endianness::Big); the GPS custom payload uses
-                // little-endian per the Kismet convention.
-                let pad_len = (4 - (data.len() % 4)) % 4;
-                let ts_nanos = duration.as_nanos();
-                let ts_high = (ts_nanos >> 32) as u32;
-                let ts_low = (ts_nanos & 0xFFFFFFFF) as u32;
-
-                let gps_bytes = build_gps_option_bytes(gps_point);
-
-                // Body = EPB fixed header (20 B) + data + padding + gps options
-                let body_len = 20 + data.len() + pad_len + gps_bytes.len();
-                let mut body = Vec::<u8>::with_capacity(body_len);
-                body.extend_from_slice(&0u32.to_be_bytes());                    // interface_id
-                body.extend_from_slice(&ts_high.to_be_bytes());                 // timestamp high
-                body.extend_from_slice(&ts_low.to_be_bytes());                  // timestamp low
-                body.extend_from_slice(&(data.len() as u32).to_be_bytes());     // captured_len
-                body.extend_from_slice(&(data.len() as u32).to_be_bytes());     // original_len
-                body.extend_from_slice(&data);
-                body.extend_from_slice(&[0u8; 3][..pad_len]);                   // padding
-                body.extend_from_slice(&gps_bytes);
-
-                let block_total_len = (12 + body.len()) as u32;
-                let raw = RawBlock {
-                    type_: ENHANCED_PACKET_BLOCK,
-                    initial_len: block_total_len,
-                    body: Cow::Owned(body),
-                    trailer_len: block_total_len,
-                };
-                self.writer.write_raw_block(&raw).await?;
-            }
+        let mut options = vec![];
+        if let Some(p) = gps {
+            let comment = if p.unix_ts == 0 {
+                format!("GPS fixed lat={:.7} lon={:.7}", p.latitude, p.longitude)
+            } else {
+                format!("GPS lat={:.7} lon={:.7} ts={}", p.latitude, p.longitude, p.unix_ts)
+            };
+            options.push(EnhancedPacketOption::Comment(Cow::Owned(comment)));
         }
+        let packet = EnhancedPacketBlock {
+            interface_id: 0,
+            timestamp: duration,
+            original_len: data.len() as u32,
+            data: Cow::Owned(data),
+            options,
+        };
+        self.writer.write_pcapng_block(packet).await?;
 
         self.ip_id = self.ip_id.wrapping_add(1);
         Ok(())

From 5acdb6d539e42542d0c61bc4136d065b544a3906 Mon Sep 17 00:00:00 2001
From: Carlos Guerra <cguerrave@gmail.com>
Date: Sun, 29 Mar 2026 17:44:39 +0200
Subject: [PATCH 04/13] added documentation and polishing UI around GPS mode

---
 daemon/src/config.rs                          | 43 -------------------
 daemon/src/diag.rs                            |  9 +++-
 daemon/src/gps.rs                             | 24 ++++++++++-
 daemon/src/main.rs                            |  3 +-
 daemon/src/qmdl_store.rs                      | 20 +++++----
 daemon/src/server.rs                          |  2 +-
 .../src/lib/components/AnalysisView.svelte    |  6 +++
 .../src/lib/components/ManifestCard.svelte    |  5 +++
 daemon/web/src/lib/manifest.svelte.ts         |  5 +++
 daemon/web/src/lib/utils.svelte.ts            |  3 +-
 daemon/web/src/routes/+page.svelte            |  7 ++-
 11 files changed, 68 insertions(+), 59 deletions(-)

diff --git a/daemon/src/config.rs b/daemon/src/config.rs
index 43c93a7e..bde94d66 100644
--- a/daemon/src/config.rs
+++ b/daemon/src/config.rs
@@ -168,49 +168,6 @@ fn resolve_bin(name: &str) -> Option<String> {
     None
 }
 
-impl Config {
-    pub fn wifi_config(&self) -> wifi_station::WifiConfig {
-        let (wpa_bin, hostapd_conf, ctrl_interface) = match self.device {
-            Device::Tmobile | Device::Wingtech => (
-                Some("/usr/sbin/wpa_supplicant".into()),
-                Some("/data/configs/hostapd.conf".into()),
-                None,
-            ),
-            Device::Uz801 => (
-                Some("/system/bin/wpa_supplicant".into()),
-                Some("/data/misc/wifi/hostapd.conf".into()),
-                Some("/data/misc/wifi/sockets".into()),
-            ),
-            _ => (None, None, None),
-        };
-        wifi_station::WifiConfig {
-            wifi_enabled: self.wifi_enabled,
-            dns_servers: self.dns_servers.clone(),
-            wifi_ssid: self.wifi_ssid.clone(),
-            wifi_password: self.wifi_password.clone(),
-            security_type: self.wifi_security,
-            wpa_supplicant_bin: wpa_bin.or_else(|| resolve_bin("wpa_supplicant")),
-            hostapd_conf,
-            ctrl_interface,
-            udhcpc_hook_path: Some("/data/rayhunter/udhcpc-hook.sh".into()),
-            dhcp_lease_path: Some("/data/rayhunter/dhcp_lease".into()),
-            wpa_conf_path: Some("/data/rayhunter/wpa_sta.conf".into()),
-            iw_bin: resolve_bin("iw"),
-            udhcpc_bin: resolve_bin("udhcpc"),
-            crash_log_dir: Some("/data/rayhunter/crash-logs".into()),
-            wakelock_name: Some("rayhunter".into()),
-        }
-    }
-}
-
-fn resolve_bin(name: &str) -> Option<String> {
-    let local = format!("/data/rayhunter/bin/{name}");
-    if std::path::Path::new(&local).exists() {
-        return Some(local);
-    }
-    None
-}
-
 pub async fn parse_config<P>(path: P) -> Result<Config, RayhunterError>
 where
     P: AsRef<std::path::Path>,
diff --git a/daemon/src/diag.rs b/daemon/src/diag.rs
index 3db74927..9a309c5e 100644
--- a/daemon/src/diag.rs
+++ b/daemon/src/diag.rs
@@ -56,6 +56,7 @@ pub struct DiagTask {
     notification_channel: tokio::sync::mpsc::Sender<Notification>,
     min_space_to_start_mb: u64,
     min_space_to_continue_mb: u64,
+    gps_mode: u8,
     state: DiagState,
     max_type_seen: EventType,
     bytes_since_space_check: usize,
@@ -104,6 +105,7 @@ impl DiagTask {
         notification_channel: tokio::sync::mpsc::Sender<Notification>,
         min_space_to_start_mb: u64,
         min_space_to_continue_mb: u64,
+        gps_mode: u8,
     ) -> Self {
         Self {
             ui_update_sender,
@@ -112,6 +114,7 @@ impl DiagTask {
             notification_channel,
             min_space_to_start_mb,
             min_space_to_continue_mb,
+            gps_mode,
             state: DiagState::Stopped,
             max_type_seen: EventType::Informational,
             bytes_since_space_check: 0,
@@ -144,7 +147,7 @@ impl DiagTask {
             DiskSpaceCheck::Failed => {}
         }
 
-        let (qmdl_file, analysis_file) = match qmdl_store.new_entry().await {
+        let (qmdl_file, analysis_file) = match qmdl_store.new_entry(self.gps_mode).await {
             Ok(files) => files,
             Err(e) => {
                 let msg = format!("failed creating QMDL file entry: {e}");
@@ -381,6 +384,7 @@ pub fn run_diag_read_thread(
     notification_channel: tokio::sync::mpsc::Sender<Notification>,
     min_space_to_start_mb: u64,
     min_space_to_continue_mb: u64,
+    gps_mode: u8,
 ) {
     task_tracker.spawn(async move {
         info!("Using configuration for device: {0:?}", device);
@@ -396,7 +400,8 @@ pub fn run_diag_read_thread(
             analyzer_config,
             notification_channel,
             min_space_to_start_mb,
-            min_space_to_continue_mb
+            min_space_to_continue_mb,
+            gps_mode,
         );
         qmdl_file_tx
             .send(DiagDeviceCtrlMessage::StartRecording { response_tx: None })
diff --git a/daemon/src/gps.rs b/daemon/src/gps.rs
index 2d090111..fd499df5 100644
--- a/daemon/src/gps.rs
+++ b/daemon/src/gps.rs
@@ -1,17 +1,37 @@
 use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 use std::sync::Arc;
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 
 use crate::server::ServerState;
 
+/// Accepts both a JSON number and a numeric string (e.g. `"1234567890"` or `1234567890`).
+/// Truncates floats to seconds. Returns an error for non-numeric values.
+fn deserialize_unix_ts<'de, D>(deserializer: D) -> Result<i64, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    use serde::de;
+    use serde_json::Value;
+    match Value::deserialize(deserializer)? {
+        Value::Number(n) => n.as_i64()
+            .or_else(|| n.as_f64().map(|f| f as i64))
+            .ok_or_else(|| de::Error::custom("timestamp out of range")),
+        Value::String(s) => s.trim().parse::<f64>()
+            .map(|f| f as i64)
+            .map_err(|_| de::Error::custom("timestamp must be a numeric value")),
+        _ => Err(de::Error::custom("timestamp must be a number or numeric string")),
+    }
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct GpsData {
     pub latitude: f64,
     pub longitude: f64,
-    pub timestamp: String,
+    #[serde(deserialize_with = "deserialize_unix_ts")]
+    pub timestamp: i64,
 }
 
 #[derive(Serialize, Deserialize)]
diff --git a/daemon/src/main.rs b/daemon/src/main.rs
index 9da023d5..954030bd 100644
--- a/daemon/src/main.rs
+++ b/daemon/src/main.rs
@@ -233,6 +233,7 @@ async fn run_with_config(
             notification_service.new_handler(),
             config.min_space_to_start_recording_mb,
             config.min_space_to_continue_recording_mb,
+            config.gps_mode,
         );
         info!("Starting UI");
 
@@ -307,7 +308,7 @@ async fn run_with_config(
             (Some(lat), Some(lon)) => Some(gps::GpsData {
                 latitude: lat,
                 longitude: lon,
-                timestamp: "fixed".to_string(),
+                timestamp: 0,
             }),
             _ => None,
         }
diff --git a/daemon/src/qmdl_store.rs b/daemon/src/qmdl_store.rs
index 1eefb662..a66cb8ff 100644
--- a/daemon/src/qmdl_store.rs
+++ b/daemon/src/qmdl_store.rs
@@ -70,10 +70,12 @@ pub struct ManifestEntry {
     /// When the manifest was uploaded to a WebDAV server
     #[cfg_attr(feature = "apidocs", schema(value_type = String))]
     pub upload_time: Option<DateTime<Local>>,
+    #[serde(default)]
+    pub gps_mode: Option<u8>,
 }
 
 impl ManifestEntry {
-    fn new() -> Self {
+    fn new(gps_mode: u8) -> Self {
         let now = rayhunter::clock::get_adjusted_now();
         let metadata = RuntimeMetadata::new();
         ManifestEntry {
@@ -86,6 +88,7 @@ impl ManifestEntry {
             arch: Some(metadata.arch),
             stop_reason: None,
             upload_time: None,
+            gps_mode: Some(gps_mode),
         }
     }
 
@@ -223,6 +226,7 @@ impl RecordingStore {
                 arch: None,
                 stop_reason: None,
                 upload_time: None,
+                gps_mode: None,
             });
         }
 
@@ -255,12 +259,12 @@ impl RecordingStore {
     // Closes the current entry (if needed), creates a new entry based on the
     // current time, and updates the manifest. Returns a tuple of the entry's
     // newly created QMDL file and analysis file.
-    pub async fn new_entry(&mut self) -> Result<(File, File), RecordingStoreError> {
+    pub async fn new_entry(&mut self, gps_mode: u8) -> Result<(File, File), RecordingStoreError> {
         // if we've already got an entry open, close it
         if self.current_entry.is_some() {
             self.close_current_entry().await?;
         }
-        let new_entry = ManifestEntry::new();
+        let new_entry = ManifestEntry::new(gps_mode);
         let qmdl_filepath = new_entry.get_qmdl_filepath(&self.path);
         let qmdl_file = File::create(&qmdl_filepath)
             .await
@@ -545,7 +549,7 @@ mod tests {
     async fn test_creating_updating_and_closing_entries() {
         let dir = make_temp_dir();
         let mut store = RecordingStore::create(dir.path()).await.unwrap();
-        let _ = store.new_entry().await.unwrap();
+        let _ = store.new_entry(0).await.unwrap();
         let entry_index = store.current_entry.unwrap();
         assert_eq!(
             RecordingStore::read_manifest(dir.path()).await.unwrap(),
@@ -582,7 +586,7 @@ mod tests {
     async fn test_create_on_existing_store() {
         let dir = make_temp_dir();
         let mut store = RecordingStore::create(dir.path()).await.unwrap();
-        let _ = store.new_entry().await.unwrap();
+        let _ = store.new_entry(0).await.unwrap();
         let entry_index = store.current_entry.unwrap();
         store
             .update_entry_qmdl_size(entry_index, 1000)
@@ -596,9 +600,9 @@ mod tests {
     async fn test_repeated_new_entries() {
         let dir = make_temp_dir();
         let mut store = RecordingStore::create(dir.path()).await.unwrap();
-        let _ = store.new_entry().await.unwrap();
+        let _ = store.new_entry(0).await.unwrap();
         let entry_index = store.current_entry.unwrap();
-        let _ = store.new_entry().await.unwrap();
+        let _ = store.new_entry(0).await.unwrap();
         let new_entry_index = store.current_entry.unwrap();
         assert_ne!(entry_index, new_entry_index);
         assert_eq!(store.manifest.entries.len(), 2);
@@ -608,7 +612,7 @@ mod tests {
     async fn test_delete_all_entries() {
         let dir = make_temp_dir();
         let mut store = RecordingStore::create(dir.path()).await.unwrap();
-        let _ = store.new_entry().await.unwrap();
+        let _ = store.new_entry(0).await.unwrap();
         assert!(store.current_entry.is_some());
 
         store.delete_all_entries().await.unwrap();
diff --git a/daemon/src/server.rs b/daemon/src/server.rs
index 12fc72d5..e4bc2043 100644
--- a/daemon/src/server.rs
+++ b/daemon/src/server.rs
@@ -523,7 +523,7 @@ mod tests {
     ) -> String {
         let entry_name = {
             let mut store = store_lock.write().await;
-            let (mut qmdl_file, _analysis_file) = store.new_entry().await.unwrap();
+            let (mut qmdl_file, _analysis_file) = store.new_entry(0).await.unwrap();
 
             if !test_data.is_empty() {
                 use tokio::io::AsyncWriteExt;
diff --git a/daemon/web/src/lib/components/AnalysisView.svelte b/daemon/web/src/lib/components/AnalysisView.svelte
index 3ffd8bce..eee0b6ba 100644
--- a/daemon/web/src/lib/components/AnalysisView.svelte
+++ b/daemon/web/src/lib/components/AnalysisView.svelte
@@ -55,6 +55,12 @@
                     <p>Analysis by Rayhunter version {metadata.rayhunter.rayhunter_version}</p>
                     <p><b>Device system OS:</b> {metadata.rayhunter.system_os}</p>
                 </div>
+                {#if entry.gps_mode !== undefined}
+                    <div>
+                        <p class="text-lg underline">GPS Mode</p>
+                        <p>{entry.gps_mode === 0 ? 'Disabled' : entry.gps_mode === 1 ? 'Fixed coordinates' : 'API endpoint'}</p>
+                    </div>
+                {/if}
                 <div>
                     <p class="text-lg underline">Analyzers</p>
                     {#each metadata.analyzers as analyzer}
diff --git a/daemon/web/src/lib/components/ManifestCard.svelte b/daemon/web/src/lib/components/ManifestCard.svelte
index 1b5d084c..9f1a2c93 100644
--- a/daemon/web/src/lib/components/ManifestCard.svelte
+++ b/daemon/web/src/lib/components/ManifestCard.svelte
@@ -86,6 +86,11 @@
             {entry.stop_reason}
         </div>
     {/if}
+    {#if entry.gps_mode !== undefined}
+        <div class="text-sm text-gray-500">
+            GPS: {entry.gps_mode === 0 ? 'Disabled' : entry.gps_mode === 1 ? 'Fixed coordinates' : 'API endpoint'}
+        </div>
+    {/if}
     <div class="flex flex-row justify-between lg:justify-end gap-1 mt-2 overflow-x-auto">
         <DownloadLink url={entry.get_pcap_url()} text="pcap" full_button />
         <DownloadLink url={entry.get_qmdl_url()} text="qmdl" full_button />
diff --git a/daemon/web/src/lib/manifest.svelte.ts b/daemon/web/src/lib/manifest.svelte.ts
index ec5d1cbe..6d14c20b 100644
--- a/daemon/web/src/lib/manifest.svelte.ts
+++ b/daemon/web/src/lib/manifest.svelte.ts
@@ -12,6 +12,7 @@ interface JsonManifestEntry {
     last_message_time: string;
     qmdl_size_bytes: number;
     stop_reason: string | null;
+    gps_mode: number | null;
 }
 
 export class Manifest {
@@ -59,6 +60,7 @@ export class ManifestEntry {
     public analysis_status: AnalysisStatus | undefined = $state(undefined);
     public analysis_report: AnalysisReport | string | undefined = $state(undefined);
     public stop_reason: string | undefined = $state(undefined);
+    public gps_mode: number | undefined = $state(undefined);
 
     constructor(json: JsonManifestEntry) {
         this.name = json.name;
@@ -70,6 +72,9 @@ export class ManifestEntry {
         if (json.stop_reason) {
             this.stop_reason = json.stop_reason;
         }
+        if (json.gps_mode !== null) {
+            this.gps_mode = json.gps_mode;
+        }
     }
 
     get_readable_qmdl_size(): string {
diff --git a/daemon/web/src/lib/utils.svelte.ts b/daemon/web/src/lib/utils.svelte.ts
index 2e27d677..ae4b77a0 100644
--- a/daemon/web/src/lib/utils.svelte.ts
+++ b/daemon/web/src/lib/utils.svelte.ts
@@ -149,7 +149,8 @@ export async function get_daemon_time(): Promise<TimeResponse> {
 export interface GpsData {
     latitude: number;
     longitude: number;
-    timestamp: string;
+    /** Unix timestamp in seconds (0 = fixed/no real time). */
+    timestamp: number;
 }
 
 export async function get_gps(): Promise<GpsData | null> {
diff --git a/daemon/web/src/routes/+page.svelte b/daemon/web/src/routes/+page.svelte
index 0324db43..27b1e0f7 100644
--- a/daemon/web/src/routes/+page.svelte
+++ b/daemon/web/src/routes/+page.svelte
@@ -299,6 +299,7 @@
                     GPS Status
                 </span>
                 {#if gps_data}
+                    {@const gps_date_formatter = new Intl.DateTimeFormat(undefined, { timeStyle: 'long', dateStyle: 'short' })}
                     <table class="w-full text-sm">
                         <tbody>
                             <tr class="border-b border-gray-100">
@@ -311,7 +312,11 @@
                             </tr>
                             <tr>
                                 <td class="py-1 pr-4 text-gray-500 font-medium">GPS Timestamp</td>
-                                <td class="py-1 font-mono">{gps_data.timestamp}</td>
+                                <td class="py-1 font-mono">
+                                    {gps_data.timestamp > 0
+                                        ? gps_date_formatter.format(new Date(gps_data.timestamp * 1000))
+                                        : 'Fixed'}
+                                </td>
                             </tr>
                         </tbody>
                     </table>

From 1db639b96c0f3f55490a87260d14791d2ff210b3 Mon Sep 17 00:00:00 2001
From: Carlos Guerra <cguerrave@gmail.com>
Date: Sun, 29 Mar 2026 17:53:27 +0200
Subject: [PATCH 05/13] trimming gps.rs to go under 400 loc changed

---
 daemon/src/gps.rs | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/daemon/src/gps.rs b/daemon/src/gps.rs
index fd499df5..dd9db37a 100644
--- a/daemon/src/gps.rs
+++ b/daemon/src/gps.rs
@@ -7,8 +7,6 @@ use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 
 use crate::server::ServerState;
 
-/// Accepts both a JSON number and a numeric string (e.g. `"1234567890"` or `1234567890`).
-/// Truncates floats to seconds. Returns an error for non-numeric values.
 fn deserialize_unix_ts<'de, D>(deserializer: D) -> Result<i64, D::Error>
 where
     D: Deserializer<'de>,
@@ -68,16 +66,10 @@ pub async fn post_gps(
     *gps = Some(gps_data.clone());
     drop(gps);
 
-    // Append the GPS fix to the current recording's sidecar file.
     let qmdl_store = state.qmdl_store_lock.read().await;
     if let Some((entry_idx, _)) = qmdl_store.get_current_entry() {
         if let Ok(mut file) = qmdl_store.open_entry_gps_for_append(entry_idx).await {
-            let unix_ts = chrono::Utc::now().timestamp() as u32;
-            let record = GpsRecord {
-                unix_ts,
-                lat: gps_data.latitude,
-                lon: gps_data.longitude,
-            };
+            let record = GpsRecord { unix_ts: chrono::Utc::now().timestamp() as u32, lat: gps_data.latitude, lon: gps_data.longitude };
             if let Ok(json) = serde_json::to_string(&record) {
                 let _ = file.write_all(format!("{json}\n").as_bytes()).await;
             }

From c35c341ba2812f64b4203aa7065a451d35bb04f7 Mon Sep 17 00:00:00 2001
From: Carlos Guerra <cguerrave@gmail.com>
Date: Wed, 1 Apr 2026 12:55:01 +0200
Subject: [PATCH 06/13] including documentation changes

---
 doc/configuration.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/doc/configuration.md b/doc/configuration.md
index dfd7ce9f..b200551a 100644
--- a/doc/configuration.md
+++ b/doc/configuration.md
@@ -20,6 +20,10 @@ Through web UI you can set:
   - *Warnings*, which will alert when a heuristic is triggered. Alerts will be sent at most once every five minutes.
   - *Low Battery*, which will alert when the device's battery is low. Notifications may not be supported for all devices—you can check if your device is supported by looking at whether the battery level indicator is functioning on the System Information section of the Rayhunter UI.
 - With **Analyzer Heuristic Settings** you can switch on or off built-in [Rayhunter heuristics](heuristics.md). Some heuristics are experimental or can trigger a lot of false positive warnings in some networks (our tests have shown that some heuristics have different behavior in US or European networks). In that case you can decide whether you would like to have the heuristics that trigger a lot of false positives on or off. Please note that we are constantly improving and adding new heuristics, so a new release may reduce false positives in existing heuristics as well.
+- The **GPS Settings** allows you to attach GPS coordinates to every packet in the PCAP file of each session depending on the mode you choose. The relevant attached fields are latitude, longitude, and GPS collection timestamp. This timestamp is meant to be compared during analysis with the packet timestamp so we know the time difference between the packet capture from the GPS capture (given GPS captures are taken in a separate sstream/device from the Rayhunter sensor and might also be inconstant because of coverage issues, among other reasons). The modes are:
+  - *Disabled*, the default option, won't attach any comment to the packets or enable any program logic for the management of coordinates.
+  - *Fixed*, this is more suitable for measurements taken in the same geographic position for that session, it enables two input fields for latitude and longitude. They accept decimal degrees format (from -90 to 90 for latitude, and -180 to 180 for latitude). This mode adds a "fixed" value to the GPS timestamp in the PCAP packets to help during analysis to know the coordinates were set up manually.
+  - *API Endpoint*, enables the /api/gps endpoint to send POST requests in json format with the values for latitude, longitude, and timestamp. The GPS timestamp should be provided as Unix timestamp, and can be passed as number or string without errors, but any other format won't pass the validation process.
 
 ## WiFi Client Mode
 

From f7e0389da0179405645ded3ecb4e3a161108d12a Mon Sep 17 00:00:00 2001
From: Carlos Guerra <cguerrave@gmail.com>
Date: Wed, 8 Apr 2026 19:00:16 +0200
Subject: [PATCH 07/13] PR chage requests, revision to GPS logging feature,
 code cleanup

---
 daemon/src/diag.rs                            |  29 ++++-
 daemon/src/gps.rs                             |  52 +++++++--
 daemon/src/main.rs                            |   7 +-
 daemon/src/pcap.rs                            | 108 ++++++++++++++++--
 daemon/src/qmdl_store.rs                      |   4 +-
 daemon/src/server.rs                          |   9 +-
 .../src/lib/components/AnalysisView.svelte    |  10 +-
 lib/src/pcap.rs                               |  12 +-
 8 files changed, 192 insertions(+), 39 deletions(-)

diff --git a/daemon/src/diag.rs b/daemon/src/diag.rs
index 9a309c5e..10d5e3af 100644
--- a/daemon/src/diag.rs
+++ b/daemon/src/diag.rs
@@ -12,7 +12,9 @@ use futures::{StreamExt, TryStreamExt, future};
 use log::{debug, error, info, warn};
 use rayhunter::Device;
 use tokio::fs::File;
-use tokio::io::{AsyncBufReadExt, BufReader};
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+
+use crate::gps::GpsRecord;
 use tokio::sync::mpsc::{Receiver, Sender};
 use tokio::sync::{RwLock, oneshot};
 use tokio_stream::wrappers::LinesStream;
@@ -57,6 +59,7 @@ pub struct DiagTask {
     min_space_to_start_mb: u64,
     min_space_to_continue_mb: u64,
     gps_mode: u8,
+    gps_fixed_coords: Option<(f64, f64)>,
     state: DiagState,
     max_type_seen: EventType,
     bytes_since_space_check: usize,
@@ -106,6 +109,7 @@ impl DiagTask {
         min_space_to_start_mb: u64,
         min_space_to_continue_mb: u64,
         gps_mode: u8,
+        gps_fixed_coords: Option<(f64, f64)>,
     ) -> Self {
         Self {
             ui_update_sender,
@@ -115,6 +119,7 @@ impl DiagTask {
             min_space_to_start_mb,
             min_space_to_continue_mb,
             gps_mode,
+            gps_fixed_coords,
             state: DiagState::Stopped,
             max_type_seen: EventType::Informational,
             bytes_since_space_check: 0,
@@ -155,6 +160,26 @@ impl DiagTask {
                 return Err(msg);
             }
         };
+        // For fixed-mode sessions, write the configured coordinates to the sidecar
+        // immediately so the per-session GPS is stored durably and isn't affected
+        // by future config changes or GPS API calls.
+        if self.gps_mode == 1 {
+            if let Some((lat, lon)) = self.gps_fixed_coords {
+                if let Some((entry_idx, _)) = qmdl_store.get_current_entry() {
+                    if let Ok(mut gps_file) = qmdl_store.open_entry_gps_for_append(entry_idx).await
+                    {
+                        let record = GpsRecord {
+                            unix_ts: 0,
+                            lat,
+                            lon,
+                        };
+                        if let Ok(json) = serde_json::to_string(&record) {
+                            let _ = gps_file.write_all(format!("{json}\n").as_bytes()).await;
+                        }
+                    }
+                }
+            }
+        }
         self.stop_current_recording().await;
         let qmdl_writer = QmdlWriter::new(qmdl_file);
         let analysis_writer = match AnalysisWriter::new(analysis_file, &self.analyzer_config).await
@@ -385,6 +410,7 @@ pub fn run_diag_read_thread(
     min_space_to_start_mb: u64,
     min_space_to_continue_mb: u64,
     gps_mode: u8,
+    gps_fixed_coords: Option<(f64, f64)>,
 ) {
     task_tracker.spawn(async move {
         info!("Using configuration for device: {0:?}", device);
@@ -402,6 +428,7 @@ pub fn run_diag_read_thread(
             min_space_to_start_mb,
             min_space_to_continue_mb,
             gps_mode,
+            gps_fixed_coords,
         );
         qmdl_file_tx
             .send(DiagDeviceCtrlMessage::StartRecording { response_tx: None })
diff --git a/daemon/src/gps.rs b/daemon/src/gps.rs
index dd9db37a..44893afd 100644
--- a/daemon/src/gps.rs
+++ b/daemon/src/gps.rs
@@ -1,6 +1,8 @@
 use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
+use chrono::{DateTime, FixedOffset, Utc};
+use log::error;
 use serde::{Deserialize, Deserializer, Serialize};
 use std::sync::Arc;
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
@@ -14,13 +16,18 @@ where
     use serde::de;
     use serde_json::Value;
     match Value::deserialize(deserializer)? {
-        Value::Number(n) => n.as_i64()
+        Value::Number(n) => n
+            .as_i64()
             .or_else(|| n.as_f64().map(|f| f as i64))
             .ok_or_else(|| de::Error::custom("timestamp out of range")),
-        Value::String(s) => s.trim().parse::<f64>()
+        Value::String(s) => s
+            .trim()
+            .parse::<f64>()
             .map(|f| f as i64)
             .map_err(|_| de::Error::custom("timestamp must be a numeric value")),
-        _ => Err(de::Error::custom("timestamp must be a number or numeric string")),
+        _ => Err(de::Error::custom(
+            "timestamp must be a number or numeric string",
+        )),
     }
 }
 
@@ -32,14 +39,30 @@ pub struct GpsData {
     pub timestamp: i64,
 }
 
+impl GpsData {
+    pub fn to_datetime(&self) -> DateTime<FixedOffset> {
+        DateTime::from_timestamp(self.timestamp, 0)
+            .unwrap_or_default()
+            .fixed_offset()
+    }
+}
+
 #[derive(Serialize, Deserialize)]
 pub struct GpsRecord {
-    pub unix_ts: u32,
+    pub unix_ts: i64,
     pub lat: f64,
     pub lon: f64,
 }
 
-/// Reads all GPS records from a sidecar file, skipping malformed lines.
+impl GpsRecord {
+    pub fn to_datetime(&self) -> DateTime<FixedOffset> {
+        DateTime::from_timestamp(self.unix_ts, 0)
+            .unwrap_or_default()
+            .fixed_offset()
+    }
+}
+
+/// Reads all GPS records from a sidecar NDJSON file, skipping malformed lines.
 pub async fn load_gps_records(file: tokio::fs::File) -> Vec<GpsRecord> {
     let reader = BufReader::new(file);
     let mut lines = reader.lines();
@@ -69,9 +92,18 @@ pub async fn post_gps(
     let qmdl_store = state.qmdl_store_lock.read().await;
     if let Some((entry_idx, _)) = qmdl_store.get_current_entry() {
         if let Ok(mut file) = qmdl_store.open_entry_gps_for_append(entry_idx).await {
-            let record = GpsRecord { unix_ts: chrono::Utc::now().timestamp() as u32, lat: gps_data.latitude, lon: gps_data.longitude };
-            if let Ok(json) = serde_json::to_string(&record) {
-                let _ = file.write_all(format!("{json}\n").as_bytes()).await;
+            let record = GpsRecord {
+                unix_ts: Utc::now().timestamp(),
+                lat: gps_data.latitude,
+                lon: gps_data.longitude,
+            };
+            match serde_json::to_string(&record) {
+                Ok(json) => {
+                    if let Err(e) = file.write_all(format!("{json}\n").as_bytes()).await {
+                        error!("failed to write GPS record to sidecar: {e}");
+                    }
+                }
+                Err(e) => error!("failed to serialize GPS record: {e}"),
             }
         }
     }
@@ -79,9 +111,7 @@ pub async fn post_gps(
     Ok(StatusCode::OK)
 }
 
-pub async fn get_gps(
-    State(state): State<Arc<ServerState>>,
-) -> Result<Json<GpsData>, StatusCode> {
+pub async fn get_gps(State(state): State<Arc<ServerState>>) -> Result<Json<GpsData>, StatusCode> {
     let gps = state.gps_state.read().await;
     match gps.as_ref() {
         Some(data) => Ok(Json(data.clone())),
diff --git a/daemon/src/main.rs b/daemon/src/main.rs
index 954030bd..358b00b4 100644
--- a/daemon/src/main.rs
+++ b/daemon/src/main.rs
@@ -22,10 +22,10 @@ use crate::battery::run_battery_notification_worker;
 use crate::config::{parse_args, parse_config};
 use crate::diag::run_diag_read_thread;
 use crate::error::RayhunterError;
+use crate::gps::{get_gps, post_gps};
 use crate::notifications::{NotificationService, run_notification_worker};
 use crate::pcap::get_pcap;
 use crate::qmdl_store::RecordingStore;
-use crate::gps::{get_gps, post_gps};
 use crate::server::{
     ServerState, debug_set_display_state, get_config, get_qmdl, get_time, get_wifi_status, get_zip,
     scan_wifi, serve_static, set_config, set_time_offset, test_notification,
@@ -221,6 +221,10 @@ async fn run_with_config(
 
     if !config.debug_mode {
         info!("Starting Diag Thread");
+        let gps_fixed_coords = match (config.gps_fixed_latitude, config.gps_fixed_longitude) {
+            (Some(lat), Some(lon)) => Some((lat, lon)),
+            _ => None,
+        };
         run_diag_read_thread(
             &task_tracker,
             config.device.clone(),
@@ -234,6 +238,7 @@ async fn run_with_config(
             config.min_space_to_start_recording_mb,
             config.min_space_to_continue_recording_mb,
             config.gps_mode,
+            gps_fixed_coords,
         );
         info!("Starting UI");
 
diff --git a/daemon/src/pcap.rs b/daemon/src/pcap.rs
index 46417ffb..603028f4 100644
--- a/daemon/src/pcap.rs
+++ b/daemon/src/pcap.rs
@@ -75,6 +75,7 @@ pub(crate) async fn load_gps_records_for_entry(
 ) -> Vec<GpsRecord> {
     // Always try the per-session sidecar first — it reflects what was actually
     // recorded regardless of what the current gps_mode config is.
+    let entry_gps_mode;
     {
         let qmdl_store = state.qmdl_store_lock.read().await;
         if let Ok(file) = qmdl_store.open_entry_gps(entry_index).await {
@@ -83,19 +84,33 @@ pub(crate) async fn load_gps_records_for_entry(
                 return records;
             }
         }
+        // Capture the entry's recorded GPS mode before releasing the lock.
+        entry_gps_mode = qmdl_store
+            .manifest
+            .entries
+            .get(entry_index)
+            .and_then(|e| e.gps_mode);
     }
-    // Sidecar missing or empty — fall back to current config.
-    if state.config.gps_mode == 1 {
-        let guard = state.gps_state.read().await;
-        return guard
-            .as_ref()
-            .map(|g| vec![GpsRecord { unix_ts: 0, lat: g.latitude, lon: g.longitude }])
-            .unwrap_or_default();
+    // Sidecar missing or empty — fall back using the entry's own recorded GPS mode,
+    // not the current config, so old fixed-mode sessions still get coordinates even
+    // if the mode has since been changed. Use the configured fixed coords directly
+    // rather than gps_state, which can be overwritten by API calls or be None.
+    if entry_gps_mode == Some(1) {
+        if let (Some(lat), Some(lon)) = (
+            state.config.gps_fixed_latitude,
+            state.config.gps_fixed_longitude,
+        ) {
+            return vec![GpsRecord {
+                unix_ts: 0,
+                lat,
+                lon,
+            }];
+        }
     }
     vec![]
 }
 
-fn find_nearest_gps(records: &[GpsRecord], packet_unix_ts: u32) -> Option<GpsPoint> {
+fn find_nearest_gps(records: &[GpsRecord], packet_unix_ts: i64) -> Option<GpsPoint> {
     if records.is_empty() {
         return None;
     }
@@ -106,9 +121,79 @@ fn find_nearest_gps(records: &[GpsRecord], packet_unix_ts: u32) -> Option<GpsPoi
         &records[records.len() - 1]
     } else {
         let (before, after) = (&records[idx - 1], &records[idx]);
-        if packet_unix_ts - before.unix_ts <= after.unix_ts - packet_unix_ts { before } else { after }
+        let before_delta = packet_unix_ts - before.unix_ts;
+        let after_delta = after.unix_ts - packet_unix_ts;
+        if before_delta <= after_delta {
+            before
+        } else {
+            after
+        }
     };
-    Some(GpsPoint { latitude: record.lat, longitude: record.lon, unix_ts: record.unix_ts })
+    Some(GpsPoint {
+        latitude: record.lat,
+        longitude: record.lon,
+        unix_ts: record.unix_ts,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn rec(unix_ts: i64, lat: f64, lon: f64) -> GpsRecord {
+        GpsRecord { unix_ts, lat, lon }
+    }
+
+    #[test]
+    fn test_empty_returns_none() {
+        assert!(find_nearest_gps(&[], 100).is_none());
+    }
+
+    #[test]
+    fn test_single_record_always_returned() {
+        let records = vec![rec(100, 1.0, 2.0)];
+        assert_eq!(find_nearest_gps(&records, 0).unwrap().unix_ts, 100);
+        assert_eq!(find_nearest_gps(&records, 200).unwrap().unix_ts, 100);
+    }
+
+    #[test]
+    fn test_before_all_records_returns_first() {
+        let records = vec![rec(100, 1.0, 2.0), rec(200, 3.0, 4.0)];
+        assert_eq!(find_nearest_gps(&records, 50).unwrap().unix_ts, 100);
+    }
+
+    #[test]
+    fn test_after_all_records_returns_last() {
+        let records = vec![rec(100, 1.0, 2.0), rec(200, 3.0, 4.0)];
+        assert_eq!(find_nearest_gps(&records, 300).unwrap().unix_ts, 200);
+    }
+
+    #[test]
+    fn test_exact_match() {
+        let records = vec![rec(100, 1.0, 2.0), rec(200, 3.0, 4.0), rec(300, 5.0, 6.0)];
+        assert_eq!(find_nearest_gps(&records, 200).unwrap().unix_ts, 200);
+    }
+
+    #[test]
+    fn test_closer_to_before() {
+        // packet at 130: delta to before(100)=30, delta to after(200)=70 → picks before
+        let records = vec![rec(100, 1.0, 2.0), rec(200, 3.0, 4.0)];
+        assert_eq!(find_nearest_gps(&records, 130).unwrap().unix_ts, 100);
+    }
+
+    #[test]
+    fn test_closer_to_after() {
+        // packet at 170: delta to before(100)=70, delta to after(200)=30 → picks after
+        let records = vec![rec(100, 1.0, 2.0), rec(200, 3.0, 4.0)];
+        assert_eq!(find_nearest_gps(&records, 170).unwrap().unix_ts, 200);
+    }
+
+    #[test]
+    fn test_equidistant_prefers_before() {
+        // packet at 150: delta to before(100)=50, delta to after(200)=50 → tie, picks before
+        let records = vec![rec(100, 1.0, 2.0), rec(200, 3.0, 4.0)];
+        assert_eq!(find_nearest_gps(&records, 150).unwrap().unix_ts, 100);
+    }
 }
 
 pub async fn generate_pcap_data<R, W>(
@@ -135,8 +220,7 @@ where
                 Ok(msg) => {
                     let maybe_gsmtap_msg = gsmtap_parser::parse(msg)?;
                     if let Some((timestamp, gsmtap_msg)) = maybe_gsmtap_msg {
-                        let packet_unix_ts =
-                            timestamp.to_datetime().timestamp().max(0) as u32;
+                        let packet_unix_ts = timestamp.to_datetime().timestamp();
                         let gps = find_nearest_gps(&gps_records, packet_unix_ts);
                         pcap_writer
                             .write_gsmtap_message(gsmtap_msg, timestamp, gps.as_ref())
diff --git a/daemon/src/qmdl_store.rs b/daemon/src/qmdl_store.rs
index a66cb8ff..7a0ef7c8 100644
--- a/daemon/src/qmdl_store.rs
+++ b/daemon/src/qmdl_store.rs
@@ -105,9 +105,7 @@ impl ManifestEntry {
     }
 
     pub fn get_gps_filepath<P: AsRef<Path>>(&self, path: P) -> PathBuf {
-        let mut filepath = path.as_ref().join(&self.name);
-        filepath.set_extension("gps.ndjson");
-        filepath
+        path.as_ref().join(format!("{}-gps.ndjson", self.name))
     }
 }
 
diff --git a/daemon/src/server.rs b/daemon/src/server.rs
index e4bc2043..15bfe9af 100644
--- a/daemon/src/server.rs
+++ b/daemon/src/server.rs
@@ -388,8 +388,13 @@ pub async fn get_zip(
                         .take(qmdl_size_bytes as u64)
                 };
 
-                if let Err(e) =
-                    generate_pcap_data(&mut entry_writer, qmdl_file_for_pcap, qmdl_size_bytes, gps_records).await
+                if let Err(e) = generate_pcap_data(
+                    &mut entry_writer,
+                    qmdl_file_for_pcap,
+                    qmdl_size_bytes,
+                    gps_records,
+                )
+                .await
                 {
                     // if we fail to generate the PCAP file, we should still continue and give the
                     // user the QMDL.
diff --git a/daemon/web/src/lib/components/AnalysisView.svelte b/daemon/web/src/lib/components/AnalysisView.svelte
index eee0b6ba..8cb67619 100644
--- a/daemon/web/src/lib/components/AnalysisView.svelte
+++ b/daemon/web/src/lib/components/AnalysisView.svelte
@@ -55,12 +55,10 @@
                     <p>Analysis by Rayhunter version {metadata.rayhunter.rayhunter_version}</p>
                     <p><b>Device system OS:</b> {metadata.rayhunter.system_os}</p>
                 </div>
-                {#if entry.gps_mode !== undefined}
-                    <div>
-                        <p class="text-lg underline">GPS Mode</p>
-                        <p>{entry.gps_mode === 0 ? 'Disabled' : entry.gps_mode === 1 ? 'Fixed coordinates' : 'API endpoint'}</p>
-                    </div>
-                {/if}
+                <div>
+                    <p class="text-lg underline">GPS Mode</p>
+                    <p>{(entry.gps_mode ?? 0) === 0 ? 'Disabled' : entry.gps_mode === 1 ? 'Fixed coordinates' : 'API endpoint'}</p>
+                </div>
                 <div>
                     <p class="text-lg underline">Analyzers</p>
                     {#each metadata.analyzers as analyzer}
diff --git a/lib/src/pcap.rs b/lib/src/pcap.rs
index 497ede07..c82d7fba 100644
--- a/lib/src/pcap.rs
+++ b/lib/src/pcap.rs
@@ -30,7 +30,7 @@ pub struct GpsPoint {
     pub latitude: f64,
     pub longitude: f64,
     /// Unix timestamp of the GPS fix. 0 means fixed/synthetic (no real GPS time).
-    pub unix_ts: u32,
+    pub unix_ts: i64,
 }
 
 pub struct GsmtapPcapWriter<T>
@@ -149,9 +149,15 @@ where
         let mut options = vec![];
         if let Some(p) = gps {
             let comment = if p.unix_ts == 0 {
-                format!("GPS fixed lat={:.7} lon={:.7}", p.latitude, p.longitude)
+                format!(
+                    r#"{{"latitude":{:.7},"longitude":{:.7}}}"#,
+                    p.latitude, p.longitude
+                )
             } else {
-                format!("GPS lat={:.7} lon={:.7} ts={}", p.latitude, p.longitude, p.unix_ts)
+                format!(
+                    r#"{{"latitude":{:.7},"longitude":{:.7},"timestamp":{}}}"#,
+                    p.latitude, p.longitude, p.unix_ts
+                )
             };
             options.push(EnhancedPacketOption::Comment(Cow::Owned(comment)));
         }

From 2e366ac31f3688d04922dc38584158778e41a459 Mon Sep 17 00:00:00 2001
From: Carlos Guerra <cguerrave@gmail.com>
Date: Wed, 8 Apr 2026 19:29:45 +0200
Subject: [PATCH 08/13] replacing numbered options in config with rust enum
 implementation, unique commit to make easier to debug or rollback

---
 Cargo.lock                                    |  1 +
 daemon/Cargo.toml                             |  1 +
 daemon/src/config.rs                          | 44 ++++++++++++++++---
 daemon/src/diag.rs                            |  9 ++--
 daemon/src/display/generic_framebuffer.rs     | 19 ++++----
 daemon/src/display/tmobile.rs                 |  4 +-
 daemon/src/display/tplink.rs                  |  4 +-
 daemon/src/display/tplink_onebit.rs           |  6 +--
 daemon/src/display/uz801.rs                   |  4 +-
 daemon/src/gps.rs                             |  3 +-
 daemon/src/key_input.rs                       |  4 +-
 daemon/src/main.rs                            |  4 +-
 daemon/src/pcap.rs                            |  3 +-
 daemon/src/qmdl_store.rs                      | 10 +++--
 .../web/src/lib/components/ConfigForm.svelte  | 21 +++++----
 15 files changed, 87 insertions(+), 50 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 34868560..29dda59f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4596,6 +4596,7 @@ dependencies = [
  "rustls-rustcrypto",
  "serde",
  "serde_json",
+ "serde_repr",
  "tempfile",
  "thiserror 1.0.69",
  "tokio",
diff --git a/daemon/Cargo.toml b/daemon/Cargo.toml
index a593b895..9bf53cc2 100644
--- a/daemon/Cargo.toml
+++ b/daemon/Cargo.toml
@@ -24,6 +24,7 @@ rayhunter = { path = "../lib" }
 wifi-station = { git = "https://github.com/BeigeBox/wifi-station", rev = "e8ec5b4" }
 toml = "0.8.8"
 serde = { version = "1.0.193", features = ["derive"] }
+serde_repr = "0.1"
 tokio = { version = "1.44.2", default-features = false, features = ["fs", "signal", "process", "rt"] }
 axum = { version = "0.8", default-features = false, features = ["http1", "tokio", "json"] }
 thiserror = "1.0.52"
diff --git a/daemon/src/config.rs b/daemon/src/config.rs
index bde94d66..8e3c64bd 100644
--- a/daemon/src/config.rs
+++ b/daemon/src/config.rs
@@ -1,10 +1,40 @@
 use log::warn;
 use serde::{Deserialize, Serialize};
+use serde_repr::{Deserialize_repr, Serialize_repr};
 
 use rayhunter::Device;
 use rayhunter::analysis::analyzer::AnalyzerConfig;
 
 use crate::error::RayhunterError;
+
+#[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Serialize_repr, Deserialize_repr)]
+#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
+pub enum GpsMode {
+    Disabled = 0,
+    Fixed = 1,
+    Api = 2,
+}
+
+#[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Serialize_repr, Deserialize_repr)]
+#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
+pub enum UiLevel {
+    Invisible = 0,
+    Subtle = 1,
+    Demo = 2,
+    EffLogo = 3,
+    HighVisibility = 4,
+    TransFlag = 128,
+}
+
+#[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Serialize_repr, Deserialize_repr)]
+#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
+pub enum KeyInputMode {
+    Disabled = 0,
+    DoubleTapPower = 1,
+}
 use crate::notifications::NotificationType;
 
 /// The structure of a valid rayhunter configuration
@@ -21,11 +51,11 @@ pub struct Config {
     /// Internal device name
     pub device: Device,
     /// UI level
-    pub ui_level: u8,
+    pub ui_level: UiLevel,
     /// Colorblind mode
     pub colorblind_mode: bool,
     /// Key input mode
-    pub key_input_mode: u8,
+    pub key_input_mode: KeyInputMode,
     /// ntfy.sh URL
     pub ntfy_url: Option<String>,
     /// Vector containing the types of enabled notifications
@@ -36,8 +66,8 @@ pub struct Config {
     pub min_space_to_start_recording_mb: u64,
     /// Minimum disk space required to continue a recording
     pub min_space_to_continue_recording_mb: u64,
-    /// GPS mode: 0=Disabled, 1=Fixed coordinates, 2=API endpoint
-    pub gps_mode: u8,
+    /// GPS mode
+    pub gps_mode: GpsMode,
     /// Fixed latitude used when gps_mode=1
     pub gps_fixed_latitude: Option<f64>,
     /// Fixed longitude used when gps_mode=1
@@ -102,15 +132,15 @@ impl Default for Config {
             port: 8080,
             debug_mode: false,
             device: Device::Orbic,
-            ui_level: 1,
+            ui_level: UiLevel::Subtle,
             colorblind_mode: false,
-            key_input_mode: 0,
+            key_input_mode: KeyInputMode::Disabled,
             analyzers: AnalyzerConfig::default(),
             ntfy_url: None,
             enabled_notifications: vec![NotificationType::Warning, NotificationType::LowBattery],
             min_space_to_start_recording_mb: 1,
             min_space_to_continue_recording_mb: 1,
-            gps_mode: 0,
+            gps_mode: GpsMode::Disabled,
             gps_fixed_latitude: None,
             gps_fixed_longitude: None,
             wifi_ssid: None,
diff --git a/daemon/src/diag.rs b/daemon/src/diag.rs
index 10d5e3af..6b7f3d41 100644
--- a/daemon/src/diag.rs
+++ b/daemon/src/diag.rs
@@ -28,6 +28,7 @@ use rayhunter::diag_device::DiagDevice;
 use rayhunter::qmdl::QmdlWriter;
 
 use crate::analysis::{AnalysisCtrlMessage, AnalysisWriter};
+use crate::config::GpsMode;
 use crate::display;
 use crate::notifications::{Notification, NotificationType};
 use crate::qmdl_store::{RecordingStore, RecordingStoreError};
@@ -58,7 +59,7 @@ pub struct DiagTask {
     notification_channel: tokio::sync::mpsc::Sender<Notification>,
     min_space_to_start_mb: u64,
     min_space_to_continue_mb: u64,
-    gps_mode: u8,
+    gps_mode: GpsMode,
     gps_fixed_coords: Option<(f64, f64)>,
     state: DiagState,
     max_type_seen: EventType,
@@ -108,7 +109,7 @@ impl DiagTask {
         notification_channel: tokio::sync::mpsc::Sender<Notification>,
         min_space_to_start_mb: u64,
         min_space_to_continue_mb: u64,
-        gps_mode: u8,
+        gps_mode: GpsMode,
         gps_fixed_coords: Option<(f64, f64)>,
     ) -> Self {
         Self {
@@ -163,7 +164,7 @@ impl DiagTask {
         // For fixed-mode sessions, write the configured coordinates to the sidecar
         // immediately so the per-session GPS is stored durably and isn't affected
         // by future config changes or GPS API calls.
-        if self.gps_mode == 1 {
+        if self.gps_mode == GpsMode::Fixed {
             if let Some((lat, lon)) = self.gps_fixed_coords {
                 if let Some((entry_idx, _)) = qmdl_store.get_current_entry() {
                     if let Ok(mut gps_file) = qmdl_store.open_entry_gps_for_append(entry_idx).await
@@ -409,7 +410,7 @@ pub fn run_diag_read_thread(
     notification_channel: tokio::sync::mpsc::Sender<Notification>,
     min_space_to_start_mb: u64,
     min_space_to_continue_mb: u64,
-    gps_mode: u8,
+    gps_mode: GpsMode,
     gps_fixed_coords: Option<(f64, f64)>,
 ) {
     task_tracker.spawn(async move {
diff --git a/daemon/src/display/generic_framebuffer.rs b/daemon/src/display/generic_framebuffer.rs
index a37b2368..9fcfb4fc 100644
--- a/daemon/src/display/generic_framebuffer.rs
+++ b/daemon/src/display/generic_framebuffer.rs
@@ -3,7 +3,7 @@ use image::{AnimationDecoder, DynamicImage, codecs::gif::GifDecoder, imageops::F
 use std::io::Cursor;
 use std::time::Duration;
 
-use crate::config;
+use crate::config::{self, UiLevel};
 use crate::display::DisplayState;
 use rayhunter::analysis::analyzer::EventType;
 
@@ -176,7 +176,7 @@ pub fn update_ui(
 ) {
     static IMAGE_DIR: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/images/");
     let display_level = config.ui_level;
-    if display_level == 0 {
+    if display_level == UiLevel::Invisible {
         info!("Invisible mode, not spawning UI.");
         return;
     }
@@ -187,14 +187,14 @@ pub fn update_ui(
     task_tracker.spawn(async move {
         // this feels wrong, is there a more rusty way to do this?
         let mut img: Option<&[u8]> = None;
-        if display_level == 2 {
+        if display_level == UiLevel::Demo {
             img = Some(
                 IMAGE_DIR
                     .get_file("orca.gif")
                     .expect("failed to read orca.gif")
                     .contents(),
             );
-        } else if display_level == 3 {
+        } else if display_level == UiLevel::EffLogo {
             img = Some(
                 IMAGE_DIR
                     .get_file("eff.png")
@@ -217,20 +217,19 @@ pub fn update_ui(
 
             let mut status_bar_height = 2;
             match display_level {
-                2 => fb.draw_gif(img.unwrap()).await,
-                3 => fb.draw_img(img.unwrap()).await,
-                4 => {
+                UiLevel::Demo => fb.draw_gif(img.unwrap()).await,
+                UiLevel::EffLogo => fb.draw_img(img.unwrap()).await,
+                UiLevel::HighVisibility => {
                     status_bar_height = fb.dimensions().height;
                 }
-                128 => {
+                UiLevel::TransFlag => {
                     fb.draw_line(Color::Cyan, 128).await;
                     fb.draw_line(Color::Pink, 102).await;
                     fb.draw_line(Color::White, 76).await;
                     fb.draw_line(Color::Pink, 50).await;
                     fb.draw_line(Color::Cyan, 25).await;
                 }
-                // this branch is for ui_level 1, which is also the default if an
-                // unknown value is used
+                // UiLevel::Subtle (1) and anything else: just the status bar line
                 _ => {}
             };
             let (color, pattern) = display_style;
diff --git a/daemon/src/display/tmobile.rs b/daemon/src/display/tmobile.rs
index 1a39fc12..e50e6a81 100644
--- a/daemon/src/display/tmobile.rs
+++ b/daemon/src/display/tmobile.rs
@@ -9,7 +9,7 @@ use tokio_util::task::TaskTracker;
 
 use std::time::Duration;
 
-use crate::config;
+use crate::config::{self, UiLevel};
 use crate::display::DisplayState;
 
 macro_rules! led {
@@ -31,7 +31,7 @@ pub fn update_ui(
     mut ui_update_rx: mpsc::Receiver<DisplayState>,
 ) {
     let mut invisible: bool = false;
-    if config.ui_level == 0 {
+    if config.ui_level == UiLevel::Invisible {
         info!("Invisible mode, not spawning UI.");
         invisible = true;
     }
diff --git a/daemon/src/display/tplink.rs b/daemon/src/display/tplink.rs
index fe512777..a3d515e3 100644
--- a/daemon/src/display/tplink.rs
+++ b/daemon/src/display/tplink.rs
@@ -3,7 +3,7 @@ use tokio::sync::mpsc::Receiver;
 use tokio_util::sync::CancellationToken;
 use tokio_util::task::TaskTracker;
 
-use crate::config;
+use crate::config::{self, UiLevel};
 use crate::display::{DisplayState, tplink_framebuffer, tplink_onebit};
 
 use std::fs;
@@ -15,7 +15,7 @@ pub fn update_ui(
     ui_update_rx: Receiver<DisplayState>,
 ) {
     let display_level = config.ui_level;
-    if display_level == 0 {
+    if display_level == UiLevel::Invisible {
         info!("Invisible mode, not spawning UI.");
     }
 
diff --git a/daemon/src/display/tplink_onebit.rs b/daemon/src/display/tplink_onebit.rs
index fbf3ded4..06d60983 100644
--- a/daemon/src/display/tplink_onebit.rs
+++ b/daemon/src/display/tplink_onebit.rs
@@ -1,7 +1,7 @@
 /// Display module for the TP-Link M7350 oled one-bit display.
 ///
 /// https://github.com/m0veax/tplink_m7350/tree/main/oled
-use crate::config;
+use crate::config::{self, UiLevel};
 use crate::display::DisplayState;
 
 use log::{error, info};
@@ -115,7 +115,7 @@ pub fn update_ui(
     mut ui_update_rx: Receiver<DisplayState>,
 ) {
     let display_level = config.ui_level;
-    if display_level == 0 {
+    if display_level == UiLevel::Invisible {
         info!("Invisible mode, not spawning UI.");
     }
 
@@ -140,7 +140,7 @@ pub fn update_ui(
 
             // we write the status every second because it may have been overwritten through menu
             // navigation.
-            if display_level != 0
+            if display_level != UiLevel::Invisible
                 && let Err(e) = tokio::fs::write(OLED_PATH, pixels).await
             {
                 error!("failed to write to display: {e}");
diff --git a/daemon/src/display/uz801.rs b/daemon/src/display/uz801.rs
index 1f7bd592..df2cc7ea 100644
--- a/daemon/src/display/uz801.rs
+++ b/daemon/src/display/uz801.rs
@@ -9,7 +9,7 @@ use tokio_util::task::TaskTracker;
 
 use std::time::Duration;
 
-use crate::config;
+use crate::config::{self, UiLevel};
 use crate::display::DisplayState;
 
 macro_rules! led {
@@ -31,7 +31,7 @@ pub fn update_ui(
     mut ui_update_rx: mpsc::Receiver<DisplayState>,
 ) {
     let mut invisible: bool = false;
-    if config.ui_level == 0 {
+    if config.ui_level == UiLevel::Invisible {
         info!("Invisible mode, not spawning UI.");
         invisible = true;
     }
diff --git a/daemon/src/gps.rs b/daemon/src/gps.rs
index 44893afd..7dc6419c 100644
--- a/daemon/src/gps.rs
+++ b/daemon/src/gps.rs
@@ -7,6 +7,7 @@ use serde::{Deserialize, Deserializer, Serialize};
 use std::sync::Arc;
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 
+use crate::config::GpsMode;
 use crate::server::ServerState;
 
 fn deserialize_unix_ts<'de, D>(deserializer: D) -> Result<i64, D::Error>
@@ -79,7 +80,7 @@ pub async fn post_gps(
     State(state): State<Arc<ServerState>>,
     Json(gps_data): Json<GpsData>,
 ) -> Result<StatusCode, (StatusCode, String)> {
-    if state.config.gps_mode != 2 {
+    if state.config.gps_mode != GpsMode::Api {
         return Err((
             StatusCode::FORBIDDEN,
             "GPS API endpoint is disabled. Set gps_mode to 2 in configuration.".to_string(),
diff --git a/daemon/src/key_input.rs b/daemon/src/key_input.rs
index 7e75fbbc..0cea6ab4 100644
--- a/daemon/src/key_input.rs
+++ b/daemon/src/key_input.rs
@@ -6,7 +6,7 @@ use tokio::sync::mpsc::Sender;
 use tokio_util::sync::CancellationToken;
 use tokio_util::task::TaskTracker;
 
-use crate::config;
+use crate::config::{self, KeyInputMode};
 use crate::diag::DiagDeviceCtrlMessage;
 
 #[derive(Debug)]
@@ -23,7 +23,7 @@ pub fn run_key_input_thread(
     diag_tx: Sender<DiagDeviceCtrlMessage>,
     cancellation_token: CancellationToken,
 ) {
-    if config.key_input_mode == 0 {
+    if config.key_input_mode == KeyInputMode::Disabled {
         return;
     }
 
diff --git a/daemon/src/main.rs b/daemon/src/main.rs
index 358b00b4..f14f075c 100644
--- a/daemon/src/main.rs
+++ b/daemon/src/main.rs
@@ -19,7 +19,7 @@ use std::net::SocketAddr;
 use std::sync::Arc;
 
 use crate::battery::run_battery_notification_worker;
-use crate::config::{parse_args, parse_config};
+use crate::config::{GpsMode, parse_args, parse_config};
 use crate::diag::run_diag_read_thread;
 use crate::error::RayhunterError;
 use crate::gps::{get_gps, post_gps};
@@ -308,7 +308,7 @@ async fn run_with_config(
             webdav_config.into(),
         );
     }
-    let initial_gps = if config.gps_mode == 1 {
+    let initial_gps = if config.gps_mode == GpsMode::Fixed {
         match (config.gps_fixed_latitude, config.gps_fixed_longitude) {
             (Some(lat), Some(lon)) => Some(gps::GpsData {
                 latitude: lat,
diff --git a/daemon/src/pcap.rs b/daemon/src/pcap.rs
index 603028f4..9899178a 100644
--- a/daemon/src/pcap.rs
+++ b/daemon/src/pcap.rs
@@ -1,3 +1,4 @@
+use crate::config::GpsMode;
 use crate::gps::{GpsRecord, load_gps_records};
 use crate::server::ServerState;
 
@@ -95,7 +96,7 @@ pub(crate) async fn load_gps_records_for_entry(
     // not the current config, so old fixed-mode sessions still get coordinates even
     // if the mode has since been changed. Use the configured fixed coords directly
     // rather than gps_state, which can be overwritten by API calls or be None.
-    if entry_gps_mode == Some(1) {
+    if entry_gps_mode == Some(GpsMode::Fixed) {
         if let (Some(lat), Some(lon)) = (
             state.config.gps_fixed_latitude,
             state.config.gps_fixed_longitude,
diff --git a/daemon/src/qmdl_store.rs b/daemon/src/qmdl_store.rs
index 7a0ef7c8..5999646d 100644
--- a/daemon/src/qmdl_store.rs
+++ b/daemon/src/qmdl_store.rs
@@ -2,6 +2,7 @@ use std::io::{self, ErrorKind};
 use std::os::unix::fs::MetadataExt;
 use std::path::{Path, PathBuf};
 
+use crate::config::GpsMode;
 use chrono::{DateTime, Local, TimeDelta};
 use log::{info, warn};
 use rayhunter::util::RuntimeMetadata;
@@ -71,11 +72,11 @@ pub struct ManifestEntry {
     #[cfg_attr(feature = "apidocs", schema(value_type = String))]
     pub upload_time: Option<DateTime<Local>>,
     #[serde(default)]
-    pub gps_mode: Option<u8>,
+    pub gps_mode: Option<GpsMode>,
 }
 
 impl ManifestEntry {
-    fn new(gps_mode: u8) -> Self {
+    fn new(gps_mode: GpsMode) -> Self {
         let now = rayhunter::clock::get_adjusted_now();
         let metadata = RuntimeMetadata::new();
         ManifestEntry {
@@ -257,7 +258,10 @@ impl RecordingStore {
     // Closes the current entry (if needed), creates a new entry based on the
     // current time, and updates the manifest. Returns a tuple of the entry's
     // newly created QMDL file and analysis file.
-    pub async fn new_entry(&mut self, gps_mode: u8) -> Result<(File, File), RecordingStoreError> {
+    pub async fn new_entry(
+        &mut self,
+        gps_mode: GpsMode,
+    ) -> Result<(File, File), RecordingStoreError> {
         // if we've already got an entry open, close it
         if self.current_entry.is_some() {
             self.close_current_entry().await?;
diff --git a/daemon/web/src/lib/components/ConfigForm.svelte b/daemon/web/src/lib/components/ConfigForm.svelte
index c8a802ef..5b34072f 100644
--- a/daemon/web/src/lib/components/ConfigForm.svelte
+++ b/daemon/web/src/lib/components/ConfigForm.svelte
@@ -166,11 +166,11 @@
                         bind:value={config.ui_level}
                         class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-hidden focus:ring-2 focus:ring-rayhunter-blue"
                     >
-                        <option value={0}>0 - Invisible mode</option>
-                        <option value={1}>1 - Subtle mode (colored line)</option>
-                        <option value={2}>2 - Demo mode (orca gif)</option>
-                        <option value={3}>3 - EFF logo</option>
-                        <option value={4}>4 - High visibility (full screen color)</option>
+                        <option value={0}>Invisible mode</option>
+                        <option value={1}>Subtle mode (colored line)</option>
+                        <option value={2}>Demo mode (orca gif)</option>
+                        <option value={3}>EFF logo</option>
+                        <option value={4}>High visibility (full screen color)</option>
                     </select>
                     <p class="text-xs text-gray-500 mt-1">
                         Note: Rayhunter draws over the device's native UI, so some flickering is
@@ -190,9 +190,8 @@
                         bind:value={config.key_input_mode}
                         class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-hidden focus:ring-2 focus:ring-rayhunter-blue"
                     >
-                        <option value={0}>0 - Disable button control</option>
-                        <option value={1}>1 - Double-tap power button to start new recording</option
-                        >
+                        <option value={0}>Disable button control</option>
+                        <option value={1}>Double-tap power button to start new recording</option>
                     </select>
                 </div>
 
@@ -673,9 +672,9 @@
                     <div>
                         <label for="gps_mode" class="block text-sm font-medium text-gray-700 mb-1">GPS Mode</label>
                         <select id="gps_mode" bind:value={config.gps_mode} class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue">
-                            <option value={0}>0 - Disabled</option>
-                            <option value={1}>1 - Fixed coordinates</option>
-                            <option value={2}>2 - API Endpoint</option>
+                            <option value={0}>Disabled</option>
+                            <option value={1}>Fixed coordinates</option>
+                            <option value={2}>API endpoint</option>
                         </select>
                         <p class="text-xs text-gray-500 mt-1">
                             {#if config.gps_mode === 2}

From a5275f63c90fa7f9ea219f18d7512a101804d8b8 Mon Sep 17 00:00:00 2001
From: Carlos Guerra <cguerrave@gmail.com>
Date: Thu, 16 Apr 2026 21:24:53 +0200
Subject: [PATCH 09/13] new merge conflict addressed, to_datetime unused code
 removed, some refactoring to appease tests

---
 daemon/src/diag.rs       | 27 +++++++++++-------------
 daemon/src/gps.rs        | 44 +++++++++++++---------------------------
 daemon/src/pcap.rs       | 18 ++++++++--------
 daemon/src/qmdl_store.rs | 10 ++++-----
 daemon/src/server.rs     |  5 +++--
 5 files changed, 43 insertions(+), 61 deletions(-)

diff --git a/daemon/src/diag.rs b/daemon/src/diag.rs
index 6b7f3d41..ba520dca 100644
--- a/daemon/src/diag.rs
+++ b/daemon/src/diag.rs
@@ -164,21 +164,18 @@ impl DiagTask {
         // For fixed-mode sessions, write the configured coordinates to the sidecar
         // immediately so the per-session GPS is stored durably and isn't affected
         // by future config changes or GPS API calls.
-        if self.gps_mode == GpsMode::Fixed {
-            if let Some((lat, lon)) = self.gps_fixed_coords {
-                if let Some((entry_idx, _)) = qmdl_store.get_current_entry() {
-                    if let Ok(mut gps_file) = qmdl_store.open_entry_gps_for_append(entry_idx).await
-                    {
-                        let record = GpsRecord {
-                            unix_ts: 0,
-                            lat,
-                            lon,
-                        };
-                        if let Ok(json) = serde_json::to_string(&record) {
-                            let _ = gps_file.write_all(format!("{json}\n").as_bytes()).await;
-                        }
-                    }
-                }
+        if self.gps_mode == GpsMode::Fixed
+            && let Some((lat, lon)) = self.gps_fixed_coords
+            && let Some((entry_idx, _)) = qmdl_store.get_current_entry()
+            && let Ok(mut gps_file) = qmdl_store.open_entry_gps_for_append(entry_idx).await
+        {
+            let record = GpsRecord {
+                unix_ts: 0,
+                lat,
+                lon,
+            };
+            if let Ok(json) = serde_json::to_string(&record) {
+                let _ = gps_file.write_all(format!("{json}\n").as_bytes()).await;
             }
         }
         self.stop_current_recording().await;
diff --git a/daemon/src/gps.rs b/daemon/src/gps.rs
index 7dc6419c..1b612818 100644
--- a/daemon/src/gps.rs
+++ b/daemon/src/gps.rs
@@ -1,7 +1,7 @@
 use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
-use chrono::{DateTime, FixedOffset, Utc};
+use chrono::Utc;
 use log::error;
 use serde::{Deserialize, Deserializer, Serialize};
 use std::sync::Arc;
@@ -40,14 +40,6 @@ pub struct GpsData {
     pub timestamp: i64,
 }
 
-impl GpsData {
-    pub fn to_datetime(&self) -> DateTime<FixedOffset> {
-        DateTime::from_timestamp(self.timestamp, 0)
-            .unwrap_or_default()
-            .fixed_offset()
-    }
-}
-
 #[derive(Serialize, Deserialize)]
 pub struct GpsRecord {
     pub unix_ts: i64,
@@ -55,14 +47,6 @@ pub struct GpsRecord {
     pub lon: f64,
 }
 
-impl GpsRecord {
-    pub fn to_datetime(&self) -> DateTime<FixedOffset> {
-        DateTime::from_timestamp(self.unix_ts, 0)
-            .unwrap_or_default()
-            .fixed_offset()
-    }
-}
-
 /// Reads all GPS records from a sidecar NDJSON file, skipping malformed lines.
 pub async fn load_gps_records(file: tokio::fs::File) -> Vec<GpsRecord> {
     let reader = BufReader::new(file);
@@ -91,21 +75,21 @@ pub async fn post_gps(
     drop(gps);
 
     let qmdl_store = state.qmdl_store_lock.read().await;
-    if let Some((entry_idx, _)) = qmdl_store.get_current_entry() {
-        if let Ok(mut file) = qmdl_store.open_entry_gps_for_append(entry_idx).await {
-            let record = GpsRecord {
-                unix_ts: Utc::now().timestamp(),
-                lat: gps_data.latitude,
-                lon: gps_data.longitude,
-            };
-            match serde_json::to_string(&record) {
-                Ok(json) => {
-                    if let Err(e) = file.write_all(format!("{json}\n").as_bytes()).await {
-                        error!("failed to write GPS record to sidecar: {e}");
-                    }
+    if let Some((entry_idx, _)) = qmdl_store.get_current_entry()
+        && let Ok(mut file) = qmdl_store.open_entry_gps_for_append(entry_idx).await
+    {
+        let record = GpsRecord {
+            unix_ts: Utc::now().timestamp(),
+            lat: gps_data.latitude,
+            lon: gps_data.longitude,
+        };
+        match serde_json::to_string(&record) {
+            Ok(json) => {
+                if let Err(e) = file.write_all(format!("{json}\n").as_bytes()).await {
+                    error!("failed to write GPS record to sidecar: {e}");
                 }
-                Err(e) => error!("failed to serialize GPS record: {e}"),
             }
+            Err(e) => error!("failed to serialize GPS record: {e}"),
         }
     }
 
diff --git a/daemon/src/pcap.rs b/daemon/src/pcap.rs
index 9899178a..33068b4e 100644
--- a/daemon/src/pcap.rs
+++ b/daemon/src/pcap.rs
@@ -96,17 +96,17 @@ pub(crate) async fn load_gps_records_for_entry(
     // not the current config, so old fixed-mode sessions still get coordinates even
     // if the mode has since been changed. Use the configured fixed coords directly
     // rather than gps_state, which can be overwritten by API calls or be None.
-    if entry_gps_mode == Some(GpsMode::Fixed) {
-        if let (Some(lat), Some(lon)) = (
+    if entry_gps_mode == Some(GpsMode::Fixed)
+        && let (Some(lat), Some(lon)) = (
             state.config.gps_fixed_latitude,
             state.config.gps_fixed_longitude,
-        ) {
-            return vec![GpsRecord {
-                unix_ts: 0,
-                lat,
-                lon,
-            }];
-        }
+        )
+    {
+        return vec![GpsRecord {
+            unix_ts: 0,
+            lat,
+            lon,
+        }];
     }
     vec![]
 }
diff --git a/daemon/src/qmdl_store.rs b/daemon/src/qmdl_store.rs
index 5999646d..15693911 100644
--- a/daemon/src/qmdl_store.rs
+++ b/daemon/src/qmdl_store.rs
@@ -551,7 +551,7 @@ mod tests {
     async fn test_creating_updating_and_closing_entries() {
         let dir = make_temp_dir();
         let mut store = RecordingStore::create(dir.path()).await.unwrap();
-        let _ = store.new_entry(0).await.unwrap();
+        let _ = store.new_entry(GpsMode::Disabled).await.unwrap();
         let entry_index = store.current_entry.unwrap();
         assert_eq!(
             RecordingStore::read_manifest(dir.path()).await.unwrap(),
@@ -588,7 +588,7 @@ mod tests {
     async fn test_create_on_existing_store() {
         let dir = make_temp_dir();
         let mut store = RecordingStore::create(dir.path()).await.unwrap();
-        let _ = store.new_entry(0).await.unwrap();
+        let _ = store.new_entry(GpsMode::Disabled).await.unwrap();
         let entry_index = store.current_entry.unwrap();
         store
             .update_entry_qmdl_size(entry_index, 1000)
@@ -602,9 +602,9 @@ mod tests {
     async fn test_repeated_new_entries() {
         let dir = make_temp_dir();
         let mut store = RecordingStore::create(dir.path()).await.unwrap();
-        let _ = store.new_entry(0).await.unwrap();
+        let _ = store.new_entry(GpsMode::Disabled).await.unwrap();
         let entry_index = store.current_entry.unwrap();
-        let _ = store.new_entry(0).await.unwrap();
+        let _ = store.new_entry(GpsMode::Disabled).await.unwrap();
         let new_entry_index = store.current_entry.unwrap();
         assert_ne!(entry_index, new_entry_index);
         assert_eq!(store.manifest.entries.len(), 2);
@@ -614,7 +614,7 @@ mod tests {
     async fn test_delete_all_entries() {
         let dir = make_temp_dir();
         let mut store = RecordingStore::create(dir.path()).await.unwrap();
-        let _ = store.new_entry(0).await.unwrap();
+        let _ = store.new_entry(GpsMode::Disabled).await.unwrap();
         assert!(store.current_entry.is_some());
 
         store.delete_all_entries().await.unwrap();
diff --git a/daemon/src/server.rs b/daemon/src/server.rs
index 15bfe9af..6756baae 100644
--- a/daemon/src/server.rs
+++ b/daemon/src/server.rs
@@ -25,8 +25,8 @@ use crate::analysis::{AnalysisCtrlMessage, AnalysisStatus};
 use crate::config::Config;
 use crate::diag::DiagDeviceCtrlMessage;
 use crate::display::DisplayState;
-use crate::notifications::DEFAULT_NOTIFICATION_TIMEOUT;
 use crate::gps::GpsData;
+use crate::notifications::DEFAULT_NOTIFICATION_TIMEOUT;
 use crate::pcap::{generate_pcap_data, load_gps_records_for_entry};
 use crate::qmdl_store::RecordingStore;
 
@@ -509,6 +509,7 @@ pub async fn debug_set_display_state(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::config::GpsMode;
     use async_zip::base::read::mem::ZipFileReader;
     use axum::extract::{Path, State};
     use tempfile::TempDir;
@@ -528,7 +529,7 @@ mod tests {
     ) -> String {
         let entry_name = {
             let mut store = store_lock.write().await;
-            let (mut qmdl_file, _analysis_file) = store.new_entry(0).await.unwrap();
+            let (mut qmdl_file, _analysis_file) = store.new_entry(GpsMode::Disabled).await.unwrap();
 
             if !test_data.is_empty() {
                 use tokio::io::AsyncWriteExt;

From b91a2122175984fa36f91852eda875f7c552e2a0 Mon Sep 17 00:00:00 2001
From: Carlos Guerra <cguerrave@gmail.com>
Date: Sun, 19 Apr 2026 16:50:51 +0200
Subject: [PATCH 10/13] requests addressed, better error handling, more
 logging, small text corrections

---
 daemon/src/diag.rs                            | 23 ++++---
 daemon/src/gps.rs                             | 66 +++++++++++++------
 daemon/src/main.rs                            |  2 +
 daemon/src/pcap.rs                            | 52 ++++++---------
 daemon/src/qmdl_store.rs                      | 23 +++++--
 .../src/lib/components/AnalysisView.svelte    |  3 +-
 .../web/src/lib/components/ConfigForm.svelte  | 13 ++--
 .../src/lib/components/ManifestCard.svelte    |  3 +-
 daemon/web/src/lib/manifest.svelte.ts         |  5 +-
 daemon/web/src/lib/utils.svelte.ts            |  8 ++-
 daemon/web/src/routes/+page.svelte            |  6 +-
 11 files changed, 122 insertions(+), 82 deletions(-)

diff --git a/daemon/src/diag.rs b/daemon/src/diag.rs
index ba520dca..b8e92153 100644
--- a/daemon/src/diag.rs
+++ b/daemon/src/diag.rs
@@ -167,15 +167,22 @@ impl DiagTask {
         if self.gps_mode == GpsMode::Fixed
             && let Some((lat, lon)) = self.gps_fixed_coords
             && let Some((entry_idx, _)) = qmdl_store.get_current_entry()
-            && let Ok(mut gps_file) = qmdl_store.open_entry_gps_for_append(entry_idx).await
         {
-            let record = GpsRecord {
-                unix_ts: 0,
-                lat,
-                lon,
-            };
-            if let Ok(json) = serde_json::to_string(&record) {
-                let _ = gps_file.write_all(format!("{json}\n").as_bytes()).await;
+            match qmdl_store.open_entry_gps_for_append(entry_idx).await {
+                Ok(Some(mut gps_file)) => {
+                    let record = GpsRecord {
+                        unix_ts: 0,
+                        lat,
+                        lon,
+                    };
+                    if let Ok(json) = serde_json::to_string(&record) {
+                        let _ = gps_file.write_all(format!("{json}\n").as_bytes()).await;
+                    }
+                }
+                Ok(None) => {
+                    error!("GPS sidecar directory not found, cannot write fixed-mode coordinates")
+                }
+                Err(e) => error!("failed to open GPS sidecar for fixed-mode entry: {e}"),
             }
         }
         self.stop_current_recording().await;
diff --git a/daemon/src/gps.rs b/daemon/src/gps.rs
index 1b612818..3158fca2 100644
--- a/daemon/src/gps.rs
+++ b/daemon/src/gps.rs
@@ -2,7 +2,7 @@ use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
 use chrono::Utc;
-use log::error;
+use log::{error, warn};
 use serde::{Deserialize, Deserializer, Serialize};
 use std::sync::Arc;
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
@@ -47,14 +47,22 @@ pub struct GpsRecord {
     pub lon: f64,
 }
 
-/// Reads all GPS records from a sidecar NDJSON file, skipping malformed lines.
+/// Reads all GPS records from a sidecar NDJSON file, logging and skipping malformed lines.
 pub async fn load_gps_records(file: tokio::fs::File) -> Vec<GpsRecord> {
     let reader = BufReader::new(file);
     let mut lines = reader.lines();
     let mut records = Vec::new();
-    while let Ok(Some(line)) = lines.next_line().await {
-        if let Ok(record) = serde_json::from_str::<GpsRecord>(&line) {
-            records.push(record);
+    loop {
+        match lines.next_line().await {
+            Ok(Some(line)) => match serde_json::from_str::<GpsRecord>(&line) {
+                Ok(record) => records.push(record),
+                Err(e) => warn!("skipping malformed GPS sidecar line: {e}"),
+            },
+            Ok(None) => break,
+            Err(e) => {
+                error!("error reading GPS sidecar file: {e}");
+                break;
+            }
         }
     }
     records
@@ -67,7 +75,8 @@ pub async fn post_gps(
     if state.config.gps_mode != GpsMode::Api {
         return Err((
             StatusCode::FORBIDDEN,
-            "GPS API endpoint is disabled. Set gps_mode to 2 in configuration.".to_string(),
+            "GPS API endpoint is disabled. Set gps_mode to API endpoint in configuration."
+                .to_string(),
         ));
     }
     let mut gps = state.gps_state.write().await;
@@ -75,21 +84,38 @@ pub async fn post_gps(
     drop(gps);
 
     let qmdl_store = state.qmdl_store_lock.read().await;
-    if let Some((entry_idx, _)) = qmdl_store.get_current_entry()
-        && let Ok(mut file) = qmdl_store.open_entry_gps_for_append(entry_idx).await
-    {
-        let record = GpsRecord {
-            unix_ts: Utc::now().timestamp(),
-            lat: gps_data.latitude,
-            lon: gps_data.longitude,
-        };
-        match serde_json::to_string(&record) {
-            Ok(json) => {
-                if let Err(e) = file.write_all(format!("{json}\n").as_bytes()).await {
-                    error!("failed to write GPS record to sidecar: {e}");
-                }
+    if let Some((entry_idx, _)) = qmdl_store.get_current_entry() {
+        match qmdl_store.open_entry_gps_for_append(entry_idx).await {
+            Ok(Some(mut file)) => {
+                let record = GpsRecord {
+                    unix_ts: Utc::now().timestamp(),
+                    lat: gps_data.latitude,
+                    lon: gps_data.longitude,
+                };
+                let json = serde_json::to_string(&record).map_err(|e| {
+                    error!("failed to serialize GPS record: {e}");
+                    (
+                        StatusCode::INTERNAL_SERVER_ERROR,
+                        format!("failed to serialize GPS record: {e}"),
+                    )
+                })?;
+                file.write_all(format!("{json}\n").as_bytes())
+                    .await
+                    .map_err(|e| {
+                        error!("failed to write GPS record to sidecar: {e}");
+                        (
+                            StatusCode::INTERNAL_SERVER_ERROR,
+                            format!("failed to write GPS record to sidecar: {e}"),
+                        )
+                    })?;
+            }
+            Ok(None) => error!("GPS sidecar directory not found, cannot write GPS record"),
+            Err(e) => {
+                return Err((
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    format!("failed to open GPS sidecar: {e}"),
+                ));
             }
-            Err(e) => error!("failed to serialize GPS record: {e}"),
         }
     }
 
diff --git a/daemon/src/main.rs b/daemon/src/main.rs
index f14f075c..187a5e06 100644
--- a/daemon/src/main.rs
+++ b/daemon/src/main.rs
@@ -308,6 +308,8 @@ async fn run_with_config(
             webdav_config.into(),
         );
     }
+    // For fixed configuration, we use timestamp 0 to not break other
+    // the GET request for GPS but user won't see the 0 in PCAPs
     let initial_gps = if config.gps_mode == GpsMode::Fixed {
         match (config.gps_fixed_latitude, config.gps_fixed_longitude) {
             (Some(lat), Some(lon)) => Some(gps::GpsData {
diff --git a/daemon/src/pcap.rs b/daemon/src/pcap.rs
index 33068b4e..eb93a8d1 100644
--- a/daemon/src/pcap.rs
+++ b/daemon/src/pcap.rs
@@ -1,7 +1,7 @@
-use crate::config::GpsMode;
 use crate::gps::{GpsRecord, load_gps_records};
 use crate::server::ServerState;
 
+use crate::config::GpsMode;
 use anyhow::Error;
 use axum::body::Body;
 use axum::extract::{Path, State};
@@ -74,41 +74,27 @@ pub(crate) async fn load_gps_records_for_entry(
     state: &Arc<ServerState>,
     entry_index: usize,
 ) -> Vec<GpsRecord> {
-    // Always try the per-session sidecar first — it reflects what was actually
-    // recorded regardless of what the current gps_mode config is.
-    let entry_gps_mode;
-    {
-        let qmdl_store = state.qmdl_store_lock.read().await;
-        if let Ok(file) = qmdl_store.open_entry_gps(entry_index).await {
-            let records = load_gps_records(file).await;
-            if !records.is_empty() {
-                return records;
+    let qmdl_store = state.qmdl_store_lock.read().await;
+    match qmdl_store.open_entry_gps(entry_index).await {
+        Ok(Some(file)) => load_gps_records(file).await,
+        Ok(None) => {
+            let gps_mode = qmdl_store
+                .manifest
+                .entries
+                .get(entry_index)
+                .and_then(|e| e.gps_mode);
+            if gps_mode.is_some_and(|m| m != GpsMode::Disabled) {
+                error!(
+                    "GPS sidecar expected for entry {entry_index} (mode: {gps_mode:?}) but not found"
+                );
             }
+            vec![]
+        }
+        Err(e) => {
+            error!("failed to open GPS sidecar: {e}");
+            vec![]
         }
-        // Capture the entry's recorded GPS mode before releasing the lock.
-        entry_gps_mode = qmdl_store
-            .manifest
-            .entries
-            .get(entry_index)
-            .and_then(|e| e.gps_mode);
-    }
-    // Sidecar missing or empty — fall back using the entry's own recorded GPS mode,
-    // not the current config, so old fixed-mode sessions still get coordinates even
-    // if the mode has since been changed. Use the configured fixed coords directly
-    // rather than gps_state, which can be overwritten by API calls or be None.
-    if entry_gps_mode == Some(GpsMode::Fixed)
-        && let (Some(lat), Some(lon)) = (
-            state.config.gps_fixed_latitude,
-            state.config.gps_fixed_longitude,
-        )
-    {
-        return vec![GpsRecord {
-            unix_ts: 0,
-            lat,
-            lon,
-        }];
     }
-    vec![]
 }
 
 fn find_nearest_gps(records: &[GpsRecord], packet_unix_ts: i64) -> Option<GpsPoint> {
diff --git a/daemon/src/qmdl_store.rs b/daemon/src/qmdl_store.rs
index 15693911..e74c66a7 100644
--- a/daemon/src/qmdl_store.rs
+++ b/daemon/src/qmdl_store.rs
@@ -304,24 +304,33 @@ impl RecordingStore {
             .map_err(RecordingStoreError::ReadFileError)
     }
 
-    pub async fn open_entry_gps(&self, entry_index: usize) -> Result<File, RecordingStoreError> {
+    pub async fn open_entry_gps(
+        &self,
+        entry_index: usize,
+    ) -> Result<Option<File>, RecordingStoreError> {
         let entry = &self.manifest.entries[entry_index];
-        File::open(entry.get_gps_filepath(&self.path))
-            .await
-            .map_err(RecordingStoreError::ReadFileError)
+        match File::open(entry.get_gps_filepath(&self.path)).await {
+            Ok(file) => Ok(Some(file)),
+            Err(e) if e.kind() == ErrorKind::NotFound => Ok(None),
+            Err(e) => Err(RecordingStoreError::ReadFileError(e)),
+        }
     }
 
     pub async fn open_entry_gps_for_append(
         &self,
         entry_index: usize,
-    ) -> Result<File, RecordingStoreError> {
+    ) -> Result<Option<File>, RecordingStoreError> {
         let entry = &self.manifest.entries[entry_index];
-        OpenOptions::new()
+        match OpenOptions::new()
             .create(true)
             .append(true)
             .open(entry.get_gps_filepath(&self.path))
             .await
-            .map_err(RecordingStoreError::CreateFileError)
+        {
+            Ok(file) => Ok(Some(file)),
+            Err(e) if e.kind() == ErrorKind::NotFound => Ok(None),
+            Err(e) => Err(RecordingStoreError::CreateFileError(e)),
+        }
     }
 
     pub async fn clear_and_open_entry_analysis(
diff --git a/daemon/web/src/lib/components/AnalysisView.svelte b/daemon/web/src/lib/components/AnalysisView.svelte
index 8cb67619..7f5ab6c9 100644
--- a/daemon/web/src/lib/components/AnalysisView.svelte
+++ b/daemon/web/src/lib/components/AnalysisView.svelte
@@ -1,6 +1,7 @@
 <script lang="ts">
     import { type ReportMetadata } from '$lib/analysis.svelte';
     import type { ManifestEntry } from '$lib/manifest.svelte';
+    import { GpsMode } from '$lib/utils.svelte';
     import { AnalysisManager } from '$lib/analysisManager.svelte';
     import AnalysisTable from './AnalysisTable.svelte';
     import ReAnalyzeButton from './ReAnalyzeButton.svelte';
@@ -57,7 +58,7 @@
                 </div>
                 <div>
                     <p class="text-lg underline">GPS Mode</p>
-                    <p>{(entry.gps_mode ?? 0) === 0 ? 'Disabled' : entry.gps_mode === 1 ? 'Fixed coordinates' : 'API endpoint'}</p>
+                    <p>{(entry.gps_mode ?? GpsMode.Disabled) === GpsMode.Disabled ? 'Disabled' : entry.gps_mode === GpsMode.Fixed ? 'Fixed coordinates' : 'API endpoint'}</p>
                 </div>
                 <div>
                     <p class="text-lg underline">Analyzers</p>
diff --git a/daemon/web/src/lib/components/ConfigForm.svelte b/daemon/web/src/lib/components/ConfigForm.svelte
index 5b34072f..c81421eb 100644
--- a/daemon/web/src/lib/components/ConfigForm.svelte
+++ b/daemon/web/src/lib/components/ConfigForm.svelte
@@ -5,6 +5,7 @@
         test_notification,
         get_wifi_status,
         scan_wifi_networks,
+        GpsMode,
         type Config,
         type WifiStatus,
         type WifiNetwork,
@@ -672,21 +673,21 @@
                     <div>
                         <label for="gps_mode" class="block text-sm font-medium text-gray-700 mb-1">GPS Mode</label>
                         <select id="gps_mode" bind:value={config.gps_mode} class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue">
-                            <option value={0}>Disabled</option>
-                            <option value={1}>Fixed coordinates</option>
-                            <option value={2}>API endpoint</option>
+                            <option value={GpsMode.Disabled}>Disabled</option>
+                            <option value={GpsMode.Fixed}>Fixed coordinates</option>
+                            <option value={GpsMode.Api}>API endpoint</option>
                         </select>
                         <p class="text-xs text-gray-500 mt-1">
-                            {#if config.gps_mode === 2}
+                            {#if config.gps_mode === GpsMode.Api}
                                 POST latitude, longitude, and timestamp to <code>/api/gps</code> from any device on the network.
-                            {:else if config.gps_mode === 1}
+                            {:else if config.gps_mode === GpsMode.Fixed}
                                 GPS coordinates are fixed to the values below.
                             {:else}
                                 GPS is disabled; no coordinates will be tracked.
                             {/if}
                         </p>
                     </div>
-                    {#if config.gps_mode === 1}
+                    {#if config.gps_mode === GpsMode.Fixed}
                         <div>
                             <label for="gps_fixed_latitude" class="block text-sm font-medium text-gray-700 mb-1">Fixed Latitude</label>
                             <input id="gps_fixed_latitude" type="number" min="-90" max="90" step="any" required
diff --git a/daemon/web/src/lib/components/ManifestCard.svelte b/daemon/web/src/lib/components/ManifestCard.svelte
index 9f1a2c93..755e5315 100644
--- a/daemon/web/src/lib/components/ManifestCard.svelte
+++ b/daemon/web/src/lib/components/ManifestCard.svelte
@@ -1,5 +1,6 @@
 <script lang="ts">
     import { ManifestEntry } from '$lib/manifest.svelte';
+    import { GpsMode } from '$lib/utils.svelte';
     import { AnalysisManager } from '$lib/analysisManager.svelte';
     import DownloadLink from '$lib/components/DownloadLink.svelte';
     import DeleteButton from '$lib/components/DeleteButton.svelte';
@@ -88,7 +89,7 @@
     {/if}
     {#if entry.gps_mode !== undefined}
         <div class="text-sm text-gray-500">
-            GPS: {entry.gps_mode === 0 ? 'Disabled' : entry.gps_mode === 1 ? 'Fixed coordinates' : 'API endpoint'}
+            GPS: {entry.gps_mode === GpsMode.Disabled ? 'Disabled' : entry.gps_mode === GpsMode.Fixed ? 'Fixed coordinates' : 'API endpoint'}
         </div>
     {/if}
     <div class="flex flex-row justify-between lg:justify-end gap-1 mt-2 overflow-x-auto">
diff --git a/daemon/web/src/lib/manifest.svelte.ts b/daemon/web/src/lib/manifest.svelte.ts
index 6d14c20b..58eb5387 100644
--- a/daemon/web/src/lib/manifest.svelte.ts
+++ b/daemon/web/src/lib/manifest.svelte.ts
@@ -1,5 +1,6 @@
 import { get_report, type AnalysisReport } from './analysis.svelte';
 import { AnalysisStatus, type AnalysisManager } from './analysisManager.svelte';
+import { GpsMode } from './utils.svelte';
 
 interface JsonManifest {
     entries: JsonManifestEntry[];
@@ -12,7 +13,7 @@ interface JsonManifestEntry {
     last_message_time: string;
     qmdl_size_bytes: number;
     stop_reason: string | null;
-    gps_mode: number | null;
+    gps_mode: GpsMode | null;
 }
 
 export class Manifest {
@@ -60,7 +61,7 @@ export class ManifestEntry {
     public analysis_status: AnalysisStatus | undefined = $state(undefined);
     public analysis_report: AnalysisReport | string | undefined = $state(undefined);
     public stop_reason: string | undefined = $state(undefined);
-    public gps_mode: number | undefined = $state(undefined);
+    public gps_mode: GpsMode | undefined = $state(undefined);
 
     constructor(json: JsonManifestEntry) {
         this.name = json.name;
diff --git a/daemon/web/src/lib/utils.svelte.ts b/daemon/web/src/lib/utils.svelte.ts
index ae4b77a0..6eed5f1d 100644
--- a/daemon/web/src/lib/utils.svelte.ts
+++ b/daemon/web/src/lib/utils.svelte.ts
@@ -18,6 +18,12 @@ export enum enabled_notifications {
     LowBattery = 'LowBattery',
 }
 
+export enum GpsMode {
+    Disabled = 0,
+    Fixed = 1,
+    Api = 2,
+}
+
 export interface Config {
     device: string;
     ui_level: number;
@@ -35,7 +41,7 @@ export interface Config {
     dns_servers: string[] | null;
     firewall_restrict_outbound: boolean;
     firewall_allowed_ports: number[] | null;
-    gps_mode: number;
+    gps_mode: GpsMode;
     gps_fixed_latitude: number | null;
     gps_fixed_longitude: number | null;
 }
diff --git a/daemon/web/src/routes/+page.svelte b/daemon/web/src/routes/+page.svelte
index 27b1e0f7..a11cf9dc 100644
--- a/daemon/web/src/routes/+page.svelte
+++ b/daemon/web/src/routes/+page.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
     import { ManifestEntry } from '$lib/manifest.svelte';
-    import { get_manifest, get_system_stats, get_gps, get_config, type GpsData } from '$lib/utils.svelte';
+    import { get_manifest, get_system_stats, get_gps, get_config, GpsMode, type GpsData } from '$lib/utils.svelte';
     import ManifestTable from '$lib/components/ManifestTable.svelte';
     import Card from '$lib/components/ManifestCard.svelte';
     import type { SystemStats } from '$lib/systemStats';
@@ -23,7 +23,7 @@
     let logview_shown: boolean = $state(false);
     let config_shown: boolean = $state(false);
     let gps_data: GpsData | null = $state(null);
-    let gps_mode: number = $state(0);
+    let gps_mode: GpsMode = $state(GpsMode.Disabled);
     $effect(() => {
         get_config().then((c) => {
             gps_mode = c.gps_mode;
@@ -290,7 +290,7 @@
             {/if}
             <SystemStatsTable stats={system_stats!} />
         </div>
-        {#if gps_mode !== 0}
+        {#if gps_mode !== GpsMode.Disabled}
             <div class="bg-white border border-gray-200 drop-shadow rounded-md p-4 flex flex-col gap-2">
                 <span class="text-lg font-semibold flex flex-row items-center gap-2">
                     <svg class="w-5 h-5 text-rayhunter-blue" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">

From cfe8131e0f6eb1d245cbe5f63fc46ba72269c867 Mon Sep 17 00:00:00 2001
From: Carlos Guerra <cguerrave@gmail.com>
Date: Wed, 22 Apr 2026 00:09:37 +0200
Subject: [PATCH 11/13] fixes requested, gps timestamp corrected,  more error
 managing, more border conditions covered

---
 daemon/src/gps.rs                  | 37 +++++++++++++++++++++++++++---
 daemon/src/main.rs                 |  7 ++++--
 daemon/src/server.rs               | 10 +++++---
 daemon/web/src/routes/+page.svelte |  6 ++---
 4 files changed, 48 insertions(+), 12 deletions(-)

diff --git a/daemon/src/gps.rs b/daemon/src/gps.rs
index 3158fca2..83ff70ed 100644
--- a/daemon/src/gps.rs
+++ b/daemon/src/gps.rs
@@ -1,8 +1,7 @@
 use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
-use chrono::Utc;
-use log::{error, warn};
+use log::{error, info, warn};
 use serde::{Deserialize, Deserializer, Serialize};
 use std::sync::Arc;
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
@@ -10,6 +9,34 @@ use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use crate::config::GpsMode;
 use crate::server::ServerState;
 
+fn deserialize_latitude<'de, D>(deserializer: D) -> Result<f64, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    use serde::de;
+    let v = f64::deserialize(deserializer)?;
+    if !(-90.0..=90.0).contains(&v) {
+        return Err(de::Error::custom(format!(
+            "latitude {v} out of range [-90, 90]"
+        )));
+    }
+    Ok(v)
+}
+
+fn deserialize_longitude<'de, D>(deserializer: D) -> Result<f64, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    use serde::de;
+    let v = f64::deserialize(deserializer)?;
+    if !(-180.0..=180.0).contains(&v) {
+        return Err(de::Error::custom(format!(
+            "longitude {v} out of range [-180, 180]"
+        )));
+    }
+    Ok(v)
+}
+
 fn deserialize_unix_ts<'de, D>(deserializer: D) -> Result<i64, D::Error>
 where
     D: Deserializer<'de>,
@@ -34,7 +61,9 @@ where
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct GpsData {
+    #[serde(deserialize_with = "deserialize_latitude")]
     pub latitude: f64,
+    #[serde(deserialize_with = "deserialize_longitude")]
     pub longitude: f64,
     #[serde(deserialize_with = "deserialize_unix_ts")]
     pub timestamp: i64,
@@ -88,7 +117,7 @@ pub async fn post_gps(
         match qmdl_store.open_entry_gps_for_append(entry_idx).await {
             Ok(Some(mut file)) => {
                 let record = GpsRecord {
-                    unix_ts: Utc::now().timestamp(),
+                    unix_ts: gps_data.timestamp,
                     lat: gps_data.latitude,
                     lon: gps_data.longitude,
                 };
@@ -117,6 +146,8 @@ pub async fn post_gps(
                 ));
             }
         }
+    } else {
+        info!("GPS data received but no recording is active — position updated in memory only, not persisted to sidecar");
     }
 
     Ok(StatusCode::OK)
diff --git a/daemon/src/main.rs b/daemon/src/main.rs
index 187a5e06..84e857e9 100644
--- a/daemon/src/main.rs
+++ b/daemon/src/main.rs
@@ -44,7 +44,7 @@ use diag::{
     DiagDeviceCtrlMessage, delete_all_recordings, delete_recording, get_analysis_report,
     start_recording, stop_recording,
 };
-use log::{error, info};
+use log::{error, info, warn};
 use qmdl_store::RecordingStoreError;
 use rayhunter::Device;
 use stats::get_log;
@@ -317,7 +317,10 @@ async fn run_with_config(
                 longitude: lon,
                 timestamp: 0,
             }),
-            _ => None,
+            _ => {
+                warn!("gps_mode is Fixed but gps_fixed_latitude or gps_fixed_longitude is missing from config — no GPS coordinates will be recorded");
+                None
+            }
         }
     } else {
         None
diff --git a/daemon/src/server.rs b/daemon/src/server.rs
index 6756baae..e1bb2540 100644
--- a/daemon/src/server.rs
+++ b/daemon/src/server.rs
@@ -22,7 +22,7 @@ use tokio_util::io::ReaderStream;
 use tokio_util::sync::CancellationToken;
 
 use crate::analysis::{AnalysisCtrlMessage, AnalysisStatus};
-use crate::config::Config;
+use crate::config::{Config, GpsMode};
 use crate::diag::DiagDeviceCtrlMessage;
 use crate::display::DisplayState;
 use crate::gps::GpsData;
@@ -162,8 +162,12 @@ pub async fn get_config(
 ))]
 pub async fn set_config(
     State(state): State<Arc<ServerState>>,
-    Json(config): Json<Config>,
+    Json(mut config): Json<Config>,
 ) -> Result<(StatusCode, String), (StatusCode, String)> {
+    if config.gps_mode != GpsMode::Fixed {
+        config.gps_fixed_latitude = None;
+        config.gps_fixed_longitude = None;
+    }
     let mut config_to_write = config.clone();
     config_to_write.wifi_ssid = None;
     config_to_write.wifi_password = None;
@@ -509,7 +513,7 @@ pub async fn debug_set_display_state(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::config::GpsMode;
+    use crate::config::GpsMode as _;
     use async_zip::base::read::mem::ZipFileReader;
     use axum::extract::{Path, State};
     use tempfile::TempDir;
diff --git a/daemon/web/src/routes/+page.svelte b/daemon/web/src/routes/+page.svelte
index a11cf9dc..a31cb75d 100644
--- a/daemon/web/src/routes/+page.svelte
+++ b/daemon/web/src/routes/+page.svelte
@@ -25,10 +25,6 @@
     let gps_data: GpsData | null = $state(null);
     let gps_mode: GpsMode = $state(GpsMode.Disabled);
     $effect(() => {
-        get_config().then((c) => {
-            gps_mode = c.gps_mode;
-        });
-
         const interval = setInterval(async () => {
             try {
                 // Don't update UI if browser tab isn't visible
@@ -46,6 +42,8 @@
                 current_entry = new_manifest.current_entry;
 
                 system_stats = await get_system_stats();
+                const config = await get_config();
+                gps_mode = config.gps_mode;
                 gps_data = await get_gps();
                 update_error = undefined;
                 loaded = true;

From ca57b2ed661147ef20625f66fd3331a6290f2d8a Mon Sep 17 00:00:00 2001
From: Carlos Guerra <cguerrave@gmail.com>
Date: Wed, 29 Apr 2026 11:18:30 +0200
Subject: [PATCH 12/13] suggested fix for gps feature, sorting timestamps

---
 daemon/src/gps.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/daemon/src/gps.rs b/daemon/src/gps.rs
index 83ff70ed..057b46fc 100644
--- a/daemon/src/gps.rs
+++ b/daemon/src/gps.rs
@@ -94,6 +94,7 @@ pub async fn load_gps_records(file: tokio::fs::File) -> Vec<GpsRecord> {
             }
         }
     }
+    records.sort_by_key(|r| r.unix_ts);
     records
 }
 

From 3d448e57f55845d45c8cda77e4b9aac59e8e6830 Mon Sep 17 00:00:00 2001
From: Carlos Guerra <cguerrave@gmail.com>
Date: Wed, 29 Apr 2026 12:39:08 +0200
Subject: [PATCH 13/13] rebasing with upsream (webdav and wifi client)

---
 daemon/src/gps.rs        | 4 +++-
 daemon/src/main.rs       | 4 +++-
 daemon/src/qmdl_store.rs | 4 ++--
 daemon/src/server.rs     | 2 +-
 daemon/src/webdav.rs     | 4 ++--
 5 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/daemon/src/gps.rs b/daemon/src/gps.rs
index 057b46fc..b41622aa 100644
--- a/daemon/src/gps.rs
+++ b/daemon/src/gps.rs
@@ -148,7 +148,9 @@ pub async fn post_gps(
             }
         }
     } else {
-        info!("GPS data received but no recording is active — position updated in memory only, not persisted to sidecar");
+        info!(
+            "GPS data received but no recording is active — position updated in memory only, not persisted to sidecar"
+        );
     }
 
     Ok(StatusCode::OK)
diff --git a/daemon/src/main.rs b/daemon/src/main.rs
index 84e857e9..171be411 100644
--- a/daemon/src/main.rs
+++ b/daemon/src/main.rs
@@ -318,7 +318,9 @@ async fn run_with_config(
                 timestamp: 0,
             }),
             _ => {
-                warn!("gps_mode is Fixed but gps_fixed_latitude or gps_fixed_longitude is missing from config — no GPS coordinates will be recorded");
+                warn!(
+                    "gps_mode is Fixed but gps_fixed_latitude or gps_fixed_longitude is missing from config — no GPS coordinates will be recorded"
+                );
                 None
             }
         }
diff --git a/daemon/src/qmdl_store.rs b/daemon/src/qmdl_store.rs
index e74c66a7..3452050e 100644
--- a/daemon/src/qmdl_store.rs
+++ b/daemon/src/qmdl_store.rs
@@ -639,7 +639,7 @@ mod tests {
     async fn test_mark_entry_as_uploaded_sets_time_and_persists() {
         let dir = make_temp_dir();
         let mut store = RecordingStore::create(dir.path()).await.unwrap();
-        let _ = store.new_entry().await.unwrap();
+        let _ = store.new_entry(GpsMode::Disabled).await.unwrap();
         let name = store.manifest.entries[0].name.clone();
         store.close_current_entry().await.unwrap();
 
@@ -670,7 +670,7 @@ mod tests {
         let mut store = RecordingStore::create(dir.path()).await.unwrap();
 
         for _ in 0..3 {
-            let _ = store.new_entry().await.unwrap();
+            let _ = store.new_entry(GpsMode::Disabled).await.unwrap();
         }
 
         store.manifest.entries[0].name = "entry-0".to_owned();
diff --git a/daemon/src/server.rs b/daemon/src/server.rs
index e1bb2540..ee3865bd 100644
--- a/daemon/src/server.rs
+++ b/daemon/src/server.rs
@@ -513,7 +513,7 @@ pub async fn debug_set_display_state(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::config::GpsMode as _;
+    use crate::config::GpsMode;
     use async_zip::base::read::mem::ZipFileReader;
     use axum::extract::{Path, State};
     use tempfile::TempDir;
diff --git a/daemon/src/webdav.rs b/daemon/src/webdav.rs
index c22752b6..479928ad 100644
--- a/daemon/src/webdav.rs
+++ b/daemon/src/webdav.rs
@@ -11,7 +11,7 @@ use tokio::{select, sync::RwLock, time};
 use tokio_util::io::ReaderStream;
 use tokio_util::{sync::CancellationToken, task::TaskTracker};
 
-use crate::config::WebdavConfig;
+use crate::config::{GpsMode, WebdavConfig};
 use crate::qmdl_store::RecordingStore;
 
 pub struct WebdavUploadWorkerConfig {
@@ -313,7 +313,7 @@ mod tests {
         dir: &std::path::Path,
     ) -> (Arc<RwLock<RecordingStore>>, String) {
         let mut store = RecordingStore::create(dir).await.unwrap();
-        let (mut qmdl_file, mut analysis_file) = store.new_entry().await.unwrap();
+        let (mut qmdl_file, mut analysis_file) = store.new_entry(GpsMode::Disabled).await.unwrap();
         qmdl_file.write_all(b"fake qmdl payload").await.unwrap();
         qmdl_file.flush().await.unwrap();
         analysis_file