Reduce ESP ACL save metadata opens while preserving verified recovery

This commit is contained in:
mikecarper committed 2026-10-04 15:57:10 -07:00
1 parent 3f1252af28
commit 0e25a1f15e
6 files changed
+494 -51

No files matched your search

+55 -22
View File
@@ -13,8 +13,23 @@
static const uint8_t CONTACT_RECORD_VERSION_ALT_PATH = 1;
static const uint8_t EMPTY_OUT_PATH[MAX_PATH_SIZE] = {};
static File openRead(FILESYSTEM* fs, const char* filename) {
static File openRead(FILESYSTEM* fs, const char* filename,
bool* metadata_ok = nullptr) {
#if defined(ESP32_PLATFORM)
bool present = false;
if (!mesh::filePresence(fs, filename, present)) {
if (metadata_ok) *metadata_ok = false;
return mesh::emptyFile(fs);
}
if (!present) return mesh::emptyFile(fs);
File file = fs->open(filename);
if (!file && metadata_ok) *metadata_ok = false;
if (file && file.isDirectory()) file.close();
return file;
#else
(void)metadata_ok;
return mesh::openFileRead(fs, filename);
#endif
}
#if !defined(NRF52_PLATFORM)
@@ -27,9 +42,12 @@ static const size_t LEGACY_CONTACT_RECORD_SIZE =
static bool readPersistedClientPath(FILESYSTEM* fs,
const uint8_t pubkey[PUB_KEY_SIZE],
uint8_t* path_len,
uint8_t path[MAX_PATH_SIZE]) {
uint8_t path[MAX_PATH_SIZE],
bool* metadata_ok = nullptr) {
#if !defined(ESP32_PLATFORM)
if (!fs->exists(mesh::CLIENT_ACL_PRIMARY_PATH)) return false;
File file = openRead(fs, mesh::CLIENT_ACL_PRIMARY_PATH);
#endif
File file = openRead(fs, mesh::CLIENT_ACL_PRIMARY_PATH, metadata_ok);
if (!file) return false;
bool found = false;
@@ -87,10 +105,11 @@ static mesh::StoredClientPathView storedClientPathForSave(
FILESYSTEM* fs,
const ClientInfo* client,
uint8_t prior_path[MAX_PATH_SIZE],
uint8_t* prior_path_len) {
uint8_t* prior_path_len,
bool* metadata_ok = nullptr) {
const bool prior_exists = !client->out_path_is_persistable
&& readPersistedClientPath(
fs, client->id.pub_key, prior_path_len, prior_path);
fs, client->id.pub_key, prior_path_len, prior_path, metadata_ok);
return mesh::selectStoredClientPath(
client->out_path_is_persistable,
client->out_path_len,
@@ -132,25 +151,32 @@ static bool readMatches(File& file, const uint8_t* expected, size_t length) {
return true;
}
static bool validateContactsFileIntegrity(FILESYSTEM* fs,
const char* filename) {
File file = openRead(fs, filename);
if (!file) return false;
static mesh::ClientACLFileValidation validateContactsFileIntegrityChecked(
FILESYSTEM* fs, const char* filename) {
bool metadata_ok = true;
File file = openRead(fs, filename, &metadata_ok);
if (!metadata_ok) return mesh::ClientACLFileValidation::MetadataError;
if (!file) return mesh::ClientACLFileValidation::Invalid;
const size_t size = file.size();
const bool has_crc = size >= 8 && (size - 8) % CONTACT_RECORD_SIZE == 0;
// A backup means publication was interrupted or is being finalized. In that
// state a primary without its CRC trailer is a torn new image, not a legacy
// image, even when truncation lands exactly on a record-size multiple.
const bool crc_required = strcmp(filename, mesh::CLIENT_ACL_PRIMARY_PATH) == 0
&& fs->exists(mesh::CLIENT_ACL_BACKUP_PATH);
bool crc_required = false;
if (strcmp(filename, mesh::CLIENT_ACL_PRIMARY_PATH) == 0
&& !mesh::clientACLFilePresence(fs, mesh::CLIENT_ACL_BACKUP_PATH,
crc_required)) {
file.close();
return mesh::ClientACLFileValidation::MetadataError;
}
if (!has_crc && size % CONTACT_RECORD_SIZE != 0
&& size % LEGACY_CONTACT_RECORD_SIZE != 0) {
file.close();
return false;
return mesh::ClientACLFileValidation::Invalid;
}
if (!has_crc) {
file.close();
return !crc_required; // standalone legacy fixed-record image
return mesh::clientACLValidation(!crc_required); // standalone legacy image
}
uint32_t crc = 0xFFFFFFFFUL;
size_t remaining = size - 8;
@@ -159,7 +185,7 @@ static bool validateContactsFileIntegrity(FILESYSTEM* fs,
const size_t chunk = remaining < sizeof(buffer) ? remaining : sizeof(buffer);
if (file.read(buffer, chunk) != (int)chunk) {
file.close();
return false;
return mesh::ClientACLFileValidation::Invalid;
}
crc = mesh::updateClientACLCRC(crc, buffer, chunk);
remaining -= chunk;
@@ -172,7 +198,12 @@ static bool validateContactsFileIntegrity(FILESYSTEM* fs,
&& memcmp(magic, mesh::CLIENT_ACL_CRC_MAGIC, sizeof(magic)) == 0
&& stored_crc == (crc ^ 0xFFFFFFFFUL);
file.close();
return valid;
return mesh::clientACLValidation(valid);
}
static bool validateContactsFileIntegrity(FILESYSTEM* fs, const char* filename) {
return validateContactsFileIntegrityChecked(fs, filename)
== mesh::ClientACLFileValidation::Valid;
}
static bool verifyContactsFile(
@@ -197,10 +228,11 @@ static bool verifyContactsFile(
|| (filter && !filter(c))) continue;
uint8_t prior_path_len = OUT_PATH_UNKNOWN;
uint8_t prior_path[MAX_PATH_SIZE] = {};
bool metadata_ok = true;
const mesh::StoredClientPathView persisted_path =
storedClientPathForSave(
fs, c, prior_path, &prior_path_len);
matches = readMatches(file, c->id.pub_key, 32)
fs, c, prior_path, &prior_path_len, &metadata_ok);
matches = metadata_ok && readMatches(file, c->id.pub_key, 32)
&& readMatches(file, &c->permissions, 1)
&& readMatches(file, (uint8_t*)&c->extra.room.sync_since, 4)
&& readMatches(file, unused, sizeof(unused))
@@ -609,7 +641,7 @@ void ClientACL::load(FILESYSTEM* fs, const mesh::LocalIdentity& self_id) {
}
#if !defined(NRF52_PLATFORM)
if (!mesh::recoverClientACLFilesVerified(
_fs, validateContactsFileIntegrity)) {
_fs, validateContactsFileIntegrityChecked)) {
MESH_DEBUG_PRINTLN("ERROR: ClientACL::load could not recover contacts files");
return;
}
@@ -748,7 +780,7 @@ bool ClientACL::save(FILESYSTEM* fs, bool (*filter)(ClientInfo*)) {
mesh::AtomicFileWriter file(_fs, "/s_contacts");
#else
if (!mesh::recoverClientACLFilesVerified(
_fs, validateContactsFileIntegrity)) {
_fs, validateContactsFileIntegrityChecked)) {
MESH_DEBUG_PRINTLN("ERROR: ClientACL::save recovery is incomplete");
return false;
}
@@ -780,10 +812,11 @@ bool ClientACL::save(FILESYSTEM* fs, bool (*filter)(ClientInfo*)) {
success = success && (file.write(unused, 2) == 2);
uint8_t prior_path_len = OUT_PATH_UNKNOWN;
uint8_t prior_path[MAX_PATH_SIZE] = {};
bool metadata_ok = true;
const mesh::StoredClientPathView persisted_path =
storedClientPathForSave(
_fs, c, prior_path, &prior_path_len);
success = success
_fs, c, prior_path, &prior_path_len, &metadata_ok);
success = success && metadata_ok
&& (file.write(&persisted_path.encoded_path_len, 1) == 1);
success = success
&& (file.write(persisted_path.path, MAX_PATH_SIZE) == MAX_PATH_SIZE);
@@ -837,7 +870,7 @@ bool ClientACL::save(FILESYSTEM* fs, bool (*filter)(ClientInfo*)) {
return false;
}
success = mesh::publishVerifiedClientACLTemp(
_fs, true, validateContactsFileIntegrity);
_fs, true, validateContactsFileIntegrityChecked);
if (!success) {
MESH_DEBUG_PRINTLN("ERROR: ClientACL::save atomic publish failed");
}
+74 -29
View File
@@ -1,16 +1,44 @@
#pragma once
#if defined(ESP32_PLATFORM)
#include "FilePresence.h"
#endif
namespace mesh {
static const char CLIENT_ACL_PRIMARY_PATH[] = "/s_contacts";
static const char CLIENT_ACL_TEMP_PATH[] = "/s_contacts.tmp";
static const char CLIENT_ACL_BACKUP_PATH[] = "/s_contacts.bak";
// ESP ACL stores are mounted at /spiffs. Unlike FS::exists(), the metadata
// probe does not open/close the file and distinguishes absent from unreadable.
template <typename Filesystem>
bool clientACLFilePresence(Filesystem* fs, const char* path, bool& present) {
#if defined(ESP32_PLATFORM)
return filePresence(fs, path, present);
#else
present = fs->exists(path);
return true;
#endif
}
enum class ClientACLFileValidation { Invalid, Valid, MetadataError };
inline ClientACLFileValidation clientACLValidation(bool valid) {
return valid ? ClientACLFileValidation::Valid
: ClientACLFileValidation::Invalid;
}
inline ClientACLFileValidation clientACLValidation(ClientACLFileValidation valid) {
return valid;
}
template <typename Filesystem>
bool removeClientACLArtifact(Filesystem* fs, const char* path) {
if (!fs->exists(path)) return true;
bool present;
if (!clientACLFilePresence(fs, path, present)) return false;
if (!present) return true;
fs->remove(path);
return !fs->exists(path);
return clientACLFilePresence(fs, path, present) && !present;
}
// Recover the last published image after any power-loss boundary in the
@@ -18,7 +46,9 @@ bool removeClientACLArtifact(Filesystem* fs, const char* path) {
// if publication had not completed, the backup is restored instead.
template <typename Filesystem>
bool recoverClientACLFiles(Filesystem* fs) {
if (fs->exists(CLIENT_ACL_PRIMARY_PATH)) {
bool primary_exists, backup_exists;
if (!clientACLFilePresence(fs, CLIENT_ACL_PRIMARY_PATH, primary_exists)) return false;
if (primary_exists) {
// The primary is already authoritative. Cleanup is best-effort: a
// filesystem which cannot remove a stale artifact must not make the
// committed image appear unavailable.
@@ -26,7 +56,8 @@ bool recoverClientACLFiles(Filesystem* fs) {
removeClientACLArtifact(fs, CLIENT_ACL_BACKUP_PATH);
return true;
}
if (fs->exists(CLIENT_ACL_BACKUP_PATH)) {
if (!clientACLFilePresence(fs, CLIENT_ACL_BACKUP_PATH, backup_exists)) return false;
if (backup_exists) {
if (!fs->rename(CLIENT_ACL_BACKUP_PATH, CLIENT_ACL_PRIMARY_PATH)) {
return false;
}
@@ -38,25 +69,33 @@ bool recoverClientACLFiles(Filesystem* fs) {
template <typename Filesystem, typename Validator>
bool recoverClientACLFilesVerified(Filesystem* fs, Validator is_valid) {
if (fs->exists(CLIENT_ACL_PRIMARY_PATH)
&& is_valid(fs, CLIENT_ACL_PRIMARY_PATH)) {
// A validated primary remains authoritative even when stale-artifact
// cleanup is temporarily unavailable.
removeClientACLArtifact(fs, CLIENT_ACL_TEMP_PATH);
removeClientACLArtifact(fs, CLIENT_ACL_BACKUP_PATH);
return true;
}
if (fs->exists(CLIENT_ACL_BACKUP_PATH)
&& is_valid(fs, CLIENT_ACL_BACKUP_PATH)) {
if (!removeClientACLArtifact(fs, CLIENT_ACL_PRIMARY_PATH)
|| !fs->rename(CLIENT_ACL_BACKUP_PATH, CLIENT_ACL_PRIMARY_PATH)) {
return false;
bool primary_exists, backup_exists;
if (!clientACLFilePresence(fs, CLIENT_ACL_PRIMARY_PATH, primary_exists)) return false;
if (primary_exists) {
const auto result = clientACLValidation(is_valid(fs, CLIENT_ACL_PRIMARY_PATH));
if (result == ClientACLFileValidation::MetadataError) return false;
if (result == ClientACLFileValidation::Valid) {
// A validated primary remains authoritative even when stale-artifact
// cleanup is temporarily unavailable.
removeClientACLArtifact(fs, CLIENT_ACL_TEMP_PATH);
removeClientACLArtifact(fs, CLIENT_ACL_BACKUP_PATH);
return true;
}
removeClientACLArtifact(fs, CLIENT_ACL_TEMP_PATH);
return true;
}
return !fs->exists(CLIENT_ACL_PRIMARY_PATH)
&& !fs->exists(CLIENT_ACL_BACKUP_PATH)
if (!clientACLFilePresence(fs, CLIENT_ACL_BACKUP_PATH, backup_exists)) return false;
if (backup_exists) {
const auto result = clientACLValidation(is_valid(fs, CLIENT_ACL_BACKUP_PATH));
if (result == ClientACLFileValidation::MetadataError) return false;
if (result == ClientACLFileValidation::Valid) {
if (!removeClientACLArtifact(fs, CLIENT_ACL_PRIMARY_PATH)
|| !fs->rename(CLIENT_ACL_BACKUP_PATH, CLIENT_ACL_PRIMARY_PATH)) {
return false;
}
removeClientACLArtifact(fs, CLIENT_ACL_TEMP_PATH);
return true;
}
}
return !primary_exists && !backup_exists
&& removeClientACLArtifact(fs, CLIENT_ACL_TEMP_PATH);
}
@@ -66,9 +105,11 @@ bool publishVerifiedClientACLTemp(Filesystem* fs, bool temp_verified) {
removeClientACLArtifact(fs, CLIENT_ACL_TEMP_PATH);
return false;
}
if (fs->exists(CLIENT_ACL_BACKUP_PATH)) return false;
bool backup_exists, had_primary;
if (!clientACLFilePresence(fs, CLIENT_ACL_BACKUP_PATH, backup_exists)
|| backup_exists
|| !clientACLFilePresence(fs, CLIENT_ACL_PRIMARY_PATH, had_primary)) return false;
const bool had_primary = fs->exists(CLIENT_ACL_PRIMARY_PATH);
if (had_primary
&& !fs->rename(CLIENT_ACL_PRIMARY_PATH, CLIENT_ACL_BACKUP_PATH)) {
return false;
@@ -76,7 +117,9 @@ bool publishVerifiedClientACLTemp(Filesystem* fs, bool temp_verified) {
if (!fs->rename(CLIENT_ACL_TEMP_PATH, CLIENT_ACL_PRIMARY_PATH)) {
// Restore the last committed image immediately when possible. If this
// rename also fails, leave both artifacts for recoverClientACLFiles().
if (had_primary && !fs->exists(CLIENT_ACL_PRIMARY_PATH)) {
bool primary_exists;
if (had_primary && clientACLFilePresence(fs, CLIENT_ACL_PRIMARY_PATH, primary_exists)
&& !primary_exists) {
fs->rename(CLIENT_ACL_BACKUP_PATH, CLIENT_ACL_PRIMARY_PATH);
}
return false;
@@ -95,16 +138,18 @@ bool publishVerifiedClientACLTemp(Filesystem* fs, bool temp_verified,
removeClientACLArtifact(fs, CLIENT_ACL_TEMP_PATH);
return false;
}
if (fs->exists(CLIENT_ACL_BACKUP_PATH)) return false;
const bool had_primary = fs->exists(CLIENT_ACL_PRIMARY_PATH);
bool backup_exists, had_primary;
if (!clientACLFilePresence(fs, CLIENT_ACL_BACKUP_PATH, backup_exists)
|| backup_exists
|| !clientACLFilePresence(fs, CLIENT_ACL_PRIMARY_PATH, had_primary)) return false;
if (had_primary
&& !fs->rename(CLIENT_ACL_PRIMARY_PATH, CLIENT_ACL_BACKUP_PATH)) {
return false;
}
if (!fs->rename(CLIENT_ACL_TEMP_PATH, CLIENT_ACL_PRIMARY_PATH)
|| !is_valid(fs, CLIENT_ACL_PRIMARY_PATH)) {
removeClientACLArtifact(fs, CLIENT_ACL_PRIMARY_PATH);
if (had_primary) {
|| clientACLValidation(is_valid(fs, CLIENT_ACL_PRIMARY_PATH))
!= ClientACLFileValidation::Valid) {
if (removeClientACLArtifact(fs, CLIENT_ACL_PRIMARY_PATH) && had_primary) {
fs->rename(CLIENT_ACL_BACKUP_PATH, CLIENT_ACL_PRIMARY_PATH);
}
return false;