#include <AuthSync.h>

Public Member Functions
	AuthSync (const String &serverBase)
	~AuthSync ()
bool	begin ()
bool	update ()
bool	preloadOffline ()
bool	isAuthorized (const String &uid)
void	dumpMemoryStats () const
void	setServerProbeResult (bool ok, unsigned long probeMillis)
uint32_t	getCardCount () const
size_t	getMemoryUsed () const

Static Public Attributes
static constexpr size_t	MAX_SAFE_CARDS = 200000UL
static constexpr size_t	MAX_SAFE_BYTES = (MAX_SAFE_CARDS + 7) / 8

Private Member Functions
bool	syncFromServer ()
bool	getCardAuthFromServer (const String &uid, int &card_id, bool &authorized)
void	addKnownAuth (const String &uid, bool allowed)
void	saveETagToNVS ()
void	loadETagFromNVS ()
bool	saveBitsetToFS (size_t bytes)
bool	loadBitsetFromFS ()
bool	saveAllowDenyToFS () const
bool	loadAllowDenyFromFS ()
bool	isBitSet (uint32_t id) const
void	setBit (uint32_t id) const
void	clearBit (uint32_t id) const
bool	writeByteAt (size_t idx, uint8_t val) const
bool	readByteAt (size_t idx, uint8_t &out) const

Static Private Member Functions
static uint64_t	hashUid (const String &s)
static size_t	calcBitsetBytes (uint32_t maxId)

Private Attributes
String	server_base
uint8_t *	authorized_bits = nullptr
uint32_t	max_card_id = 0
unsigned long	last_sync = 0
unsigned long	SYNC_INTERVAL = 60000
unsigned long	last_server_probe = 0
bool	server_last_ok = false
bool	serverPreviouslyUnreachable = false
Preferences	prefs_
bool	prefsOpen_ = false
std::vector< uint64_t >	allowHashes_
std::vector< uint64_t >	denyHashes_
String	last_etag

Detailed Description

Definition at line 9 of file AuthSync.h.

Constructor & Destructor Documentation

◆ AuthSync()

AuthSync::AuthSync ( const String & serverBase )

explicit

Definition at line 49 of file AuthSync.cpp.

                                           : server_base(serverBase) {
 
    authorized_bits = authorized_bits_storage;
}

References authorized_bits, anonymous_namespace{AuthSync.cpp}::authorized_bits_storage, and server_base.

Referenced by setup().

Here is the caller graph for this function:

◆ ~AuthSync()

AuthSync::~AuthSync ( )

Definition at line 54 of file AuthSync.cpp.

                    {
    // authorized_bits points at static storage — don't free. Reset pointer for safety.
    authorized_bits = nullptr;
    if (prefsOpen_) {
        prefs_.end();
        prefsOpen_ = false;
    }
}

References authorized_bits, prefs_, and prefsOpen_.

Member Function Documentation

◆ addKnownAuth()

void AuthSync::addKnownAuth	(	const String &	uid,
		bool	allowed )

private

Definition at line 471 of file AuthSync.cpp.

                                                           {
    // Learn a card's authorization status for offline use by
 
    const uint64_t h = hashUid(uid);
    // Ensure sorted insert - helper lambda
    auto insert_sorted = [](std::vector<uint64_t>& vec, uint64_t val){
        const auto it = std::lower_bound(vec.begin(), vec.end(), val);
        if (it == vec.end() || *it != val) vec.insert(it, val);
    };
 
    if (allowed) {
        // Remove from deny if present
        const auto it = std::lower_bound(denyHashes_.begin(), denyHashes_.end(), h);
        if (it != denyHashes_.end() && *it == h) denyHashes_.erase(it);
        insert_sorted(allowHashes_, h);
    } else {
        const auto it = std::lower_bound(allowHashes_.begin(), allowHashes_.end(), h);
        if (it != allowHashes_.end() && *it == h) allowHashes_.erase(it);
        insert_sorted(denyHashes_, h);
    }
    saveETagToNVS();
}

References hashUid(), and saveETagToNVS().

Referenced by isAuthorized().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ begin()

bool AuthSync::begin ( )

Definition at line 120 of file AuthSync.cpp.

                     {
    if (!prefsOpen_) {
        prefsOpen_ = prefs_.begin("auth", false);
    }
    if (prefsOpen_) {
        loadETagFromNVS();
    }
    // Try to load a previously saved bitset snapshot from filesystem
    if (LittleFS.begin()) {
        loadBitsetFromFS();
    }
    return syncFromServer();
}

References loadBitsetFromFS(), loadETagFromNVS(), prefs_, prefsOpen_, and syncFromServer().

Referenced by setup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calcBitsetBytes()

size_t AuthSync::calcBitsetBytes ( uint32_t maxId )

staticprivate

Definition at line 64 of file AuthSync.cpp.

                                               {
    // bits = maxId + 1
    const size_t bits = (size_t)maxId + 1;
    if (bits == 0) return 0;
    if (bits > std::numeric_limits<size_t>::max() - 7) return 0;
    return (bits + 7) / 8;
}

Referenced by dumpMemoryStats(), getMemoryUsed(), readByteAt(), syncFromServer(), and writeByteAt().

Here is the caller graph for this function:

◆ clearBit()

void AuthSync::clearBit ( uint32_t id ) const

private

Definition at line 111 of file AuthSync.cpp.

                                         {
    if (!authorized_bits) return;//buffer is initialized
    if (id > max_card_id) return;//bounds check
    const size_t idx = (size_t)id >> 3; //divide by 8
    const uint8_t bit = id & 7;
    authorized_bits[idx] &= ~(1u << bit);
}

References authorized_bits, and max_card_id.

◆ dumpMemoryStats()

void AuthSync::dumpMemoryStats ( ) const

Definition at line 649 of file AuthSync.cpp.

                                     {
    // Print free heap
    const size_t freeHeap = esp_get_free_heap_size();
    const size_t largest = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT);
    Serial.printf("[AuthSync] freeHeap=%u largestFreeBlock=%u\n", static_cast<unsigned>(freeHeap), static_cast<unsigned>(largest));
 
    // Hash vectors
    Serial.printf("[AuthSync] allowHashes entries=%u bytes=%u\n", static_cast<unsigned>(allowHashes_.size()), static_cast<unsigned>(allowHashes_.size() * sizeof(uint64_t)));
    Serial.printf("[AuthSync] denyHashes  entries=%u bytes=%u\n", static_cast<unsigned>(denyHashes_.size()), static_cast<unsigned>(denyHashes_.size() * sizeof(uint64_t)));
 
    // Bitset usage
    const size_t bitBytes = calcBitsetBytes(max_card_id);
    Serial.printf("[AuthSync] max_card_id=%u bitset_bytes=%u MAX_SAFE_BYTES=%u\n", max_card_id, static_cast<unsigned>(bitBytes), static_cast<unsigned>(MAX_SAFE_BYTES));
}

References calcBitsetBytes(), max_card_id, and MAX_SAFE_BYTES.

Referenced by setup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getCardAuthFromServer()

bool AuthSync::getCardAuthFromServer	(	const String &	uid,
		int &	card_id,
		bool &	authorized )

private

Definition at line 193 of file AuthSync.cpp.

                                                                                      {
    card_id = -1;
    authorized = false;
    // Guard: need WiFi and a configured server base
    if (WiFi.status() != WL_CONNECTED || server_base.length() == 0) return false;
 
    // Backoff: only apply if we've actually probed before (last_server_probe != 0)
    if (!server_last_ok && last_server_probe != 0 && (millis() - last_server_probe) < 10000) {
        return false; // use offline cache immediately
    }
 
    // Periodic lightweight server status probe (cached) to avoid expensive lookups when server down
    if (millis() - last_server_probe > 5000 || last_server_probe == 0) {
        last_server_probe = millis();
        HTTPClient ping;
        // Further reduce probe timeout to minimize per-scan delay when offline.
        // A very short timeout risks false negatives on a slow network; tune if needed.
        ping.setTimeout(250); // was 1000ms
        ping.begin(server_base + "/api/status");
        const int sc = ping.GET();
        ping.end();
        server_last_ok = (sc == 200);
        if (!server_last_ok) {
            Serial.println("[AuthSync] Server status probe failed quickly; using offline cache");
            return false; // return immediately to avoid extra delay this scan
        }
    }
    if (!server_last_ok) return false;  // fallback to offline caches
 
    // Additional quick guard: if probe just failed we already returned
    HTTPClient http;
    http.setTimeout(1200); // reduce per-card lookup timeout
    http.begin(server_base + "/api/cards/" + uid);
    const int code = http.GET();
    if (code != 200) {
        http.end();
        return false;
    }
    String payload = http.getString();
    http.end();
 
    JsonDocument doc;
    const DeserializationError err = deserializeJson(doc, payload);
    if (err) return false;
 
    const bool exists = doc["exists"] | false;
    if (!exists) return false;
    card_id = doc["card_id"] | -1;
    authorized = doc["authorized"] | false;
    return true;
}

References last_server_probe, server_base, and server_last_ok.

Referenced by isAuthorized().

Here is the caller graph for this function:

◆ getCardCount()

uint32_t AuthSync::getCardCount ( ) const

inline

Definition at line 40 of file AuthSync.h.

40{ return max_card_id + 1; }

References max_card_id.

◆ getMemoryUsed()

size_t AuthSync::getMemoryUsed ( ) const

inline

Definition at line 41 of file AuthSync.h.

41{ return calcBitsetBytes(max_card_id); }

References calcBitsetBytes(), and max_card_id.

Here is the call graph for this function:

◆ hashUid()

uint64_t AuthSync::hashUid ( const String & s )

staticprivate

Definition at line 40 of file AuthSync.cpp.

                                          {
    return HashUtils::hashUid(s);
  /*  String t = s;  // normalize to uppercase, trimmed
    t.trim();
    t.toUpperCase();
    //Normalise hash for whitespace or case differences
    return fnv1a64(reinterpret_cast<const uint8_t*>(t.c_str()), t.length());
*/}

References HashUtils::hashUid().

Referenced by addKnownAuth(), and isAuthorized().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isAuthorized()

bool AuthSync::isAuthorized ( const String & uid )

Definition at line 158 of file AuthSync.cpp.

                                             {
    // Compute and log hash for debugging/offline cache tracking
    const uint64_t h = hashUid(uid);
    Serial.printf("[AuthSync] UID: %s -> Hash: 0x%016llX\n", uid.c_str(), h);
 
    // Priority 1: Check local cache first (deny takes precedence)
    const bool denied = std::binary_search(denyHashes_.begin(), denyHashes_.end(), h);
    if (denied) {
        Serial.println("[AuthSync] Found in deny cache -> DENIED");
        return false;
    }
    const bool allowed = std::binary_search(allowHashes_.begin(), allowHashes_.end(), h);
    if (allowed) {
        Serial.println("[AuthSync] Found in allow cache -> AUTHORIZED");
        return true;
    }
 
    // Priority 2: Unknown card - query server if online
    Serial.println("[AuthSync] Unknown card; checking server...");
    if (WiFi.status() == WL_CONNECTED && server_base.length() > 0) {
        int card_id = -1;
        bool server_allowed = false;
        if (getCardAuthFromServer(uid, card_id, server_allowed)) {
            // Learn the server result for offline use next time
            addKnownAuth(uid, server_allowed);
            Serial.printf("[AuthSync] Server says: %s\n", server_allowed ? "AUTHORIZED" : "DENIED");
            return server_allowed;
        }
    }
 
    // Priority 3: Offline and unknown - deny by default
    Serial.println("[AuthSync] Offline + unknown -> DENIED by default");
    return false;
}

References addKnownAuth(), getCardAuthFromServer(), hashUid(), and server_base.

Referenced by loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isBitSet()

bool AuthSync::isBitSet ( uint32_t id ) const

private

Definition at line 93 of file AuthSync.cpp.

                                         {
    if (!authorized_bits) return false;
    if (id > max_card_id) return false;
    const size_t idx = (size_t)id >> 3;
    const uint8_t bit = id & 7;
    return ((authorized_bits[idx] >> bit) & 1) != 0;
}

References authorized_bits, and max_card_id.

◆ loadAllowDenyFromFS()

bool AuthSync::loadAllowDenyFromFS ( )

private

Definition at line 516 of file AuthSync.cpp.

                                   {
    if (!LittleFS.begin()) return false;
    const char *final = "/allow_deny.bin";
    if (!LittleFS.exists(final)) return false;
    File f = LittleFS.open(final, FILE_READ);
    if (!f) return false;
    if (f.size() < static_cast<int>(sizeof(uint32_t))*2) { f.close(); return false; }
    uint32_t an = 0, dn = 0;
    f.read(reinterpret_cast<uint8_t*>(&an), sizeof(an));
    f.read(reinterpret_cast<uint8_t*>(&dn), sizeof(dn));
    // Basic sanity check
    const size_t expected = sizeof(uint32_t)*2 + (size_t)an * sizeof(uint64_t) + (size_t)dn * sizeof(uint64_t);
    if ((size_t)f.size() < expected) { f.close(); return false; }
    allowHashes_.assign(an, 0);
    denyHashes_.assign(dn, 0);
    // Read hashes
    if (an) f.read(reinterpret_cast<uint8_t*>(allowHashes_.data()), an * sizeof(uint64_t));
    if (dn) f.read(reinterpret_cast<uint8_t*>(denyHashes_.data()), dn * sizeof(uint64_t));
    f.close();
    // Ensure sorted
    std::sort(allowHashes_.begin(), allowHashes_.end());
    std::sort(denyHashes_.begin(), denyHashes_.end());
    return true;
}

Referenced by loadETagFromNVS().

Here is the caller graph for this function:

◆ loadBitsetFromFS()

bool AuthSync::loadBitsetFromFS ( )

private

Definition at line 595 of file AuthSync.cpp.

                                {
    const char *final = "/bits.bin";
    if (!LittleFS.exists(final)) return false;
    File f = LittleFS.open(final, FILE_READ);
    if (!f) return false;
    const size_t bytes = f.size();
    if (bytes == 0 || bytes > MAX_SAFE_BYTES) {
        f.close();
        Serial.println("[AuthSync] Bitset file size invalid or too large");
        return false;
    }
    const size_t r = f.read(reinterpret_cast<uint8_t*>(authorized_bits), bytes);
    f.close();
    if (r != bytes) {
        Serial.println("[AuthSync] Failed to read full bitset from file");
        return false;
    }
    if (prefsOpen_) {
        max_card_id = prefs_.getUInt("max_id", (uint32_t)((bytes * 8) - 1));
    } else {
        max_card_id = (uint32_t)((bytes * 8) - 1);
    }
    Serial.printf("[AuthSync] Loaded bitset snapshot %u bytes, max_id=%u\n", static_cast<unsigned>(bytes), max_card_id);
    return true;
}

References authorized_bits, max_card_id, MAX_SAFE_BYTES, prefs_, and prefsOpen_.

Referenced by begin(), and preloadOffline().

Here is the caller graph for this function:

◆ loadETagFromNVS()

void AuthSync::loadETagFromNVS ( )

private

Definition at line 556 of file AuthSync.cpp.

                               {
    if (!prefsOpen_) return;
    // Restore persisted ETag if present
    if (prefs_.isKey("bitset_etag")) {
        last_etag = prefs_.getString("bitset_etag", "");
    } else {
        last_etag = "";
    }
    // Attempt to load allow/deny from LittleFS; if it fails leave vectors empty
    loadAllowDenyFromFS();
}

References last_etag, loadAllowDenyFromFS(), prefs_, and prefsOpen_.

Referenced by begin(), and preloadOffline().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ preloadOffline()

bool AuthSync::preloadOffline ( )

Definition at line 136 of file AuthSync.cpp.

                              {
    if (!prefsOpen_) {
        prefsOpen_ = prefs_.begin("auth", false);
    }
    if (prefsOpen_) {
        loadETagFromNVS();
        // Load filesystem snapshot if present
        if (LittleFS.begin()) {
            loadBitsetFromFS();
        }
        return true;
    }
    return false;
}

References loadBitsetFromFS(), loadETagFromNVS(), prefs_, and prefsOpen_.

Referenced by setup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ readByteAt()

bool AuthSync::readByteAt	(	size_t	idx,
		uint8_t &	out ) const

private

Definition at line 83 of file AuthSync.cpp.

                                                        {
    if (!authorized_bits) return false;
    const size_t bytes = calcBitsetBytes(max_card_id);
    if (bytes == 0) return false;
    if (idx >= bytes) return false;
    out = authorized_bits[idx];
    return true;
}

References authorized_bits, calcBitsetBytes(), and max_card_id.

Here is the call graph for this function:

◆ saveAllowDenyToFS()

bool AuthSync::saveAllowDenyToFS ( ) const

private

Definition at line 494 of file AuthSync.cpp.

                                       {
    if (!LittleFS.begin()) return false;
    const char *tmp = "/allow_deny.bin.tmp";
    const char *final = "/allow_deny.bin";
    File f = LittleFS.open(tmp, FILE_WRITE);
    if (!f) return false;
    // Write counts as 32-bit little-endian
    const uint32_t an = (uint32_t)allowHashes_.size();
    const uint32_t dn = (uint32_t)denyHashes_.size();
    f.write(reinterpret_cast<const uint8_t*>(&an), sizeof(an));
    f.write(reinterpret_cast<const uint8_t*>(&dn), sizeof(dn));
    if (an) f.write(reinterpret_cast<const uint8_t*>(allowHashes_.data()), an * sizeof(uint64_t));
    if (dn) f.write(reinterpret_cast<const uint8_t*>(denyHashes_.data()), dn * sizeof(uint64_t));
    f.close();
    LittleFS.remove(final);
    if (!LittleFS.rename(tmp, final)) {
        LittleFS.remove(tmp);
        return false;
    }
    return true;
}

Referenced by saveETagToNVS().

Here is the caller graph for this function:

◆ saveBitsetToFS()

bool AuthSync::saveBitsetToFS ( size_t bytes )

private

Definition at line 568 of file AuthSync.cpp.

                                          {
    if (bytes == 0) return false;
    const char *tmp = "/bits.bin.tmp";
    const char *final = "/bits.bin";
    File f = LittleFS.open(tmp, FILE_WRITE);
    if (!f) {
        Serial.println("[AuthSync] Failed to open tmp file for bitset");
        return false;
    }
    //removed redundant reinterpret_cast<const uint8_t*> from below
    const size_t written = f.write((authorized_bits), bytes);
    f.close();
    if (written != bytes) {
        Serial.println("[AuthSync] Failed to write full bitset to tmp file");
        LittleFS.remove(tmp);
        return false;
    }
    LittleFS.remove(final);
    if (!LittleFS.rename(tmp, final)) {
        Serial.println("[AuthSync] Failed to rename bitset tmp file");
        return false;
    }
    if (prefsOpen_) prefs_.putUInt("max_id", max_card_id);
    Serial.printf("[AuthSync] Saved bitset snapshot %u bytes\n", static_cast<unsigned>(bytes));
    return true;
}

References authorized_bits, max_card_id, prefs_, and prefsOpen_.

Referenced by syncFromServer().

Here is the caller graph for this function:

◆ saveETagToNVS()

void AuthSync::saveETagToNVS ( )

private

Definition at line 542 of file AuthSync.cpp.

                             {
    if (!prefsOpen_) return;
    // Persist last_etag only
    if (last_etag.length()) {
        prefs_.putString("bitset_etag", last_etag);
    } else {
        prefs_.remove("bitset_etag");
    }
    // Persist allow/deny vectors to LittleFS (best-effort - log on failure, no retry)
    if (!saveAllowDenyToFS()) {
        Serial.println("[AuthSync] Warning: failed to persist allow/deny to LittleFS");
    }
}

References last_etag, prefs_, prefsOpen_, and saveAllowDenyToFS().

Referenced by addKnownAuth(), and syncFromServer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setBit()

void AuthSync::setBit ( uint32_t id ) const

private

Definition at line 102 of file AuthSync.cpp.

                                       {
    if (!authorized_bits) return;//buffer is initialized
    if (id > max_card_id) return;//bounds check
    const size_t idx = (size_t)id >> 3;
    const uint8_t bit = id & 7;
    authorized_bits[idx] |= 1u << bit;
}

References authorized_bits, and max_card_id.

◆ setServerProbeResult()

void AuthSync::setServerProbeResult	(	bool	ok,
		unsigned long	probeMillis )

Definition at line 669 of file AuthSync.cpp.

                                                                      {
    server_last_ok = ok;
    last_server_probe = probeMillis;
}

References last_server_probe, and server_last_ok.

Referenced by serverCheckTimerCallback().

Here is the caller graph for this function:

◆ syncFromServer()

bool AuthSync::syncFromServer ( )

private

Definition at line 288 of file AuthSync.cpp.

                              {
    if (WiFi.status() != WL_CONNECTED || server_base.length() == 0)
        return false;
    // Backoff: only after a failed probe and not on the very first attempt (last_server_probe != 0)
    if (!server_last_ok && last_server_probe != 0 && (millis() - last_server_probe) < 10000) {
        Serial.println("[AuthSync] Backoff active; skipping sync");
        return false;
    }
 
    // Only perform an inline reachability probe on the very first sync attempt.
    // After the initial probe we rely on the external server-check timer
    // (NetworkTask) to update `server_last_ok` and `last_server_probe` so
    // we don't duplicate probes here.
    if (last_server_probe == 0) {
        // First-time probe: do a quick reachability check so the initial
        // sync (called from setup()) can proceed when no external timer has
        // yet run.
        last_server_probe = millis();
        HTTPClient ping;
        ping.setTimeout(1000); // short probe for initial sync
        ping.begin(server_base + "/api/status");
        const int sc = ping.GET();
        ping.end();
        server_last_ok = (sc == 200);
        if (!server_last_ok) {
            Serial.println("[AuthSync] Sync aborted: initial probe failed (server unreachable)");
            return false;
        }
    } else if (!server_last_ok) {
        // An external timer (NetworkTask) has already probed and reported the
        // server as unreachable — skip the sync to avoid redundant network calls.
        Serial.println("[AuthSync] Sync aborted: server unreachable (cached)");
        return false;
    }
 
    HTTPClient http;
    http.setTimeout(2000);  // shorter sync timeout
    http.begin(server_base + "/api/sync");
    // Send If-None-Match header if we have a saved ETag to allow 304 responses
    if (last_etag.length()) {
        http.addHeader("If-None-Match", last_etag);
    }
    const int code = http.GET();
 
    if (code == 304) {
        // Not modified — nothing to do. Update last_sync and return success.
        last_sync = millis();
        Serial.println("[AuthSync] Sync: 304 Not Modified — skipping update");
        http.end();
        return true;
    }
    if (code != 200) {
        Serial.printf("[AuthSync] Sync failed with code: %d\n", code);
        http.end();
        return false;
    }
 
    String payload = http.getString();
    http.end();
 
    JsonDocument doc;
    const DeserializationError err = deserializeJson(doc, payload);
    if (err) {
        Serial.printf("[AuthSync] JSON parse error: %s\n", err.c_str());
        return false;
    }
 
    // Extract new maximum card ID and bitset hex from server payload
    const uint32_t new_max = doc["max_id"] | 0;
    const String hex = doc["bits"].as<String>();
 
    // Save new ETag header from server (if returned)
    const String serverEtag = http.header("ETag");
    if (serverEtag.length()) {
        last_etag = serverEtag;
        if (prefsOpen_) prefs_.putString("bitset_etag", last_etag);
    }
 
    // Use the static storage; validate size fits
    const size_t bytes = calcBitsetBytes(new_max);
    if (bytes == 0 || bytes > MAX_SAFE_BYTES) {
        Serial.println("[AuthSync] Sync failed: requested bitset too large for static buffer");
        max_card_id = 0;
        return false;
    }
    // Zero only the required portion
    std::fill_n(authorized_bits, bytes, 0);
 
    // Decode the hex bitset payload (two characters per byte) into
    // the newly allocated buffer using the bounds-checked writer.
    for (size_t i = 0; i + 1 < hex.length(); i += 2) {
        String byteStr = hex.substring(i, i + 2);
        const auto v = static_cast<uint8_t>(strtol(byteStr.c_str(), nullptr, 16));
        if (!writeByteAt(i / 2, v)) break;
    }
 
    // Commit the new bitset and record the time of this successful sync.
    max_card_id = new_max;
    last_sync = millis();
 
    // Persist the bitset snapshot to filesystem for faster boot/offline use
    if (LittleFS.begin()) {
        saveBitsetToFS(bytes);
    }
 
    // Optionally refresh offline allow/deny UID hash lists when the
    // server includes arrays of UIDs. These are normalized, hashed,
    // de-duplicated, and then swapped into the in-memory caches.
    if (doc["allow"].is<JsonArray>() || doc["allow_uids"].is<JsonArray>() ||
        doc["deny"].is<JsonArray>()  || doc["deny_uids"].is<JsonArray>()) {
        std::vector<uint64_t> allowNew;
        std::vector<uint64_t> denyNew;
// Extract optional allow/deny UID arrays from the sync JSON, normalize + hash
// each UID into 64-bit values, and append to the new vectors.
        auto loadArray = [&](const char* key, std::vector<uint64_t>& out){
            const JsonVariant var = doc[key];
            if (!var.is<JsonArray>()) return;
            for (JsonVariant v : var.as<JsonArray>()) {
                String uid = v.as<const char*>();
                out.push_back(hashUid(uid));
            }
        };
//std::sort magic incantation
 
        loadArray("allow", allowNew);
        loadArray("allow_uids", allowNew);
        loadArray("deny", denyNew);
        loadArray("deny_uids", denyNew);
 
        std::sort(allowNew.begin(), allowNew.end());//
        allowNew.erase(std::unique(allowNew.begin(), allowNew.end()), allowNew.end());
        std::sort(denyNew.begin(), denyNew.end());
        denyNew.erase(std::unique(denyNew.begin(), denyNew.end()), denyNew.end());
 
        if (!allowNew.empty() || !denyNew.empty()) {
            allowHashes_.swap(allowNew);
            denyHashes_.swap(denyNew);
            saveETagToNVS();
            //It then saves the new vectors to NVS for persistence across reboots.
 
        }
    }
 
    // Log a compact summary of the sync result for debugging.
    Serial.printf("[AuthSync] Synced max_id=%u (%u bytes heap)\n", max_card_id, bytes);
    return true;
}

References authorized_bits, calcBitsetBytes(), last_etag, last_server_probe, last_sync, max_card_id, MAX_SAFE_BYTES, prefs_, prefsOpen_, saveBitsetToFS(), saveETagToNVS(), server_base, server_last_ok, and writeByteAt().

Referenced by begin(), and update().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update()

bool AuthSync::update ( )

Definition at line 151 of file AuthSync.cpp.

                      {
    if (millis() - last_sync > SYNC_INTERVAL) {
        return syncFromServer();
    }
    return true;
}

References last_sync, SYNC_INTERVAL, and syncFromServer().

Referenced by NetworkTask().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ writeByteAt()

bool AuthSync::writeByteAt	(	size_t	idx,
		uint8_t	val ) const

private

Definition at line 73 of file AuthSync.cpp.

                                                        {
    if (!authorized_bits) return false;
    const size_t bytes = calcBitsetBytes(max_card_id);
    if (bytes == 0) return false;
    if (idx >= bytes) return false;
    authorized_bits[idx] = val;
    return true;
}

References authorized_bits, calcBitsetBytes(), and max_card_id.

Referenced by syncFromServer().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ allowHashes_

std::vector<uint64_t> AuthSync::allowHashes_

private

Definition at line 71 of file AuthSync.h.

◆ authorized_bits

uint8_t* AuthSync::authorized_bits = nullptr

private

Definition at line 48 of file AuthSync.h.

Referenced by AuthSync(), clearBit(), isBitSet(), loadBitsetFromFS(), readByteAt(), saveBitsetToFS(), setBit(), syncFromServer(), writeByteAt(), and ~AuthSync().

◆ denyHashes_

std::vector<uint64_t> AuthSync::denyHashes_

private

Definition at line 72 of file AuthSync.h.

◆ last_etag

String AuthSync::last_etag

private

Definition at line 74 of file AuthSync.h.

Referenced by loadETagFromNVS(), saveETagToNVS(), and syncFromServer().

◆ last_server_probe

unsigned long AuthSync::last_server_probe = 0

private

Definition at line 53 of file AuthSync.h.

Referenced by getCardAuthFromServer(), setServerProbeResult(), and syncFromServer().

◆ last_sync

unsigned long AuthSync::last_sync = 0

private

Definition at line 50 of file AuthSync.h.

Referenced by syncFromServer(), and update().

◆ max_card_id

uint32_t AuthSync::max_card_id = 0

private

Definition at line 49 of file AuthSync.h.

Referenced by clearBit(), dumpMemoryStats(), getCardCount(), getMemoryUsed(), isBitSet(), loadBitsetFromFS(), readByteAt(), saveBitsetToFS(), setBit(), syncFromServer(), and writeByteAt().

◆ MAX_SAFE_BYTES

size_t AuthSync::MAX_SAFE_BYTES = (MAX_SAFE_CARDS + 7) / 8

staticconstexpr

Definition at line 19 of file AuthSync.h.

Referenced by dumpMemoryStats(), loadBitsetFromFS(), and syncFromServer().

◆ MAX_SAFE_CARDS

size_t AuthSync::MAX_SAFE_CARDS = 200000UL

staticconstexpr

Definition at line 17 of file AuthSync.h.

◆ prefs_

Preferences AuthSync::prefs_

private

Definition at line 69 of file AuthSync.h.

Referenced by begin(), loadBitsetFromFS(), loadETagFromNVS(), preloadOffline(), saveBitsetToFS(), saveETagToNVS(), syncFromServer(), and ~AuthSync().

◆ prefsOpen_

bool AuthSync::prefsOpen_ = false

private

Definition at line 70 of file AuthSync.h.

Referenced by begin(), loadBitsetFromFS(), loadETagFromNVS(), preloadOffline(), saveBitsetToFS(), saveETagToNVS(), syncFromServer(), and ~AuthSync().

◆ server_base

String AuthSync::server_base

private

Definition at line 44 of file AuthSync.h.

Referenced by AuthSync(), getCardAuthFromServer(), isAuthorized(), and syncFromServer().

◆ server_last_ok

bool AuthSync::server_last_ok = false

private

Definition at line 54 of file AuthSync.h.

Referenced by getCardAuthFromServer(), setServerProbeResult(), and syncFromServer().

◆ serverPreviouslyUnreachable

bool AuthSync::serverPreviouslyUnreachable = false

private

Definition at line 55 of file AuthSync.h.

◆ SYNC_INTERVAL

unsigned long AuthSync::SYNC_INTERVAL = 60000

private

Definition at line 51 of file AuthSync.h.

Referenced by update().

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AuthSync()

◆ ~AuthSync()

Member Function Documentation

◆ addKnownAuth()

◆ begin()

◆ calcBitsetBytes()

◆ clearBit()

◆ dumpMemoryStats()

◆ getCardAuthFromServer()

◆ getCardCount()

◆ getMemoryUsed()

◆ hashUid()

◆ isAuthorized()

◆ isBitSet()

◆ loadAllowDenyFromFS()

◆ loadBitsetFromFS()

◆ loadETagFromNVS()

◆ preloadOffline()

◆ readByteAt()

◆ saveAllowDenyToFS()

◆ saveBitsetToFS()

◆ saveETagToNVS()

◆ setBit()

◆ setServerProbeResult()

◆ syncFromServer()

◆ update()

◆ writeByteAt()

Member Data Documentation

◆ allowHashes_

◆ authorized_bits

◆ denyHashes_

◆ last_etag

◆ last_server_probe

◆ last_sync

◆ max_card_id

◆ MAX_SAFE_BYTES

◆ MAX_SAFE_CARDS

◆ prefs_

◆ prefsOpen_

◆ server_base

◆ server_last_ok

◆ serverPreviouslyUnreachable

◆ SYNC_INTERVAL