// File: src/storage.c #include #include #include #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 : "", 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="); } if (dev) free(dev); } else { ESP_LOGI(TAG, "DUMP Device: name="); } // 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="); } if (url) free(url); } else { ESP_LOGI(TAG, "DUMP Service: url="); } 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; }