Files
nanopsx_sen66/firmware/components/storage/src/storage.c
T

450 lines
15 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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;
}