Refactor: storage in separate component ausgelagert

This commit is contained in:
2025-12-11 00:56:54 +01:00
parent 707df025b8
commit 5fccab5aff
4 changed files with 10 additions and 2 deletions
+450
View File
@@ -0,0 +1,450 @@
// File: src/storage.c
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "esp_log.h"
#include "nvs_flash.h"
#include "nvs.h"
#include "storage.h"
#include "esp_system.h"
static const char *TAG = "storage";
// Namespace & Keys (intern)
#define NVS_NAMESPACE "wifi"
#define NVS_KEY_SSID "sta_ssid"
#define NVS_KEY_PASS "sta_pass"
#define NVS_KEY_DEVNAME "dev_name"
#define NVS_KEY_INFLUX_TOKEN "influx_token"
#define NVS_KEY_BUCKET "influx_bucket"
#define NVS_KEY_ORG "org_id"
#define NVS_KEY_SERVICE_URL "service_url"
// Werkseinstellungen
#define DEFAULT_ORG_ID "myorg"
#define DEFAULT_BUCKET "nanoPSX"
#define DEFAULT_INFLUX_TOKEN "0946c41441a85088b38d39da6ed06d75a"
#define DEFAULT_DEVNAME "Sensor"
static char* get_nvs_str(nvs_handle_t h, const char *key);
bool storage_load_device_name(char **out_devname) {
if (!out_devname) return false;
*out_devname = NULL;
nvs_handle_t h;
if (nvs_open(NVS_NAMESPACE, NVS_READONLY, &h) != ESP_OK) return false;
char *name = get_nvs_str(h, NVS_KEY_DEVNAME);
nvs_close(h);
if (!name) return false;
*out_devname = name;
return true;
}
esp_err_t storage_save_service_url(const char *url) {
nvs_handle_t h;
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &h);
if (err != ESP_OK) return err;
// Semantik wie bei anderen Feldern: "" => löschen
if (url && url[0] != '\0') {
err = nvs_set_str(h, NVS_KEY_SERVICE_URL, url);
} else {
esp_err_t e = nvs_erase_key(h, NVS_KEY_SERVICE_URL);
err = (e == ESP_ERR_NVS_NOT_FOUND) ? ESP_OK : e;
}
if (err == ESP_OK) err = nvs_commit(h);
nvs_close(h);
if (err == ESP_OK) {
ESP_LOGI(TAG, "Service-URL %s", (url && url[0]) ? "gespeichert" : "gelöscht");
} else {
ESP_LOGE(TAG, "Speichern Service-URL fehlgeschlagen: %s", esp_err_to_name(err));
}
return err;
}
bool storage_load_service_url(char **out_url) {
if (!out_url) return false;
*out_url = NULL;
nvs_handle_t h;
if (nvs_open(NVS_NAMESPACE, NVS_READONLY, &h) != ESP_OK) return false;
char *url = get_nvs_str(h, NVS_KEY_SERVICE_URL);
nvs_close(h);
if (!url) return false;
*out_url = url;
return true;
}
void storage_erase_service_url(void) {
(void)storage_save_service_url("");
}
// ---------- NVS Init ----------
esp_err_t storage_init(void) {
esp_err_t ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
ESP_ERROR_CHECK(nvs_flash_erase());
ret = nvs_flash_init();
}
if (ret == ESP_OK) {
ESP_LOGI(TAG, "NVS init OK");
} else {
ESP_LOGE(TAG, "NVS init failed: %s", esp_err_to_name(ret));
}
return ret;
}
// ---------- interne Helfer ----------
static esp_err_t nvs_set_str_or_erase(nvs_handle_t h, const char *key, const char *val) {
if (val && val[0] != '\0') {
return nvs_set_str(h, key, val);
} else {
esp_err_t e = nvs_erase_key(h, key);
return (e == ESP_ERR_NVS_NOT_FOUND) ? ESP_OK : e;
}
}
static char* get_nvs_str(nvs_handle_t h, const char *key) {
size_t need = 0;
if (nvs_get_str(h, key, NULL, &need) != ESP_OK || need == 0) return NULL;
char *buf = (char*)malloc(need);
if (!buf) return NULL;
if (nvs_get_str(h, key, buf, &need) != ESP_OK) {
free(buf);
return NULL;
}
return buf; // inkl. Nullterminator
}
static esp_err_t set_keep_or_erase(nvs_handle_t h, const char *key, const char *val) {
if (val == NULL) return ESP_OK; // nicht geändert
if (val[0] == '\0') { // explizit löschen -> fällt auf Default zurück
esp_err_t e = nvs_erase_key(h, key);
return (e == ESP_ERR_NVS_NOT_FOUND) ? ESP_OK : e;
}
return nvs_set_str(h, key, val); // neuen Wert setzen
}
// ---------- WLAN-Creds ----------
bool storage_load_wifi_creds(char **out_ssid, char **out_pass) {
if (!out_ssid || !out_pass) return false;
*out_ssid = *out_pass = NULL;
nvs_handle_t h;
if (nvs_open(NVS_NAMESPACE, NVS_READONLY, &h) != ESP_OK) return false;
size_t need = 0;
// SSID
if (nvs_get_str(h, NVS_KEY_SSID, NULL, &need) != ESP_OK || need == 0) {
nvs_close(h);
return false;
}
char *ssid = (char*)malloc(need);
if (!ssid) { nvs_close(h); return false; }
if (nvs_get_str(h, NVS_KEY_SSID, ssid, &need) != ESP_OK) {
free(ssid); nvs_close(h); return false;
}
// PASS
need = 0;
if (nvs_get_str(h, NVS_KEY_PASS, NULL, &need) != ESP_OK || need == 0) {
free(ssid); nvs_close(h); return false;
}
char *pass = (char*)malloc(need);
if (!pass) { free(ssid); nvs_close(h); return false; }
if (nvs_get_str(h, NVS_KEY_PASS, pass, &need) != ESP_OK) {
free(ssid); free(pass); nvs_close(h); return false;
}
nvs_close(h);
*out_ssid = ssid;
*out_pass = pass;
return true;
}
esp_err_t storage_save_wifi_creds(const char *ssid, const char *pass) {
if (!ssid || !pass) return ESP_ERR_INVALID_ARG;
// idempotent schreiben
char *cur_s = NULL, *cur_p = NULL;
bool have = storage_load_wifi_creds(&cur_s, &cur_p);
bool same = have && strcmp(cur_s, ssid) == 0 && strcmp(cur_p, pass) == 0;
if (cur_s) free(cur_s);
if (cur_p) free(cur_p);
if (same) {
ESP_LOGI(TAG, "Creds identisch, kein erneutes Speichern.");
return ESP_OK;
}
nvs_handle_t h;
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &h);
if (err != ESP_OK) return err;
ESP_ERROR_CHECK_WITHOUT_ABORT(nvs_set_str(h, NVS_KEY_SSID, ssid));
ESP_ERROR_CHECK_WITHOUT_ABORT(nvs_set_str(h, NVS_KEY_PASS, pass));
err = nvs_commit(h);
nvs_close(h);
if (err == ESP_OK) {
ESP_LOGI(TAG, "Creds gespeichert: SSID='%s' (Passwort %zu Zeichen)", ssid, strlen(pass));
} else {
ESP_LOGE(TAG, "nvs_commit failed: %s", esp_err_to_name(err));
}
return err;
}
// ---------- Device/Influx-Infos (generisch speichern) ----------
esp_err_t storage_save_device_info(const char *devicename,
const char *token,
const char *bucket,
const char *org) {
nvs_handle_t h;
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &h);
if (err != ESP_OK) return err;
ESP_ERROR_CHECK_WITHOUT_ABORT(nvs_set_str_or_erase(h, NVS_KEY_DEVNAME, devicename));
ESP_ERROR_CHECK_WITHOUT_ABORT(nvs_set_str_or_erase(h, NVS_KEY_INFLUX_TOKEN, token));
ESP_ERROR_CHECK_WITHOUT_ABORT(nvs_set_str_or_erase(h, NVS_KEY_BUCKET, bucket));
ESP_ERROR_CHECK_WITHOUT_ABORT(nvs_set_str_or_erase(h, NVS_KEY_ORG, org));
err = nvs_commit(h);
nvs_close(h);
if (err == ESP_OK) {
ESP_LOGI(TAG, "Deviceinfo gespeichert: name='%s', token_len=%d",
devicename ? devicename : "",
token ? (int)strlen(token) : 0);
} else {
ESP_LOGE(TAG, "nvs_commit failed: %s", esp_err_to_name(err));
}
return err;
}
// ---------- Werkseinstellung + effektive Influx-Konfig ----------
bool storage_get_effective_influx(char **out_org, char **out_bucket, char **out_token) {
if (!out_org || !out_bucket || !out_token) return false;
*out_org = *out_bucket = *out_token = NULL;
nvs_handle_t h;
bool have_nvs = (nvs_open(NVS_NAMESPACE, NVS_READONLY, &h) == ESP_OK);
char *org = NULL, *bucket = NULL, *token = NULL;
if (have_nvs) {
org = get_nvs_str(h, NVS_KEY_ORG);
bucket = get_nvs_str(h, NVS_KEY_BUCKET);
token = get_nvs_str(h, NVS_KEY_INFLUX_TOKEN);
nvs_close(h);
}
if (!org) org = strdup(DEFAULT_ORG_ID);
if (!bucket) bucket = strdup(DEFAULT_BUCKET);
if (!token) token = strdup(DEFAULT_INFLUX_TOKEN);
if (!org || !bucket || !token) {
free(org); free(bucket); free(token);
return false;
}
*out_org = org; *out_bucket = bucket; *out_token = token;
return true;
}
// Speichert nur, wenn sich mind. ein übergebenes Feld ändert
// NULL = Feld nicht angefasst (behalten)
// "" = löschen (fällt auf Werkseinstellung zurück)
esp_err_t storage_save_influx_softap(const char *org, const char *bucket, const char *token) {
char *cur_org = NULL, *cur_bucket = NULL, *cur_token = NULL;
if (!storage_get_effective_influx(&cur_org, &cur_bucket, &cur_token)) {
ESP_LOGE(TAG, "cannot get effective influx config");
return ESP_FAIL;
}
// Wenn nichts übergeben wurde, ist nichts zu tun
if (!org && !bucket && !token) {
free(cur_org); free(cur_bucket); free(cur_token);
ESP_LOGI(TAG, "SoftAP: keine geänderten Felder.");
return ESP_OK;
}
bool changed = false;
if (org != NULL && strcmp(org, cur_org) != 0) changed = true;
if (bucket != NULL && strcmp(bucket, cur_bucket) != 0) changed = true;
if (token != NULL && strcmp(token, cur_token) != 0) changed = true;
free(cur_org); free(cur_bucket); free(cur_token);
if (!changed) {
ESP_LOGI(TAG, "SoftAP: keine Änderungen – nichts zu speichern.");
return ESP_OK;
}
nvs_handle_t h;
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &h);
if (err != ESP_OK) return err;
ESP_ERROR_CHECK_WITHOUT_ABORT(set_keep_or_erase(h, NVS_KEY_ORG, org));
ESP_ERROR_CHECK_WITHOUT_ABORT(set_keep_or_erase(h, NVS_KEY_BUCKET, bucket));
ESP_ERROR_CHECK_WITHOUT_ABORT(set_keep_or_erase(h, NVS_KEY_INFLUX_TOKEN, token));
err = nvs_commit(h);
nvs_close(h);
if (err == ESP_OK) {
ESP_LOGI(TAG, "SoftAP: Influx-Konfig gespeichert.");
} else {
ESP_LOGE(TAG, "nvs_commit failed: %s", esp_err_to_name(err));
}
return err;
}
void storage_factory_reset_influx(void) {
nvs_handle_t h;
if (nvs_open(NVS_NAMESPACE, NVS_READWRITE, &h) != ESP_OK) return;
nvs_erase_key(h, NVS_KEY_ORG);
nvs_erase_key(h, NVS_KEY_BUCKET);
nvs_erase_key(h, NVS_KEY_INFLUX_TOKEN);
nvs_commit(h);
nvs_close(h);
ESP_LOGI(TAG, "Influx-Keys gelöscht – Werkseinstellungen aktiv beim nächsten Use.");
}
void storage_debug_dump(void) {
// WLAN
char *ssid = NULL, *pass = NULL;
if (storage_load_wifi_creds(&ssid, &pass)) {
ESP_LOGI(TAG, "DUMP WLAN: SSID='%s', PASS_LEN=%d",
ssid ? ssid : "<null>", pass ? (int)strlen(pass) : -1);
free(ssid); free(pass);
} else {
ESP_LOGI(TAG, "DUMP WLAN: keine STA-Credentials gespeichert.");
}
// Influx (effektiv = NVS oder Defaults)
char *org = NULL, *bucket = NULL, *token = NULL;
if (storage_get_effective_influx(&org, &bucket, &token)) {
// Token maskieren
const char *t = token ? token : "";
int n = (int)strlen(t);
char masked[80] = {0};
if (n <= 8) {
snprintf(masked, sizeof(masked), "%s", t);
} else {
int head = 4, tail = 4;
int stars = n - head - tail;
if (stars < 0) stars = 0;
snprintf(masked, sizeof(masked), "%.*s%.*s%.*s",
head, t,
stars, "****************************************",
tail, t + n - tail);
}
ESP_LOGI(TAG, "DUMP Influx: org='%s', bucket='%s', token='%s' (len=%d)",
org ? org : "", bucket ? bucket : "", masked, n);
free(org); free(bucket); free(token);
} else {
ESP_LOGW(TAG, "DUMP Influx: konnte effektive Konfiguration nicht lesen.");
}
// Device-Name + Service-URL in einem NVS-Handle lesen
nvs_handle_t h;
if (nvs_open(NVS_NAMESPACE, NVS_READONLY, &h) == ESP_OK) {
// Device-Name
size_t need = 0;
if (nvs_get_str(h, NVS_KEY_DEVNAME, NULL, &need) == ESP_OK && need > 0) {
char *dev = (char*)malloc(need);
if (dev && nvs_get_str(h, NVS_KEY_DEVNAME, dev, &need) == ESP_OK) {
ESP_LOGI(TAG, "DUMP Device: name='%s'", dev);
} else {
ESP_LOGI(TAG, "DUMP Device: name=<read error>");
}
if (dev) free(dev);
} else {
ESP_LOGI(TAG, "DUMP Device: name=<nicht gesetzt>");
}
// Service-URL
need = 0;
if (nvs_get_str(h, NVS_KEY_SERVICE_URL, NULL, &need) == ESP_OK && need > 0) {
char *url = (char*)malloc(need);
if (url && nvs_get_str(h, NVS_KEY_SERVICE_URL, url, &need) == ESP_OK) {
ESP_LOGI(TAG, "DUMP Service: url='%s'", url);
} else {
ESP_LOGI(TAG, "DUMP Service: url=<read error>");
}
if (url) free(url);
} else {
ESP_LOGI(TAG, "DUMP Service: url=<nicht gesetzt>");
}
nvs_close(h);
}
}
esp_err_t storage_save_device_name(const char *devicename) {
nvs_handle_t h;
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &h);
if (err != ESP_OK) return err;
// Semantik: NULL = nicht ändern, "" = löschen, sonst setzen
if (devicename != NULL) {
if (devicename[0] == '\0') {
esp_err_t e = nvs_erase_key(h, NVS_KEY_DEVNAME);
if (e != ESP_OK && e != ESP_ERR_NVS_NOT_FOUND) { nvs_close(h); return e; }
} else {
err = nvs_set_str(h, NVS_KEY_DEVNAME, devicename);
if (err != ESP_OK) { nvs_close(h); return err; }
}
err = nvs_commit(h);
} else {
err = ESP_OK; // nichts geändert
}
nvs_close(h);
if (err == ESP_OK) {
ESP_LOGI(TAG, "Device-Name %s",
(devicename == NULL) ? "unverändert"
: (devicename[0] == '\0') ? "gelöscht"
: "gesetzt");
}
return err;
}
// ---------- Device-Name (effektiv mit Default) ----------
bool storage_get_effective_device_name(char **out_devname) {
if (!out_devname) return false;
*out_devname = NULL;
char *name = NULL;
if (!storage_load_device_name(&name)) {
// kein Name im NVS -> Werkseinstellung nehmen
name = strdup(DEFAULT_DEVNAME);
if (!name) return false;
}
*out_devname = name; // malloc-String zurückgeben
return true;
}
esp_err_t storage_factory_reset_all(void) {
// Löscht die komplette NVS-Partition (alle Namespaces und Keys)
esp_err_t err = nvs_flash_erase();
if (err == ESP_OK) {
// Direkt danach kann bei Bedarf wieder initialisiert werden – wir rebooten aber ohnehin
ESP_LOGW(TAG, "FACTORY RESET: gesamte NVS-Partition gelöscht.");
} else {
ESP_LOGE(TAG, "FACTORY RESET: nvs_flash_erase() fehlgeschlagen: %s", esp_err_to_name(err));
}
return err;
}