feat: isolate event radio profiles

Author: RCGV1

src/mesh/NodeDB.cpp

@@ -2166,6 +2166,19 @@ void NodeDB::loadFromDisk()
     migrationSavePending = false;
     configDecodeFailed = false;
 
+#if USERPREFS_EVENT_MODE
+    // The event config is intentionally isolated from the ordinary config.
+    // We only seed it when no event file exists; a corrupt event file must not
+    // silently fall back to and overwrite the user's normal radio profile.
+    bool eventConfigMissing = false;
+#ifdef FSCom
+    spiLock->lock();
+    eventConfigMissing = !FSCom.exists(configFileName);
+    spiLock->unlock();
+#endif
+    bool initializedEventConfig = false;
+#endif
+
     meshtastic_Config_SecurityConfig backupSecurity = meshtastic_Config_SecurityConfig_init_zero;
 
 #ifdef ARCH_ESP32
@@ -2354,6 +2367,29 @@ void NodeDB::loadFromDisk()
 
     state = loadProto(configFileName, meshtastic_LocalConfig_size, sizeof(meshtastic_LocalConfig), &meshtastic_LocalConfig_msg,
                       &config);
+#if USERPREFS_EVENT_MODE
+    if (eventConfigMissing && state != LoadFileResult::LOAD_SUCCESS) {
+        const LoadFileResult eventConfigState = state;
+        if (loadProto(standardConfigFileName, meshtastic_LocalConfig_size, sizeof(meshtastic_LocalConfig),
+                      &meshtastic_LocalConfig_msg, &config) == LoadFileResult::LOAD_SUCCESS) {
+            // Preserve the user's identity and non-radio preferences, then
+            // replace only LoRa with this event build's compiled defaults.
+            const meshtastic_LocalConfig standardConfig = config;
+            installDefaultConfig(true);
+            const meshtastic_Config_LoRaConfig eventLora = config.lora;
+            config = standardConfig;
+            config.has_lora = true;
+            config.lora = eventLora;
+            state = LoadFileResult::LOAD_SUCCESS;
+            initializedEventConfig = true;
+            LOG_INFO("Initialized event config without modifying %s", standardConfigFileName);
+        } else {
+            // loadProto() clears config before decoding. Restore the event
+            // outcome so the normal default/degraded path handles that safely.
+            state = eventConfigState;
+        }
+    }
+#endif
     if (state == LoadFileResult::DECODE_FAILED) {
         // Config file present but undecodable this boot (corruption / torn write / transient decrypt fail).
         // loadProto() already zeroed `config`, so the keypair is gone from RAM; minting a new one would change
@@ -2415,6 +2451,15 @@ void NodeDB::loadFromDisk()
     config.lora.override_frequency = USERPREFS_LORACONFIG_OVERRIDE_FREQUENCY;
 #endif
 
+#if USERPREFS_EVENT_MODE
+    if (initializedEventConfig) {
+        // This is the first durable event-profile write.  A failed write is
+        // safe: normal files remain untouched and the next event boot retries.
+        if (!saveToDisk(SEGMENT_CONFIG))
+            LOG_ERROR("Unable to persist initial event config");
+    }
+#endif
+
     if (backupSecurity.private_key.size > 0) {
         LOG_DEBUG("Restoring backup of security config");
         config.security = backupSecurity;

src/mesh/NodeDB.h

@@ -112,10 +112,34 @@ extern meshtastic_Position localPosition;
 static constexpr const char *deviceStateFileName = "/prefs/device.proto";
 static constexpr const char *legacyPrefFileName = "/prefs/db.proto";
 static constexpr const char *nodeDatabaseFileName = "/prefs/nodes.proto";
-static constexpr const char *configFileName = "/prefs/config.proto";
+// Event builds keep their radio profile in separate files.  A normal firmware
+// image therefore resumes the user's ordinary config and channel table without
+// a client-mediated restore after an event OTA.
+static constexpr const char *standardConfigFileName = "/prefs/config.proto";
+static constexpr const char *standardChannelFileName = "/prefs/channels.proto";
+static constexpr const char *eventConfigFileName = "/prefs/event-config.proto";
+static constexpr const char *eventChannelFileName = "/prefs/event-channels.proto";
+
+struct RadioProfileStoragePaths {
+    const char *config;
+    const char *channels;
+};
+
+constexpr RadioProfileStoragePaths radioProfileStoragePaths(bool eventMode)
+{
+    return eventMode ? RadioProfileStoragePaths{eventConfigFileName, eventChannelFileName}
+                     : RadioProfileStoragePaths{standardConfigFileName, standardChannelFileName};
+}
+
+#if USERPREFS_EVENT_MODE
+static constexpr auto radioProfileStorage = radioProfileStoragePaths(true);
+#else
+static constexpr auto radioProfileStorage = radioProfileStoragePaths(false);
+#endif
+static constexpr const char *configFileName = radioProfileStorage.config;
+static constexpr const char *channelFileName = radioProfileStorage.channels;
 static constexpr const char *uiconfigFileName = "/prefs/uiconfig.proto";
 static constexpr const char *moduleConfigFileName = "/prefs/module.proto";
-static constexpr const char *channelFileName = "/prefs/channels.proto";
 static constexpr const char *backupFileName = "/backups/backup.proto";
 
 /// Given a node, return how many seconds in the past (vs now) that we last heard from it

test/test_event_profile_storage/test_main.cpp

@@ -0,0 +1,37 @@
+#include "MeshTypes.h" // Include BEFORE TestUtil.h
+#include "TestUtil.h"
+#include "mesh/NodeDB.h"
+#include <unity.h>
+
+void test_standard_profile_uses_standard_files()
+{
+    const auto paths = radioProfileStoragePaths(false);
+
+    TEST_ASSERT_EQUAL_STRING("/prefs/config.proto", paths.config);
+    TEST_ASSERT_EQUAL_STRING("/prefs/channels.proto", paths.channels);
+}
+
+void test_event_profile_uses_isolated_files()
+{
+    const auto paths = radioProfileStoragePaths(true);
+
+    TEST_ASSERT_EQUAL_STRING("/prefs/event-config.proto", paths.config);
+    TEST_ASSERT_EQUAL_STRING("/prefs/event-channels.proto", paths.channels);
+}
+
+void setUp(void) {}
+
+void tearDown(void) {}
+
+extern "C" {
+void setup()
+{
+    initializeTestEnvironment();
+    UNITY_BEGIN();
+    RUN_TEST(test_standard_profile_uses_standard_files);
+    RUN_TEST(test_event_profile_uses_isolated_files);
+    exit(UNITY_END());
+}
+
+void loop() {}
+}