diff --git a/.github/workflows/run-unit-tests.yml b/.github/workflows/run-unit-tests.yml index 795f6dba3..6331f4b21 100644 --- a/.github/workflows/run-unit-tests.yml +++ b/.github/workflows/run-unit-tests.yml @@ -127,6 +127,7 @@ jobs: python3 -B test/test_pico_ble_queues.py -v python3 -B test/test_companion_preferences_transaction.py -v python3 -B test/test_companion_prefs_values.py -v + python3 -B test/test_companion_prefs_image.py -v python3 -B test/test_companion_prefs_tail.py -v python3 -B test/test_companion_radio_settings_transaction.py -v python3 -B test/test_companion_prefs_transactions.py -v diff --git a/examples/companion_radio/DataStore.cpp b/examples/companion_radio/DataStore.cpp index dd82264ec..296e4d695 100644 --- a/examples/companion_radio/DataStore.cpp +++ b/examples/companion_radio/DataStore.cpp @@ -1260,123 +1260,136 @@ bool DataStore::savePrefs(const CompanionNodePrefs& _prefs, double node_lat, dou File file = openWrite(_fs, "/new_prefs"); #endif if (file) { +#if defined(STM32_PLATFORM) + // Keep the explicit wire field list, but make one bounded atomic write. + // Other platforms retain direct writes and their existing stack footprint. + uint8_t image[235]; + size_t image_length = 0; + const auto writeField = [&](const void* data, size_t size) -> bool { + if (image_length > sizeof(image) + || size > sizeof(image) - image_length) { + // Latch failure without reading data or advancing past the buffer. + // The return value only preserves the common emitter interface; + // the exact-length check below is the authoritative write gate. + image_length = sizeof(image) + 1; + return true; + } + memcpy(image + image_length, data, size); + image_length += size; + return true; + }; +#else + const auto writeField = [&file](const void* data, size_t size) -> bool { + return file.write(static_cast(data), size) == size; + }; +#endif uint8_t pad[8]; memset(pad, 0, sizeof(pad)); - bool success = file.write((uint8_t *)&_prefs.airtime_factor, sizeof(float)) == sizeof(float); // 0 - success = success && file.write((uint8_t *)_prefs.node_name, sizeof(_prefs.node_name)) == sizeof(_prefs.node_name); // 4 - success = success && file.write(pad, 4) == 4; // 36 - success = success && file.write((uint8_t *)&node_lat, sizeof(node_lat)) == sizeof(node_lat); // 40 - success = success && file.write((uint8_t *)&node_lon, sizeof(node_lon)) == sizeof(node_lon); // 48 - success = success && file.write((uint8_t *)&_prefs.freq, sizeof(_prefs.freq)) == sizeof(_prefs.freq); // 56 - success = success && file.write((uint8_t *)&_prefs.sf, sizeof(_prefs.sf)) == sizeof(_prefs.sf); // 60 - success = success && file.write((uint8_t *)&_prefs.cr, sizeof(_prefs.cr)) == sizeof(_prefs.cr); // 61 - success = success && file.write((uint8_t *)&_prefs.client_repeat, sizeof(_prefs.client_repeat)) == sizeof(_prefs.client_repeat); // 62 - success = success && file.write((uint8_t *)&_prefs.manual_add_contacts, sizeof(_prefs.manual_add_contacts)) == sizeof(_prefs.manual_add_contacts); // 63 - success = success && file.write((uint8_t *)&_prefs.bw, sizeof(_prefs.bw)) == sizeof(_prefs.bw); // 64 - success = success && file.write((uint8_t *)&_prefs.tx_power_dbm, sizeof(_prefs.tx_power_dbm)) == sizeof(_prefs.tx_power_dbm); // 68 - success = success && file.write((uint8_t *)&_prefs.telemetry_mode_base, sizeof(_prefs.telemetry_mode_base)) == sizeof(_prefs.telemetry_mode_base); // 69 - success = success && file.write((uint8_t *)&_prefs.telemetry_mode_loc, sizeof(_prefs.telemetry_mode_loc)) == sizeof(_prefs.telemetry_mode_loc); // 70 - success = success && file.write((uint8_t *)&_prefs.telemetry_mode_env, sizeof(_prefs.telemetry_mode_env)) == sizeof(_prefs.telemetry_mode_env); // 71 - success = success && file.write((uint8_t *)&_prefs.rx_delay_base, sizeof(_prefs.rx_delay_base)) == sizeof(_prefs.rx_delay_base); // 72 - success = success && file.write((uint8_t *)&_prefs.advert_loc_policy, sizeof(_prefs.advert_loc_policy)) == sizeof(_prefs.advert_loc_policy); // 76 - success = success && file.write((uint8_t *)&_prefs.multi_acks, sizeof(_prefs.multi_acks)) == sizeof(_prefs.multi_acks); // 77 - success = success && file.write((uint8_t *)&_prefs.path_hash_mode, sizeof(_prefs.path_hash_mode)) == sizeof(_prefs.path_hash_mode); // 78 - success = success && file.write(pad, 1) == 1; // 79 - success = success && file.write((uint8_t *)&_prefs.ble_pin, sizeof(_prefs.ble_pin)) == sizeof(_prefs.ble_pin); // 80 - success = success && file.write((uint8_t *)&_prefs.buzzer_quiet, sizeof(_prefs.buzzer_quiet)) == sizeof(_prefs.buzzer_quiet); // 84 - success = success && file.write((uint8_t *)&_prefs.gps_enabled, sizeof(_prefs.gps_enabled)) == sizeof(_prefs.gps_enabled); // 85 - success = success && file.write((uint8_t *)&_prefs.gps_interval, sizeof(_prefs.gps_interval)) == sizeof(_prefs.gps_interval); // 86 - success = success && file.write((uint8_t *)&_prefs.autoadd_config, sizeof(_prefs.autoadd_config)) == sizeof(_prefs.autoadd_config); // 87 - success = success && file.write((uint8_t *)&_prefs.autoadd_max_hops, sizeof(_prefs.autoadd_max_hops)) == sizeof(_prefs.autoadd_max_hops); // 88 - success = success && file.write((uint8_t *)&_prefs.rx_boosted_gain, sizeof(_prefs.rx_boosted_gain)) == sizeof(_prefs.rx_boosted_gain); // 89 - success = success && file.write((uint8_t *)_prefs.default_scope_name, sizeof(_prefs.default_scope_name)) == sizeof(_prefs.default_scope_name); // 90 - success = success && file.write((uint8_t *)_prefs.default_scope_key, sizeof(_prefs.default_scope_key)) == sizeof(_prefs.default_scope_key); // 121 - success = success && file.write((uint8_t *)&_prefs.radio_fem_rxgain, sizeof(_prefs.radio_fem_rxgain)) == sizeof(_prefs.radio_fem_rxgain); // 122 - success = success && file.write((uint8_t *)&_prefs.radio_fem_rxgain_override, - sizeof(_prefs.radio_fem_rxgain_override)) == sizeof(_prefs.radio_fem_rxgain_override); // 123 - success = success && file.write((uint8_t *)&_prefs.vibe_quiet, - sizeof(_prefs.vibe_quiet)) == sizeof(_prefs.vibe_quiet); // 124 - success = success && file.write((uint8_t *)&_prefs.radio_fem_txgain, - sizeof(_prefs.radio_fem_txgain)) == sizeof(_prefs.radio_fem_txgain); // 125 - success = success && file.write((uint8_t *)&_prefs.rx_powersaving_enabled, - sizeof(_prefs.rx_powersaving_enabled)) == sizeof(_prefs.rx_powersaving_enabled); // 126 - success = success && file.write((uint8_t *)&_prefs.rx_ps_rx_us, - sizeof(_prefs.rx_ps_rx_us)) == sizeof(_prefs.rx_ps_rx_us); // 127 - success = success && file.write((uint8_t *)&_prefs.rx_ps_sleep_us, - sizeof(_prefs.rx_ps_sleep_us)) == sizeof(_prefs.rx_ps_sleep_us); // 131 - success = success && file.write((uint8_t *)&_prefs.rx_ps_level, - sizeof(_prefs.rx_ps_level)) == sizeof(_prefs.rx_ps_level); // 135 - success = success && file.write((uint8_t *)&_prefs.rx_ps_preamble, - sizeof(_prefs.rx_ps_preamble)) == sizeof(_prefs.rx_ps_preamble); // 136 - success = success && file.write((uint8_t *)&_prefs.powersaving_enabled, - sizeof(_prefs.powersaving_enabled)) == sizeof(_prefs.powersaving_enabled); // 137 - success = success && file.write((uint8_t *)&_prefs.wifi_enabled, - sizeof(_prefs.wifi_enabled)) == sizeof(_prefs.wifi_enabled); // 138 - success = success && file.write((uint8_t *)&_prefs.powersaving_policy_version, - sizeof(_prefs.powersaving_policy_version)) - == sizeof(_prefs.powersaving_policy_version); // 139 - success = success && file.write((uint8_t *)&_prefs.usb_logging_enabled, - sizeof(_prefs.usb_logging_enabled)) - == sizeof(_prefs.usb_logging_enabled); // 140 - success = success && file.write((uint8_t *)_prefs.bluetooth_name, - sizeof(_prefs.bluetooth_name)) == sizeof(_prefs.bluetooth_name); // 141 - success = success && file.write( + bool success = writeField((uint8_t *)&_prefs.airtime_factor, sizeof(float)); // 0 + success = success && writeField((uint8_t *)_prefs.node_name, sizeof(_prefs.node_name)); // 4 + success = success && writeField(pad, 4); // 36 + success = success && writeField((uint8_t *)&node_lat, sizeof(node_lat)); // 40 + success = success && writeField((uint8_t *)&node_lon, sizeof(node_lon)); // 48 + success = success && writeField((uint8_t *)&_prefs.freq, sizeof(_prefs.freq)); // 56 + success = success && writeField((uint8_t *)&_prefs.sf, sizeof(_prefs.sf)); // 60 + success = success && writeField((uint8_t *)&_prefs.cr, sizeof(_prefs.cr)); // 61 + success = success && writeField((uint8_t *)&_prefs.client_repeat, sizeof(_prefs.client_repeat)); // 62 + success = success && writeField((uint8_t *)&_prefs.manual_add_contacts, sizeof(_prefs.manual_add_contacts)); // 63 + success = success && writeField((uint8_t *)&_prefs.bw, sizeof(_prefs.bw)); // 64 + success = success && writeField((uint8_t *)&_prefs.tx_power_dbm, sizeof(_prefs.tx_power_dbm)); // 68 + success = success && writeField((uint8_t *)&_prefs.telemetry_mode_base, sizeof(_prefs.telemetry_mode_base)); // 69 + success = success && writeField((uint8_t *)&_prefs.telemetry_mode_loc, sizeof(_prefs.telemetry_mode_loc)); // 70 + success = success && writeField((uint8_t *)&_prefs.telemetry_mode_env, sizeof(_prefs.telemetry_mode_env)); // 71 + success = success && writeField((uint8_t *)&_prefs.rx_delay_base, sizeof(_prefs.rx_delay_base)); // 72 + success = success && writeField((uint8_t *)&_prefs.advert_loc_policy, sizeof(_prefs.advert_loc_policy)); // 76 + success = success && writeField((uint8_t *)&_prefs.multi_acks, sizeof(_prefs.multi_acks)); // 77 + success = success && writeField((uint8_t *)&_prefs.path_hash_mode, sizeof(_prefs.path_hash_mode)); // 78 + success = success && writeField(pad, 1); // 79 + success = success && writeField((uint8_t *)&_prefs.ble_pin, sizeof(_prefs.ble_pin)); // 80 + success = success && writeField((uint8_t *)&_prefs.buzzer_quiet, sizeof(_prefs.buzzer_quiet)); // 84 + success = success && writeField((uint8_t *)&_prefs.gps_enabled, sizeof(_prefs.gps_enabled)); // 85 + success = success && writeField((uint8_t *)&_prefs.gps_interval, sizeof(_prefs.gps_interval)); // 86 + success = success && writeField((uint8_t *)&_prefs.autoadd_config, sizeof(_prefs.autoadd_config)); // 87 + success = success && writeField((uint8_t *)&_prefs.autoadd_max_hops, sizeof(_prefs.autoadd_max_hops)); // 88 + success = success && writeField((uint8_t *)&_prefs.rx_boosted_gain, sizeof(_prefs.rx_boosted_gain)); // 89 + success = success && writeField((uint8_t *)_prefs.default_scope_name, sizeof(_prefs.default_scope_name)); // 90 + success = success && writeField((uint8_t *)_prefs.default_scope_key, sizeof(_prefs.default_scope_key)); // 121 + success = success && writeField((uint8_t *)&_prefs.radio_fem_rxgain, sizeof(_prefs.radio_fem_rxgain)); // 122 + success = success && writeField((uint8_t *)&_prefs.radio_fem_rxgain_override, + sizeof(_prefs.radio_fem_rxgain_override)); // 123 + success = success && writeField((uint8_t *)&_prefs.vibe_quiet, + sizeof(_prefs.vibe_quiet)); // 124 + success = success && writeField((uint8_t *)&_prefs.radio_fem_txgain, + sizeof(_prefs.radio_fem_txgain)); // 125 + success = success && writeField((uint8_t *)&_prefs.rx_powersaving_enabled, + sizeof(_prefs.rx_powersaving_enabled)); // 126 + success = success && writeField((uint8_t *)&_prefs.rx_ps_rx_us, + sizeof(_prefs.rx_ps_rx_us)); // 127 + success = success && writeField((uint8_t *)&_prefs.rx_ps_sleep_us, + sizeof(_prefs.rx_ps_sleep_us)); // 131 + success = success && writeField((uint8_t *)&_prefs.rx_ps_level, + sizeof(_prefs.rx_ps_level)); // 135 + success = success && writeField((uint8_t *)&_prefs.rx_ps_preamble, + sizeof(_prefs.rx_ps_preamble)); // 136 + success = success && writeField((uint8_t *)&_prefs.powersaving_enabled, + sizeof(_prefs.powersaving_enabled)); // 137 + success = success && writeField((uint8_t *)&_prefs.wifi_enabled, + sizeof(_prefs.wifi_enabled)); // 138 + success = success && writeField((uint8_t *)&_prefs.powersaving_policy_version, + sizeof(_prefs.powersaving_policy_version)); // 139 + success = success && writeField((uint8_t *)&_prefs.usb_logging_enabled, + sizeof(_prefs.usb_logging_enabled)); // 140 + success = success && writeField((uint8_t *)_prefs.bluetooth_name, + sizeof(_prefs.bluetooth_name)); // 141 + success = success && writeField( (uint8_t *)&_prefs.display_rotation_degrees, - sizeof(_prefs.display_rotation_degrees)) - == sizeof(_prefs.display_rotation_degrees); - success = success && file.write((uint8_t *)&_prefs.cad_enabled, - sizeof(_prefs.cad_enabled)) == sizeof(_prefs.cad_enabled); - success = success && file.write((uint8_t *)&_prefs.cad_scan_timeout_ms, - sizeof(_prefs.cad_scan_timeout_ms)) - == sizeof(_prefs.cad_scan_timeout_ms); - success = success && file.write((uint8_t *)&_prefs.cad_retry_delay_ms, - sizeof(_prefs.cad_retry_delay_ms)) - == sizeof(_prefs.cad_retry_delay_ms); - success = success && file.write((uint8_t *)&_prefs.cad_max_duration_ms, - sizeof(_prefs.cad_max_duration_ms)) - == sizeof(_prefs.cad_max_duration_ms); - success = success && file.write((uint8_t *)&_prefs.bluetooth_mac_mode, - sizeof(_prefs.bluetooth_mac_mode)) - == sizeof(_prefs.bluetooth_mac_mode); - success = success && file.write((uint8_t *)_prefs.bluetooth_mac, - sizeof(_prefs.bluetooth_mac)) == sizeof(_prefs.bluetooth_mac); - success = success && file.write( + sizeof(_prefs.display_rotation_degrees)); + success = success && writeField((uint8_t *)&_prefs.cad_enabled, + sizeof(_prefs.cad_enabled)); + success = success && writeField((uint8_t *)&_prefs.cad_scan_timeout_ms, + sizeof(_prefs.cad_scan_timeout_ms)); + success = success && writeField((uint8_t *)&_prefs.cad_retry_delay_ms, + sizeof(_prefs.cad_retry_delay_ms)); + success = success && writeField((uint8_t *)&_prefs.cad_max_duration_ms, + sizeof(_prefs.cad_max_duration_ms)); + success = success && writeField((uint8_t *)&_prefs.bluetooth_mac_mode, + sizeof(_prefs.bluetooth_mac_mode)); + success = success && writeField((uint8_t *)_prefs.bluetooth_mac, + sizeof(_prefs.bluetooth_mac)); + success = success && writeField( (uint8_t *)&_prefs.bluetooth_stealth_peer_type, - sizeof(_prefs.bluetooth_stealth_peer_type)) - == sizeof(_prefs.bluetooth_stealth_peer_type); - success = success && file.write( + sizeof(_prefs.bluetooth_stealth_peer_type)); + success = success && writeField( (uint8_t *)_prefs.bluetooth_stealth_peer, - sizeof(_prefs.bluetooth_stealth_peer)) - == sizeof(_prefs.bluetooth_stealth_peer); - success = success && file.write( + sizeof(_prefs.bluetooth_stealth_peer)); + success = success && writeField( (uint8_t *)&_prefs.bluetooth_stealth_mode, - sizeof(_prefs.bluetooth_stealth_mode)) - == sizeof(_prefs.bluetooth_stealth_mode); + sizeof(_prefs.bluetooth_stealth_mode)); - success = success && file.write((uint8_t *)&_prefs.tx_delay_factor, - sizeof(_prefs.tx_delay_factor)) == sizeof(_prefs.tx_delay_factor); - success = success && file.write((uint8_t *)&_prefs.direct_tx_delay_factor, - sizeof(_prefs.direct_tx_delay_factor)) == sizeof(_prefs.direct_tx_delay_factor); - success = success && file.write((uint8_t *)&_prefs.interference_threshold, - sizeof(_prefs.interference_threshold)) == sizeof(_prefs.interference_threshold); - success = success && file.write((uint8_t *)&_prefs.agc_reset_interval, - sizeof(_prefs.agc_reset_interval)) == sizeof(_prefs.agc_reset_interval); - success = success && file.write((uint8_t *)&_prefs.tz_offset, - sizeof(_prefs.tz_offset)) == sizeof(_prefs.tz_offset); + success = success && writeField((uint8_t *)&_prefs.tx_delay_factor, + sizeof(_prefs.tx_delay_factor)); + success = success && writeField((uint8_t *)&_prefs.direct_tx_delay_factor, + sizeof(_prefs.direct_tx_delay_factor)); + success = success && writeField((uint8_t *)&_prefs.interference_threshold, + sizeof(_prefs.interference_threshold)); + success = success && writeField((uint8_t *)&_prefs.agc_reset_interval, + sizeof(_prefs.agc_reset_interval)); + success = success && writeField((uint8_t *)&_prefs.tz_offset, + sizeof(_prefs.tz_offset)); #ifdef TBEAM_1W - success = success && file.write((uint8_t *)_prefs.fan_mode, - sizeof(_prefs.fan_mode)) == sizeof(_prefs.fan_mode); - success = success && file.write((uint8_t *)&_prefs.fan_lo, - sizeof(_prefs.fan_lo)) == sizeof(_prefs.fan_lo); - success = success && file.write((uint8_t *)&_prefs.fan_hi, - sizeof(_prefs.fan_hi)) == sizeof(_prefs.fan_hi); + success = success && writeField((uint8_t *)_prefs.fan_mode, + sizeof(_prefs.fan_mode)); + success = success && writeField((uint8_t *)&_prefs.fan_lo, + sizeof(_prefs.fan_lo)); + success = success && writeField((uint8_t *)&_prefs.fan_hi, + sizeof(_prefs.fan_hi)); #endif #if defined(RP2040_PLATFORM) && defined(ENABLE_WIFI_INTERFACE) - success = success && file.write((uint8_t *)_prefs.wifi_ssid, - sizeof(_prefs.wifi_ssid)) == sizeof(_prefs.wifi_ssid); - success = success && file.write((uint8_t *)_prefs.wifi_pwd, - sizeof(_prefs.wifi_pwd)) == sizeof(_prefs.wifi_pwd); + success = success && writeField((uint8_t *)_prefs.wifi_ssid, + sizeof(_prefs.wifi_ssid)); + success = success && writeField((uint8_t *)_prefs.wifi_pwd, + sizeof(_prefs.wifi_pwd)); #endif // Pack only the explicit persisted tail, never the class's padded layout. // memcpy retains the GPS field's established native byte representation. @@ -1387,8 +1400,12 @@ bool DataStore::savePrefs(const CompanionNodePrefs& _prefs, double node_lat, dou _prefs.usb_debug_enabled}; memcpy(tail + 6, &_prefs.gps_sync_interval_hours, sizeof(_prefs.gps_sync_interval_hours)); - success = success && file.write(tail, sizeof(tail)) == sizeof(tail); + success = success && writeField(tail, sizeof(tail)); +#if defined(STM32_PLATFORM) + success = success && image_length == sizeof(image) + && file.write(image, sizeof(image)) == sizeof(image); +#endif #if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM) || defined(ESP32_PLATFORM) || defined(RP2040_PLATFORM) success = file.commit(success); if (!success) MESH_DEBUG_PRINTLN("DataStore: atomic preferences write failed"); diff --git a/test/test_companion_prefs_image.py b/test/test_companion_prefs_image.py new file mode 100644 index 000000000..a8f769b6d --- /dev/null +++ b/test/test_companion_prefs_image.py @@ -0,0 +1,288 @@ +"""Check the explicit preference wire layout and bounded STM32 staging.""" +from pathlib import Path +import os +import subprocess +import tempfile +import unittest + +from test_companion_preferences_transaction import HARNESS, esp_recovery_helpers +from test_radio_receive_contract import method + +ROOT = Path(__file__).resolve().parents[1] + +# Published field order and sizes, independent of the implementation's emitter +# and the class's in-memory member order or padding. None represents zero pad. +WIRE_FIELDS = ( + ('airtime_factor', 4), ('node_name', 32), (None, 4), + ('@lat', 8), ('@lon', 8), ('freq', 4), ('sf', 1), ('cr', 1), + ('client_repeat', 1), ('manual_add_contacts', 1), ('bw', 4), + ('tx_power_dbm', 1), ('telemetry_mode_base', 1), ('telemetry_mode_loc', 1), + ('telemetry_mode_env', 1), ('rx_delay_base', 4), ('advert_loc_policy', 1), + ('multi_acks', 1), ('path_hash_mode', 1), (None, 1), ('ble_pin', 4), + ('buzzer_quiet', 1), ('gps_enabled', 1), ('gps_interval', 4), + ('autoadd_config', 1), ('autoadd_max_hops', 1), ('rx_boosted_gain', 1), + ('default_scope_name', 31), ('default_scope_key', 16), + ('radio_fem_rxgain', 1), ('radio_fem_rxgain_override', 1), + ('vibe_quiet', 1), ('radio_fem_txgain', 1), ('rx_powersaving_enabled', 1), + ('rx_ps_rx_us', 4), ('rx_ps_sleep_us', 4), ('rx_ps_level', 1), + ('rx_ps_preamble', 1), ('powersaving_enabled', 1), ('wifi_enabled', 1), + ('powersaving_policy_version', 1), ('usb_logging_enabled', 1), + ('bluetooth_name', 32), ('display_rotation_degrees', 2), ('cad_enabled', 1), + ('cad_scan_timeout_ms', 2), ('cad_retry_delay_ms', 2), + ('cad_max_duration_ms', 2), ('bluetooth_mac_mode', 1), ('bluetooth_mac', 6), + ('bluetooth_stealth_peer_type', 1), ('bluetooth_stealth_peer', 6), + ('bluetooth_stealth_mode', 1), ('tx_delay_factor', 4), + ('direct_tx_delay_factor', 4), ('interference_threshold', 1), + ('agc_reset_interval', 1), ('tz_offset', 1), +) +TAIL_FIELDS = ( + ('flood_retry_attempts', 1), ('flood_retry_max_path', 1), + ('flood_retry_group_max_path', 1), ('flood_retry_advert_enabled', 1), + ('one_key_dm_enabled', 1), ('bluetooth_enabled', 1), + ('gps_sync_interval_hours', 2), ('usb_debug_enabled', 1), +) +OPTIONAL_FIELDS = ( + ('defined(TBEAM_1W)', (('fan_mode', 5), ('fan_lo', 1), ('fan_hi', 1))), + ('defined(RP2040_PLATFORM) && defined(ENABLE_WIFI_INTERFACE)', + (('wifi_ssid', 33), ('wifi_pwd', 64))), +) + +TESTS = r''' +#include + +static void seed(CompanionNodePrefs& prefs, uint32_t& random) { + auto fill = [&](void* destination, size_t size) { + auto* bytes = static_cast(destination); + for (size_t i = 0; i < size; ++i) { + random = random * 1664525u + 1013904223u; + bytes[i] = static_cast(random >> 24); + } + }; + @SEED@ +} + +static std::vector golden(const CompanionNodePrefs& prefs, + double lat, double lon) { + std::vector bytes; + auto append = [&](const void* data, size_t size) { + const auto* first = static_cast(data); + bytes.insert(bytes.end(), first, first + size); + }; + @GOLDEN@ +#if defined(TBEAM_1W) + assert(bytes.size() == 242); +#elif defined(RP2040_PLATFORM) && defined(ENABLE_WIFI_INTERFACE) + assert(bytes.size() == 332); +#else + assert(bytes.size() == 235); +#endif + return bytes; +} + +static void unchanged(const DataStore& store, + const std::vector& before) { + assert(store.fs.files.at("/new_prefs") == before); + assert(!store.fs.exists("/new_prefs.tmp")); +} + +int main() { + uint32_t random = 0x31415926; + unsigned comparisons = 0; + for (unsigned trial = 0; trial < 512; ++trial) { + CompanionNodePrefs prefs; + // Exercise every persisted byte, not a memcpy of the nontrivial class. + // Raw invalid values are intentionally retained by the writer; validation + // and migration remain the loader/CLI's existing responsibility. + seed(prefs, random); + DataStore store; + assert(store.savePrefs(prefs, 47.125, -122.25)); + assert(store.fs.files.at("/new_prefs") == golden(prefs, 47.125, -122.25)); + assert(!store.fs.exists("/new_prefs.tmp")); + ++comparisons; + } + + CompanionNodePrefs original; + strcpy(original.node_name, "durable image"); + original.freq = 915.25f; original.ble_pin = 123456; + original.bluetooth_enabled = 1; original.usb_debug_enabled = 1; + original.gps_sync_interval_hours = 336; + DataStore initial; + assert(initial.savePrefs(original, 47.125, -122.25)); + const auto before = golden(original, 47.125, -122.25); + assert(initial.fs.files.at("/new_prefs") == before); + CompanionNodePrefs changed; + assert(changed.copyPersistedValuesFrom(original)); + strcpy(changed.node_name, "replacement image"); + changed.freq = 910.5f; changed.usb_debug_enabled = 0; + changed.gps_sync_interval_hours = 24; + const auto after = golden(changed, 42.25, -121.125); + + // Every possible short write and readback, including every tail byte, + // must preserve the old durable image. STM32 issues only one image write; + // the other supported platforms preserve their scalar-write path. + for (size_t quota = 0; quota < before.size(); ++quota) { + DataStore write; + write.fs.files["/new_prefs"] = before; + write.fs.fail_write_after = static_cast(quota); + assert(!write.savePrefs(changed, 42.25, -121.125)); + unchanged(write, before); + write.fs.fail_write_after = -1; + assert(write.savePrefs(changed, 42.25, -121.125)); + assert(write.fs.files.at("/new_prefs") == after); + DataStore read; + read.fs.files["/new_prefs"] = before; + read.fs.fail_read_after = static_cast(quota); + assert(!read.savePrefs(changed, 42.25, -121.125)); + unchanged(read, before); + ++comparisons; + } + for (unsigned fault = 0; fault < 3; ++fault) { + DataStore store; + store.fs.files["/new_prefs"] = before; + if (fault == 0) store.fs.fail_write_open = true; + if (fault == 1) store.fs.fail_write = true; + if (fault == 2) store.fs.fail_read_open = true; + assert(!store.savePrefs(changed, 42.25, -121.125)); + unchanged(store, before); + ++comparisons; + } +#if defined(STM32_PLATFORM) || defined(NRF52_PLATFORM) + const unsigned rename_steps = 1; +#else + const unsigned rename_steps = 2; +#endif + for (unsigned failure = 1; failure <= rename_steps; ++failure) { + DataStore store; + store.fs.files["/new_prefs"] = before; + store.fs.fail_rename = static_cast(failure); + assert(!store.savePrefs(changed, 42.25, -121.125)); + unchanged(store, before); + ++comparisons; + } + assert(initial.savePrefs(changed, 42.25, -121.125)); + CompanionNodePrefs loaded; + double lat = 0, lon = 0; + assert(initial.loadPrefs(loaded, lat, lon)); + assert(!strcmp(loaded.node_name, changed.node_name)); + assert(loaded.freq == changed.freq && loaded.ble_pin == changed.ble_pin); + assert(loaded.gps_sync_interval_hours == 24 && loaded.usb_debug_enabled == 0); + assert(lat == 42.25 && lon == -121.125); + +#if defined(STM32_PLATFORM) + // A future field or wrong staging capacity must fail closed, not overrun + // the stack or silently publish a truncated/extra-byte format. + for (bool undersized : {false, true}) { + DataStore store; + store.fs.files["/new_prefs"] = before; + assert(!(undersized ? store.savePrefsTooSmall(changed, lat, lon) + : store.savePrefsTooLarge(changed, lat, lon))); + unchanged(store, before); + ++comparisons; + } +#endif + printf("PASS: %u independent wire/fault comparisons\n", comparisons); +} +''' + + +def field_code(rows, seed=False): + result = [] + for name, size in rows: + if seed: + if name is not None and not name.startswith('@'): + result.append(f'fill(&prefs.{name}, sizeof(prefs.{name}));') + elif name is None: + result.append(f'bytes.insert(bytes.end(), {size}, uint8_t(0));') + else: + value = name[1:] if name.startswith('@') else 'prefs.' + name + result.append(f'static_assert(sizeof({value}) == {size}, "published field size");') + result.append(f'append(&{value}, {size});') + return '\n '.join(result) + + +class CompanionPrefsImageTests(unittest.TestCase): + def test_explicit_wire_layout_and_atomic_staging(self): + source = (ROOT / 'examples/companion_radio/DataStore.cpp').read_text() + save = method(source, 'bool DataStore::savePrefs(') + methods = esp_recovery_helpers(source) + '\n'.join( + method(source, signature) for signature in ( + 'bool DataStore::loadPrefs(', 'bool DataStore::loadPrefsInt(') + ) + '\n' + save + for suffix, capacity in (('TooSmall', 234), ('TooLarge', 236)): + variant = save.replace('DataStore::savePrefs(', 'DataStore::savePrefs' + suffix + '(', 1) + self.assertIn('uint8_t image[235];', variant) + variant = variant.replace('uint8_t image[235];', f'uint8_t image[{capacity}];', 1) + methods += '\n#if defined(STM32_PLATFORM)\n' + variant + '\n#endif\n' + code = HARNESS.split('int main(')[0].replace('@METHODS@', methods) + code = code.replace(' bool savePrefs(const CompanionNodePrefs&, double, double);', + ' bool savePrefs(const CompanionNodePrefs&, double, double);\n' + ' bool savePrefsTooSmall(const CompanionNodePrefs&, double, double);\n' + ' bool savePrefsTooLarge(const CompanionNodePrefs&, double, double);') + self.assertEqual(sum(size for _, size in WIRE_FIELDS), 226) + self.assertEqual(sum(size for _, size in TAIL_FIELDS), 9) + generated = {} + for seed in (False, True): + rows = [field_code(WIRE_FIELDS, seed)] + for condition, fields in OPTIONAL_FIELDS: + rows.append('#if ' + condition + '\n' + field_code(fields, seed) + '\n#endif') + rows.append(field_code(TAIL_FIELDS, seed)) + generated['@SEED@' if seed else '@GOLDEN@'] = '\n '.join(rows) + tests = TESTS + for placeholder, value in generated.items(): + tests = tests.replace(placeholder, value) + with tempfile.TemporaryDirectory(prefix='meshcore-prefs-image-') as directory: + work = Path(directory) + (work / 'Utils.h').write_text('''#pragma once +#include +#include +namespace mesh { struct Utils { + static void printHex(Stream&,const uint8_t*,size_t){assert(false);} + static void fromHex(uint8_t*,size_t,const char*){assert(false);} +}; } +''') + (work / 'platform_shim.h').write_text('''#include +#include +inline char* utoa(unsigned int value,char* output,int base){ + if(base!=10)abort();sprintf(output,"%u",value);return output; +} +''') + transaction = (ROOT / 'src/helpers/ContactFileTransaction.h').read_text() + (work / 'ContactFileTransaction.h').write_text(transaction.replace( + '#include "IdentityStore.h"', '#include ')) + # Reuse the existing memory-filesystem boundary, adding only an + # observable open failure needed to exercise the actual writer. + fs = (ROOT / 'test/fixtures/radio_profiles/mocks/helpers/IdentityStore.h').read_text() + fs = fs.replace(' bool fail_write = false;', + ' bool fail_write = false, fail_write_open = false;') + fs = fs.replace(' if (*mode == \'w\') files[path].clear();', + ' if (*mode == \'w\' && fail_write_open) return {};\n' + ' if (*mode == \'w\') files[path].clear();') + (work / 'helpers').mkdir() + (work / 'helpers/IdentityStore.h').write_text(fs) + cpp = work / 'test.cpp' + cpp.write_text(code + tests) + for platform in ('STM32_PLATFORM', 'NRF52_PLATFORM', 'ESP32_PLATFORM', + 'RP2040_PLATFORM', 'ESP32_PLATFORM,TBEAM_1W', + 'RP2040_PLATFORM,ENABLE_WIFI_INTERFACE'): + with self.subTest(platform=platform): + binary = work / 'test' + sanitizers = [] if os.name == 'nt' else [ + '-fsanitize=address,undefined', '-fno-sanitize-recover=all', + '-fno-pie', '-no-pie'] + built = subprocess.run([os.environ.get('CXX', 'g++'), '-std=c++17', + *['-D' + flag + '=1' for flag in platform.split(',')], + *sanitizers, '-include', str(work / 'platform_shim.h'), + '-I', str(work), '-I', str(ROOT / 'test/fixtures/radio_profiles/mocks'), + '-I', str(ROOT / 'test/mocks'), '-I', str(ROOT / 'src'), + '-I', str(ROOT / 'src/helpers'), '-I', str(ROOT), str(cpp), + *[str(ROOT / 'src/helpers' / name) for name in ( + 'ConfigSerializer.cpp', 'DynamicConfigSerializer.cpp', + 'CommonRadioPrefs.cpp', 'TxtDataHelpers.cpp')], + '-o', str(binary)], capture_output=True, text=True) + self.assertEqual(built.returncode, 0, built.stdout + built.stderr) + ran = subprocess.run([str(binary)], capture_output=True, text=True) + self.assertEqual(ran.returncode, 0, ran.stdout + ran.stderr) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_companion_prefs_tail.py b/test/test_companion_prefs_tail.py index a3e27831b..68f57cd81 100644 --- a/test/test_companion_prefs_tail.py +++ b/test/test_companion_prefs_tail.py @@ -136,6 +136,14 @@ class CompanionPrefsTailTests(unittest.TestCase): tail_end = save.index('\n#if defined(NRF52_PLATFORM)', tail_start) legacy_save = save[:tail_start] + LEGACY_TAIL + save[tail_end:] legacy_save = legacy_save.replace('DataStore::savePrefs(', 'DataStore::savePrefsLegacy(', 1) + # The golden tail serializer must still issue the original scalar + # writes, including on STM32 where the production writer now stages + # an image. Its prefix emitter forwards directly to the same file. + emitter_start = legacy_save.index('#if defined(STM32_PLATFORM)\n // Keep the explicit wire field list') + emitter_end = legacy_save.index('\n uint8_t pad[8];', emitter_start) + legacy_save = legacy_save[:emitter_start] + ''' const auto writeField = [&file](const void* data, size_t size) -> bool { + return file.write(static_cast(data), size) == size; + };''' + legacy_save[emitter_end:] methods = esp_recovery_helpers(source) + '\n'.join(method(source, signature) for signature in ( 'bool DataStore::loadPrefs(', 'bool DataStore::loadPrefsInt(')) methods += '\n' + save + '\n' + legacy_save