Bound STM32 Companion preference image writes

This commit is contained in:
mikecarper committed 2026-10-03 22:41:45 -07:00
1 parent 59e761262d
commit 54e5b0b996
4 files changed
+421 -107

No files matched your search

+1
View File
@@ -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
+124 -107
View File
@@ -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<const uint8_t*>(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");
+288
View File
@@ -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 <vector>
static void seed(CompanionNodePrefs& prefs, uint32_t& random) {
auto fill = [&](void* destination, size_t size) {
auto* bytes = static_cast<uint8_t*>(destination);
for (size_t i = 0; i < size; ++i) {
random = random * 1664525u + 1013904223u;
bytes[i] = static_cast<uint8_t>(random >> 24);
}
};
@SEED@
}
static std::vector<uint8_t> golden(const CompanionNodePrefs& prefs,
double lat, double lon) {
std::vector<uint8_t> bytes;
auto append = [&](const void* data, size_t size) {
const auto* first = static_cast<const uint8_t*>(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<uint8_t>& 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<int>(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<int>(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<int>(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 <Arduino.h>
#include <cassert>
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 <cstdlib>
#include <cstdio>
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 <helpers/IdentityStore.h>'))
# 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()
+8
View File
@@ -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<const uint8_t*>(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