retrofit to gcc8

components/platform_console/cmd_nvs.c

@@ -0,0 +1,554 @@
+/* Console example — NVS commands
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+//#define LOG_LOCAL_LEVEL ESP_LOG_VERBOSE
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "nvs_flash.h"
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include "esp_log.h"
+#include "esp_console.h"
+#include "argtable3/argtable3.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/event_groups.h"
+#include "esp_err.h"
+#include "cmd_nvs.h"
+#include "nvs.h"
+#include "nvs_utilities.h"
+
+
+
+static const char *ARG_TYPE_STR = "type can be: i8, u8, i16, u16 i32, u32 i64, u64, str, blob";
+static const char * TAG = "cmd_nvs";
+
+static struct {
+    struct arg_str *key;
+    struct arg_str *type;
+    struct arg_str *value;
+    struct arg_end *end;
+} set_args;
+
+static struct {
+    struct arg_str *key;
+    struct arg_str *type;
+    struct arg_end *end;
+} get_args;
+
+static struct {
+    struct arg_str *key;
+    struct arg_end *end;
+} erase_args;
+
+static struct {
+    struct arg_str *namespace;
+    struct arg_end *end;
+} erase_all_args;
+
+static struct {
+    struct arg_str *partition;
+    struct arg_str *namespace;
+    struct arg_str *type;
+    struct arg_end *end;
+} list_args;
+
+
+
+static esp_err_t store_blob(nvs_handle nvs, const char *key, const char *str_values)
+{
+    uint8_t value;
+    size_t str_len = strlen(str_values);
+    size_t blob_len = str_len / 2;
+
+    if (str_len % 2) {
+        ESP_LOGE(TAG, "Blob data must contain even number of characters");
+        return ESP_ERR_NVS_TYPE_MISMATCH;
+    }
+
+    char *blob = (char *)malloc(blob_len);
+    if (blob == NULL) {
+        return ESP_ERR_NO_MEM;
+    }
+
+    for (int i = 0, j = 0; i < str_len; i++) {
+        char ch = str_values[i];
+        if (ch >= '0' && ch <= '9') {
+            value = ch - '0';
+        } else if (ch >= 'A' && ch <= 'F') {
+            value = ch - 'A' + 10;
+        } else if (ch >= 'a' && ch <= 'f') {
+            value = ch - 'a' + 10;
+        } else {
+            ESP_LOGE(TAG, "Blob data contain invalid character");
+            free(blob);
+            return ESP_ERR_NVS_TYPE_MISMATCH;
+        }
+
+        if (i & 1) {
+            blob[j++] += value;
+        } else {
+            blob[j] = value << 4;
+        }
+    }
+
+    esp_err_t err = nvs_set_blob(nvs, key, blob, blob_len);
+    free(blob);
+
+    if (err == ESP_OK) {
+        err = nvs_commit(nvs);
+    }
+
+    return err;
+}
+
+static esp_err_t set_value_in_nvs(const char *key, const char *str_type, const char *str_value)
+{
+    esp_err_t err;
+    nvs_handle nvs;
+    bool range_error = false;
+
+    nvs_type_t type = str_to_type(str_type);
+
+    if (type == NVS_TYPE_ANY) {
+        return ESP_ERR_NVS_TYPE_MISMATCH;
+    }
+
+    err = nvs_open_from_partition(settings_partition, current_namespace, NVS_READWRITE, &nvs);
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    if (type == NVS_TYPE_I8) {
+        int32_t value = strtol(str_value, NULL, 0);
+        if (value < INT8_MIN || value > INT8_MAX || errno == ERANGE) {
+            range_error = true;
+        } else {
+            err = nvs_set_i8(nvs, key, (int8_t)value);
+        }
+    } else if (type == NVS_TYPE_U8) {
+        uint32_t value = strtoul(str_value, NULL, 0);
+        if (value > UINT8_MAX || errno == ERANGE) {
+            range_error = true;
+        } else {
+            err = nvs_set_u8(nvs, key, (uint8_t)value);
+        }
+    } else if (type == NVS_TYPE_I16) {
+        int32_t value = strtol(str_value, NULL, 0);
+        if (value < INT16_MIN || value > INT16_MAX || errno == ERANGE) {
+            range_error = true;
+        } else {
+            err = nvs_set_i16(nvs, key, (int16_t)value);
+        }
+    } else if (type == NVS_TYPE_U16) {
+        uint32_t value = strtoul(str_value, NULL, 0);
+        if (value > UINT16_MAX || errno == ERANGE) {
+            range_error = true;
+        } else {
+            err = nvs_set_u16(nvs, key, (uint16_t)value);
+        }
+    } else if (type == NVS_TYPE_I32) {
+        int32_t value = strtol(str_value, NULL, 0);
+        if (errno != ERANGE) {
+            err = nvs_set_i32(nvs, key, value);
+        }
+    } else if (type == NVS_TYPE_U32) {
+        uint32_t value = strtoul(str_value, NULL, 0);
+        if (errno != ERANGE) {
+            err = nvs_set_u32(nvs, key, value);
+        }
+    } else if (type == NVS_TYPE_I64) {
+        int64_t value = strtoll(str_value, NULL, 0);
+        if (errno != ERANGE) {
+            err = nvs_set_i64(nvs, key, value);
+        }
+    } else if (type == NVS_TYPE_U64) {
+        uint64_t value = strtoull(str_value, NULL, 0);
+        if (errno != ERANGE) {
+            err = nvs_set_u64(nvs, key, value);
+        }
+    } else if (type == NVS_TYPE_STR) {
+        err = nvs_set_str(nvs, key, str_value);
+    } else if (type == NVS_TYPE_BLOB) {
+        err = store_blob(nvs, key, str_value);
+    }
+
+    if (range_error || errno == ERANGE) {
+        nvs_close(nvs);
+        return ESP_ERR_NVS_VALUE_TOO_LONG;
+    }
+
+    if (err == ESP_OK) {
+    	ESP_LOGI(TAG, "Set value ok. Committing '%s'", key);
+        err = nvs_commit(nvs);
+        if (err == ESP_OK) {
+            ESP_LOGI(TAG, "Value stored under key '%s'", key);
+        }
+    }
+
+    nvs_close(nvs);
+    return err;
+}
+
+static esp_err_t get_value_from_nvs(const char *key, const char *str_type)
+{
+    nvs_handle nvs;
+    esp_err_t err;
+
+    nvs_type_t type = str_to_type(str_type);
+
+    if (type == NVS_TYPE_ANY) {
+        return ESP_ERR_NVS_TYPE_MISMATCH;
+    }
+
+    err = nvs_open_from_partition(settings_partition, current_namespace, NVS_READWRITE, &nvs);
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    if (type == NVS_TYPE_I8) {
+        int8_t value;
+        err = nvs_get_i8(nvs, key, &value);
+        if (err == ESP_OK) {
+            printf("Value associated with key '%s' is %d \n", key, value);
+        }
+    } else if (type == NVS_TYPE_U8) {
+        uint8_t value;
+        err = nvs_get_u8(nvs, key, &value);
+        if (err == ESP_OK) {
+            printf("Value associated with key '%s' is %u \n", key, value);
+        }
+    } else if (type == NVS_TYPE_I16) {
+        int16_t value;
+        err = nvs_get_i16(nvs, key, &value);
+        if (err == ESP_OK) {
+            printf("Value associated with key '%s' is %d \n", key, value);
+        }
+    } else if (type == NVS_TYPE_U16) {
+        uint16_t value;
+        if ((err = nvs_get_u16(nvs, key, &value)) == ESP_OK) {
+            printf("Value associated with key '%s' is %u", key, value);
+        }
+    } else if (type == NVS_TYPE_I32) {
+        int32_t value;
+        if ((err = nvs_get_i32(nvs, key, &value)) == ESP_OK) {
+            printf("Value associated with key '%s' is %d \n", key, value);
+        }
+    } else if (type == NVS_TYPE_U32) {
+        uint32_t value;
+        if ((err = nvs_get_u32(nvs, key, &value)) == ESP_OK) {
+            printf("Value associated with key '%s' is %u \n", key, value);
+        }
+    } else if (type == NVS_TYPE_I64) {
+        int64_t value;
+        if ((err = nvs_get_i64(nvs, key, &value)) == ESP_OK) {
+            printf("Value associated with key '%s' is %lld \n", key, value);
+        }
+    } else if (type == NVS_TYPE_U64) {
+        uint64_t value;
+        if ( (err = nvs_get_u64(nvs, key, &value)) == ESP_OK) {
+            printf("Value associated with key '%s' is %llu \n", key, value);
+        }
+    } else if (type == NVS_TYPE_STR) {
+        size_t len=0;
+        if ( (err = nvs_get_str(nvs, key, NULL, &len)) == ESP_OK) {
+            char *str = (char *)malloc(len);
+            if ( (err = nvs_get_str(nvs, key, str, &len)) == ESP_OK) {
+                printf("String associated with key '%s' is %s \n", key, str);
+            }
+            free(str);
+        }
+    } else if (type == NVS_TYPE_BLOB) {
+        size_t len;
+        if ( (err = nvs_get_blob(nvs, key, NULL, &len)) == ESP_OK) {
+            char *blob = (char *)malloc(len);
+            if ( (err = nvs_get_blob(nvs, key, blob, &len)) == ESP_OK) {
+                printf("Blob associated with key '%s' is %d bytes long: \n", key, len);
+                print_blob(blob, len);
+            }
+            free(blob);
+        }
+    }
+
+    nvs_close(nvs);
+    return err;
+}
+
+static esp_err_t erase(const char *key)
+{
+    nvs_handle nvs;
+
+    esp_err_t err = nvs_open_from_partition(settings_partition, current_namespace, NVS_READWRITE, &nvs);
+    if (err == ESP_OK) {
+        err = nvs_erase_key(nvs, key);
+        if (err == ESP_OK) {
+            err = nvs_commit(nvs);
+            if (err == ESP_OK) {
+                ESP_LOGI(TAG, "Value with key '%s' erased", key);
+            }
+        }
+        nvs_close(nvs);
+    }
+
+    return err;
+}
+
+static esp_err_t erase_all(const char *name)
+{
+    nvs_handle nvs;
+
+    esp_err_t err = nvs_open_from_partition(settings_partition, current_namespace, NVS_READWRITE, &nvs);
+    if (err == ESP_OK) {
+        err = nvs_erase_all(nvs);
+        if (err == ESP_OK) {
+            err = nvs_commit(nvs);
+        }
+    }
+
+    ESP_LOGI(TAG, "Namespace '%s' was %s erased", name, (err == ESP_OK) ? "" : "not");
+    nvs_close(nvs);
+    return ESP_OK;
+}
+
+static int set_value(int argc, char **argv)
+{
+	ESP_LOGD(TAG, "%s %u - Parsing keys ",__func__,__LINE__);
+    int nerrors = arg_parse(argc, argv, (void **) &set_args);
+
+    if (nerrors != 0) {
+    	ESP_LOGE(TAG, "%s %u - Error Parsing keys ",__func__,__LINE__);
+        arg_print_errors(stderr, set_args.end, argv[0]);
+        return 1;
+    }
+
+    const char *key = set_args.key->sval[0];
+    const char *type = set_args.type->sval[0];
+    const char *values = set_args.value->sval[0];
+    ESP_LOGI(TAG, "Setting '%s' (type %s)", key,type);
+    esp_err_t err = set_value_in_nvs(key, type, values);
+
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s", esp_err_to_name(err));
+        return 1;
+    }
+
+    return 0;
+
+}
+
+static int get_value(int argc, char **argv)
+{
+    int nerrors = arg_parse(argc, argv, (void **) &get_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, get_args.end, argv[0]);
+        return 1;
+    }
+
+    const char *key = get_args.key->sval[0];
+    const char *type = get_args.type->sval[0];
+
+    esp_err_t err = get_value_from_nvs(key, type);
+
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s", esp_err_to_name(err));
+        return 1;
+    }
+
+    return 0;
+}
+
+static int erase_value(int argc, char **argv)
+{
+    int nerrors = arg_parse(argc, argv, (void **) &erase_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, erase_args.end, argv[0]);
+        return 1;
+    }
+
+    const char *key = erase_args.key->sval[0];
+
+    esp_err_t err = erase(key);
+
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s", esp_err_to_name(err));
+        return 1;
+    }
+
+    return 0;
+}
+
+static int erase_namespace(int argc, char **argv)
+{
+    int nerrors = arg_parse(argc, argv, (void **) &erase_all_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, erase_all_args.end, argv[0]);
+        return 1;
+    }
+
+    const char *name = erase_all_args.namespace->sval[0];
+
+    esp_err_t err = erase_all(name);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s", esp_err_to_name(err));
+        return 1;
+    }
+
+    return 0;
+}
+
+static int erase_wifi_manager(int argc, char **argv)
+{
+    nvs_handle nvs;
+	esp_err_t err = nvs_open("config", NVS_READWRITE, &nvs);
+	if (err == ESP_OK) {
+		err = nvs_erase_all(nvs);
+		if (err == ESP_OK) {
+			err = nvs_commit(nvs);
+		}
+	}
+	nvs_close(nvs);
+	if (err != ESP_OK) {
+		ESP_LOGE(TAG, "wifi manager configuration was not erase. %s", esp_err_to_name(err));
+		return 1;
+	}
+	else {
+		ESP_LOGW(TAG, "Wifi manager configuration was erased");
+	}
+	return 0;
+}
+
+
+static int list(const char *part, const char *name, const char *str_type)
+{
+    nvs_type_t type = str_to_type(str_type);
+
+    nvs_iterator_t it = nvs_entry_find(part, NULL, type);
+    if (it == NULL) {
+        ESP_LOGE(TAG, "No such enty was found");
+        return 1;
+    }
+
+    do {
+        nvs_entry_info_t info;
+        nvs_entry_info(it, &info);
+        it = nvs_entry_next(it);
+
+        printf("namespace '%s', key '%s', type '%s' \n",
+               info.namespace_name, info.key, type_to_str(info.type));
+    } while (it != NULL);
+
+    return 0;
+}
+static int list_entries(int argc, char **argv)
+{
+    list_args.partition->sval[0] = "";
+    list_args.namespace->sval[0] = "";
+    list_args.type->sval[0] = "";
+
+    int nerrors = arg_parse(argc, argv, (void **) &list_args);
+    if (nerrors != 0) {
+        arg_print_errors(stderr, list_args.end, argv[0]);
+        return 1;
+    }
+
+    const char *part = list_args.partition->sval[0];
+    const char *name = list_args.namespace->sval[0];
+    const char *type = list_args.type->sval[0];
+
+    return list(part, name, type);
+}
+void register_nvs()
+{
+	set_args.key = arg_str1(NULL, NULL, "<key>", "key of the value to be set");
+    set_args.type = arg_str1(NULL, NULL, "<type>", ARG_TYPE_STR);
+    set_args.value = arg_str1("v", "value", "<value>", "value to be stored");
+    set_args.end = arg_end(2);
+
+    get_args.key = arg_str1(NULL, NULL, "<key>", "key of the value to be read");
+    get_args.type = arg_str1(NULL, NULL, "<type>", ARG_TYPE_STR);
+    get_args.end = arg_end(2);
+
+    erase_args.key = arg_str1(NULL, NULL, "<key>", "key of the value to be erased");
+    erase_args.end = arg_end(2);
+
+    erase_all_args.namespace = arg_str1(NULL, NULL, "<namespace>", "namespace to be erased");
+    erase_all_args.end = arg_end(2);
+
+    list_args.partition = arg_str1(NULL, NULL, "<partition>", "partition name");
+    list_args.namespace = arg_str0("n", "namespace", "<namespace>", "namespace name");
+    list_args.type = arg_str0("t", "type", "<type>", ARG_TYPE_STR);
+    list_args.end = arg_end(2);
+    const esp_console_cmd_t set_cmd = {
+        .command = "nvs_set",
+        .help = "Set variable in selected namespace. Blob type must be comma separated list of hex values. \n"
+        "Examples:\n"
+        " nvs_set VarName i32 -v 123 \n"
+        " nvs_set VarName srt -v YourString \n"
+        " nvs_set VarName blob -v 0123456789abcdef \n",
+        .hint = NULL,
+        .func = &set_value,
+        .argtable = &set_args
+    };
+
+    const esp_console_cmd_t get_cmd = {
+        .command = "nvs_get",
+        .help = "Get variable from selected namespace. \n"
+        "Example: nvs_get VarName i32",
+        .hint = NULL,
+        .func = &get_value,
+        .argtable = &get_args
+    };
+
+    const esp_console_cmd_t erase_cmd = {
+        .command = "nvs_erase",
+        .help = "Erase variable from current namespace",
+        .hint = NULL,
+        .func = &erase_value,
+        .argtable = &erase_args
+    };
+
+    const esp_console_cmd_t erase_namespace_cmd = {
+        .command = "nvs_erase_namespace",
+        .help = "Erases specified namespace",
+        .hint = NULL,
+        .func = &erase_namespace,
+        .argtable = &erase_all_args
+    };
+    const esp_console_cmd_t erase_wifimanager_cmd = {
+        .command = "nvs_erase_wifi_manager",
+        .help = "Erases wifi_manager's config",
+        .hint = NULL,
+        .func = &erase_wifi_manager,
+        .argtable = NULL
+    };
+
+
+    const esp_console_cmd_t list_entries_cmd = {
+           .command = "nvs_list",
+           .help = "List stored key-value pairs stored in NVS."
+           "Namespace and type can be specified to print only those key-value pairs.\n"
+           "Following command list variables stored inside 'nvs' partition, under namespace 'storage' with type uint32_t"
+           "Example: nvs_list nvs -n storage -t u32 \n",
+           .hint = NULL,
+           .func = &list_entries,
+           .argtable = &list_args
+       };
+    ESP_ERROR_CHECK(esp_console_cmd_register(&list_entries_cmd));
+    ESP_ERROR_CHECK(esp_console_cmd_register(&set_cmd));
+    ESP_ERROR_CHECK(esp_console_cmd_register(&get_cmd));
+    ESP_ERROR_CHECK(esp_console_cmd_register(&erase_cmd));
+    ESP_ERROR_CHECK(esp_console_cmd_register(&erase_namespace_cmd));
+    ESP_ERROR_CHECK(esp_console_cmd_register(&erase_wifimanager_cmd));
+
+}
+#ifdef __cplusplus
+extern }
+#endif