Mirror/squeezelite-esp32
1
0
Fork 0
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2025-12-10 13:37:03 +03:00
Code Issues Packages Projects Releases Wiki Activity

Store certificates in NVS, bug fixes - release

Browse Source
This commit is contained in:
Sebastien
2019-11-22 16:37:53 -05:00
parent 29242c63b9
commit 6fd80f0ff4
11 changed files with 408 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
main/component.mk
View File

@@ -10,4 +10,5 @@
CFLAGS += -D LOG_LOCAL_LEVEL=ESP_LOG_INFO
COMPONENT_ADD_INCLUDEDIRS += $(COMPONENT_PATH)/../tools
COMPONENT_EXTRA_INCLUDES += $(PROJECT_PATH)/components/tools/
LDFLAGS += -s
LDFLAGS += -s
COMPONENT_EMBED_TXTFILES := ${PROJECT_PATH}/server_certs/github.pem

129
main/config.c
View File

@@ -61,7 +61,16 @@ bool config_set_group_bit(int bit_num,bool flag);
cJSON * config_set_value_safe(nvs_type_t nvs_type, const char *key, void * value);
static void vCallbackFunction( TimerHandle_t xTimer );
void config_set_entry_changed_flag(cJSON * entry, cJSON_bool flag);
#define IMPLEMENT_SET_DEFAULT(t,nt) void config_set_default_## t (const char *key, t value){\
void * pval = malloc(sizeof(value));\
*((t *) pval) = value;\
config_set_default(nt, key,pval,0);\
free(pval); }
#define IMPLEMENT_GET_NUM(t,nt) esp_err_t config_get_## t (const char *key, t * value){\
void * pval = config_alloc_get(nt, key);\
if(pval!=NULL){ *value = *(t * )pval; free(pval); return ESP_OK; }\
return ESP_FAIL;}
#ifdef RECOVERY_APPLICATION
static void * malloc_fn(size_t sz){
void * ptr = heap_caps_malloc(sz, MALLOC_CAP_SPIRAM);
@@ -79,6 +88,7 @@ static void * free_fn(void * ptr){
}
return NULL;
}
#endif
void init_cJSON(){
static cJSON_Hooks hooks;
// initialize cJSON hooks it uses SPIRAM memory
@@ -118,52 +128,71 @@ void config_start_timer(){
}
}
nvs_type_t config_get_item_type(cJSON * entry){
if(entry==NULL){
ESP_LOGE(TAG,"null pointer received!");
return true;
}
cJSON * item_type = cJSON_GetObjectItemCaseSensitive(entry, "type");
if(item_type ==NULL ) {
ESP_LOGE(TAG, "Item type not found! ");
return 0;
}
ESP_LOGD(TAG,"Found item type %f",item_type->valuedouble);
return item_type->valuedouble;
}
cJSON * config_set_value_safe(nvs_type_t nvs_type, const char *key, void * value){
char * num_buffer = NULL;
num_buffer = malloc(NUM_BUFFER_LEN);
memset(num_buffer,0x00,NUM_BUFFER_LEN);
cJSON * entry = cJSON_CreateObject();
double numvalue = 0;
if(entry == NULL) {
ESP_LOGE(TAG, "Unable to allocate memory for entry %s",key);
return NULL;
}
cJSON_AddNumberToObject(entry,"type", nvs_type );
switch (nvs_type) {
case NVS_TYPE_I8:
snprintf(num_buffer, NUM_BUFFER_LEN-1, "%i", *(int8_t*)value);
cJSON_AddNumberToObject(entry,"value", *(int8_t*)value );
break;
case NVS_TYPE_I16:
snprintf(num_buffer, NUM_BUFFER_LEN-1, "%i", *(int16_t*)value);
cJSON_AddNumberToObject(entry,"value", *(int16_t*)value );
break;
case NVS_TYPE_I32:
snprintf(num_buffer, NUM_BUFFER_LEN-1, "%i", *(int32_t*)value);
cJSON_AddNumberToObject(entry,"value", *(int32_t*)value );
break;
case NVS_TYPE_U8:
snprintf(num_buffer, NUM_BUFFER_LEN-1, "%u", *(uint8_t*)value);
cJSON_AddNumberToObject(entry,"value", *(uint8_t*)value );
break;
case NVS_TYPE_U16:
snprintf(num_buffer, NUM_BUFFER_LEN-1, "%u", *(uint16_t*)value);
cJSON_AddNumberToObject(entry,"value", *(uint16_t*)value );
break;
case NVS_TYPE_U32:
snprintf(num_buffer, NUM_BUFFER_LEN-1, "%u", *(uint32_t*)value);
cJSON_AddNumberToObject(entry,"value", *(uint32_t*)value );
break;
case NVS_TYPE_STR:
cJSON_AddStringToObject(entry, "value", (char *)value);
break;
case NVS_TYPE_I64:
case NVS_TYPE_U64:
default:
ESP_LOGE(TAG, "nvs type %u not supported", nvs_type);
break;
}
cJSON * existing = cJSON_GetObjectItemCaseSensitive(nvs_json, key);
if(existing !=NULL && nvs_type == NVS_TYPE_STR && config_get_item_type(existing) != NVS_TYPE_STR ) {
ESP_LOGW(TAG, "Storing numeric value from string");
numvalue = atof((char *)value);
cJSON_AddNumberToObject(entry,"value", numvalue );
nvs_type_t exist_type = config_get_item_type(existing);
ESP_LOGW(TAG, "Stored value %f from string %s as type %d",numvalue, (char *)value,exist_type);
cJSON_AddNumberToObject(entry,"type", exist_type);
}
else {
cJSON_AddNumberToObject(entry,"type", nvs_type );
switch (nvs_type) {
case NVS_TYPE_I8:
cJSON_AddNumberToObject(entry,"value", *(int8_t*)value );
break;
case NVS_TYPE_I16:
cJSON_AddNumberToObject(entry,"value", *(int16_t*)value );
break;
case NVS_TYPE_I32:
cJSON_AddNumberToObject(entry,"value", *(int32_t*)value );
break;
case NVS_TYPE_U8:
cJSON_AddNumberToObject(entry,"value", *(uint8_t*)value );
break;
case NVS_TYPE_U16:
cJSON_AddNumberToObject(entry,"value", *(uint16_t*)value );
break;
case NVS_TYPE_U32:
cJSON_AddNumberToObject(entry,"value", *(uint32_t*)value );
break;
case NVS_TYPE_STR:
cJSON_AddStringToObject(entry, "value", (char *)value);
break;
case NVS_TYPE_I64:
case NVS_TYPE_U64:
default:
ESP_LOGE(TAG, "nvs type %u not supported", nvs_type);
break;
}
}
if(existing!=NULL ) {
ESP_LOGV(TAG, "Changing existing entry [%s].", key);
char * exist_str = cJSON_PrintUnformatted(existing);
@@ -207,7 +236,6 @@ cJSON * config_set_value_safe(nvs_type_t nvs_type, const char *key, void * value
config_set_entry_changed_flag(entry,true);
cJSON_AddItemToObject(nvs_json, key, entry);
}
free(num_buffer);
return entry;
}
@@ -222,6 +250,7 @@ nvs_type_t config_get_entry_type(cJSON * entry){
ESP_LOGE(TAG, "Entry type not found in nvs cache for existing setting.");
return 0;
}
ESP_LOGV(TAG,"Found type %s",type_to_str(entry_type->valuedouble));
return entry_type->valuedouble;
}
void config_set_entry_changed_flag(cJSON * entry, cJSON_bool flag){
@@ -267,6 +296,10 @@ cJSON_bool config_is_entry_changed(cJSON * entry){
}
return cJSON_IsTrue(changed);
}
void * config_safe_alloc_get_entry_value(nvs_type_t nvs_type, cJSON * entry){
void * value=NULL;
if(entry==NULL){
@@ -300,7 +333,6 @@ void * config_safe_alloc_get_entry_value(nvs_type_t nvs_type, cJSON * entry){
return NULL;
}
if (nvs_type == NVS_TYPE_I8) {
value=malloc(sizeof(int8_t));
*(int8_t *)value = (int8_t)entry_value->valuedouble;
@@ -507,7 +539,7 @@ bool config_set_group_bit(int bit_num,bool flag){
}
return result;
}
//void config_set_default_uint16(const char *key, uint16_t value) { }
void config_set_default(nvs_type_t type, const char *key, void * default_value, size_t blob_size) {
if(!config_lock(LOCK_MAX_WAIT/portTICK_PERIOD_MS)){
ESP_LOGE(TAG, "Unable to lock config");
@@ -672,3 +704,16 @@ esp_err_t config_set_value(nvs_type_t nvs_type, const char *key, void * value){
return result;
}
IMPLEMENT_SET_DEFAULT(uint8_t,NVS_TYPE_U8);
IMPLEMENT_SET_DEFAULT(int8_t,NVS_TYPE_I8);
IMPLEMENT_SET_DEFAULT(uint16_t,NVS_TYPE_U16);
IMPLEMENT_SET_DEFAULT(int16_t,NVS_TYPE_I16);
IMPLEMENT_SET_DEFAULT(uint32_t,NVS_TYPE_U32);
IMPLEMENT_SET_DEFAULT(int32_t,NVS_TYPE_I32);
IMPLEMENT_GET_NUM(uint8_t,NVS_TYPE_U8);
IMPLEMENT_GET_NUM(int8_t,NVS_TYPE_I8);
IMPLEMENT_GET_NUM(uint16_t,NVS_TYPE_U16);
IMPLEMENT_GET_NUM(int16_t,NVS_TYPE_I16);
IMPLEMENT_GET_NUM(uint32_t,NVS_TYPE_U32);
IMPLEMENT_GET_NUM(int32_t,NVS_TYPE_I32);

17
main/config.h
View File

@@ -10,6 +10,23 @@ extern "C" {
#ifdef __cplusplus
}
#endif
#define DECLARE_SET_DEFAULT(t) void config_set_default_## t (const char *key, t value);
#define DECLARE_GET_NUM(t) esp_err_t config_get_## t (const char *key, t * value);
DECLARE_SET_DEFAULT(uint8_t);
DECLARE_SET_DEFAULT(uint16_t);
DECLARE_SET_DEFAULT(uint32_t);
DECLARE_SET_DEFAULT(int8_t);
DECLARE_SET_DEFAULT(int16_t);
DECLARE_SET_DEFAULT(int32_t);
DECLARE_GET_NUM(uint8_t);
DECLARE_GET_NUM(uint16_t);
DECLARE_GET_NUM(uint32_t);
DECLARE_GET_NUM(int8_t);
DECLARE_GET_NUM(int16_t);
DECLARE_GET_NUM(int32_t);
bool config_has_changes();
void config_commit_to_nvs();
void config_start_timer();

120
main/esp_app_main.c
View File

@@ -50,6 +50,9 @@
extern bool enable_bt_sink;
extern bool enable_airplay;
extern bool jack_mutes_amp;
static const char certs_namespace[] = "certificates";
static const char certs_key[] = "blob";
static const char certs_version[] = "version";
EventGroupHandle_t wifi_event_group;
@@ -69,6 +72,8 @@ char * fwurl = NULL;
#define LED_RED_GPIO -1
#endif
static bool bWifiConnected=false;
extern const uint8_t server_cert_pem_start[] asm("_binary_github_pem_start");
extern const uint8_t server_cert_pem_end[] asm("_binary_github_pem_end");
@@ -125,6 +130,108 @@ esp_log_level_t get_log_level_from_char(char * level){
void set_log_level(char * tag, char * level){
esp_log_level_set(tag, get_log_level_from_char(level));
}
esp_err_t update_certificates(){
// server_cert_pem_start
// server_cert_pem_end
nvs_handle handle;
esp_err_t esp_err;
esp_app_desc_t running_app_info;
ESP_LOGI(TAG, "About to check if certificates need to be updated in flash");
esp_err = nvs_open_from_partition(settings_partition, certs_namespace, NVS_READWRITE, &handle);
if (esp_err != ESP_OK) {
ESP_LOGE(TAG, "Unable to open name namespace %s. Error %s", certs_namespace, esp_err_to_name(esp_err));
return esp_err;
}
const esp_partition_t *running = esp_ota_get_running_partition();
if(running->subtype !=ESP_PARTITION_SUBTYPE_APP_FACTORY ){
ESP_LOGI(TAG, "Running partition [%s] type %d subtype %d (offset 0x%08x)", running->label, running->type, running->subtype, running->address);
}
if (esp_ota_get_partition_description(running, &running_app_info) == ESP_OK) {
ESP_LOGI(TAG, "Running version: %s", running_app_info.version);
}
size_t len=0;
char *str=NULL;
bool changed=false;
if ( (esp_err= nvs_get_str(handle, certs_version, NULL, &len)) == ESP_OK) {
str=(char *)malloc(len);
if ( (esp_err = nvs_get_str(handle, certs_version, str, &len)) == ESP_OK) {
printf("String associated with key '%s' is %s \n", certs_version, str);
}
}
if(str!=NULL){
if(strcmp((char *)running_app_info.version,(char *)str )){
// Versions are different
ESP_LOGW(TAG,"Found a different software version. Updating certificates");
changed=true;
}
free(str);
}
else {
ESP_LOGW(TAG,"No certificate found. Adding certificates");
changed=true;
}
if(changed){
esp_err = nvs_set_blob(handle, certs_key, server_cert_pem_start, (server_cert_pem_end-server_cert_pem_start));
if(esp_err!=ESP_OK){
ESP_LOGE(TAG, "Failed to store certificate data: %s", esp_err_to_name(esp_err));
}
else {
ESP_LOGI(TAG,"Updated stored https certificates");
esp_err = nvs_set_str(handle, certs_version, running_app_info.version);
if(esp_err!=ESP_OK){
ESP_LOGE(TAG, "Failed to store app version: %s", esp_err_to_name(esp_err));
}
else {
esp_err = nvs_commit(handle);
if(esp_err!=ESP_OK){
ESP_LOGE(TAG, "Failed to commit certificate changes: %s", esp_err_to_name(esp_err));
}
}
}
}
nvs_close(handle);
return ESP_OK;
}
const char * get_certificate(){
nvs_handle handle;
esp_err_t esp_err;
char *blob =NULL;
//
ESP_LOGD(TAG, "Fetching certificate.");
esp_err = nvs_open_from_partition(settings_partition, certs_namespace, NVS_READONLY, &handle);
if(esp_err == ESP_OK){
size_t len;
esp_err = nvs_get_blob(handle, certs_key, NULL, &len);
if( esp_err == ESP_OK) {
blob = (char *)malloc(len);
esp_err = nvs_get_blob(handle, certs_key, blob, &len);
if ( esp_err == ESP_OK) {
printf("Blob associated with key '%s' is %d bytes long: \n", certs_key, len);
}
}
else{
ESP_LOGE(TAG, "Unable to get the existing blob from namespace %s. [%s]", certs_namespace, esp_err_to_name(esp_err));
}
nvs_close(handle);
}
else{
ESP_LOGE(TAG, "Unable to open name namespace %s. [%s]", certs_namespace, esp_err_to_name(esp_err));
}
return blob;
}
//CONFIG_SDIF_NUM=0
@@ -207,8 +314,7 @@ void register_default_nvs(){
ESP_LOGD(TAG,"Registering default value for key %s, value %s", "bypass_wm", "0");
config_set_default(NVS_TYPE_STR, "bypass_wm", "0", 0);
// ESP_LOGD(TAG,"Registering default value for key %s, value %s", "test_num", "0");
// config_set_default(NVS_TYPE_U16, "test_num", (uint16_t)2, 0);
ESP_LOGD(TAG,"Registering default value for key %s, value %s", "test_num", "0");
char number_buffer[101] = {};
@@ -260,7 +366,7 @@ void register_default_nvs(){
void app_main()
{
char * fwurl = NULL;
esp_err_t update_certificates();
ESP_LOGD(TAG,"Creating event group for wifi");
wifi_event_group = xEventGroupCreate();
ESP_LOGD(TAG,"Clearing CONNECTED_BIT from wifi group");
@@ -268,12 +374,18 @@ void app_main()
ESP_LOGI(TAG,"Starting app_main");
initialize_nvs();
ESP_LOGI(TAG,"Setting up config subsystem.");
config_init();
ESP_LOGD(TAG,"Registering default values");
ESP_LOGI(TAG,"Registering default values");
register_default_nvs();
#if !RECOVERY_APPLICATION
ESP_LOGI(TAG,"Checking if certificates need to be updated");
update_certificates();
#endif
ESP_LOGD(TAG,"Getting firmware OTA URL (if any)");
fwurl = process_ota_url();

49
main/nvs_utilities.c
View File

@@ -20,6 +20,55 @@ const char current_namespace[] = "config";
const char settings_partition[] = "settings";
static const char * TAG = "nvs_utilities";
typedef struct {
nvs_type_t type;
const char *str;
} type_str_pair_t;
static const type_str_pair_t type_str_pair[] = {
{ NVS_TYPE_I8, "i8" },
{ NVS_TYPE_U8, "u8" },
{ NVS_TYPE_U16, "u16" },
{ NVS_TYPE_I16, "i16" },
{ NVS_TYPE_U32, "u32" },
{ NVS_TYPE_I32, "i32" },
{ NVS_TYPE_U64, "u64" },
{ NVS_TYPE_I64, "i64" },
{ NVS_TYPE_STR, "str" },
{ NVS_TYPE_BLOB, "blob" },
{ NVS_TYPE_ANY, "any" },
};
static const size_t TYPE_STR_PAIR_SIZE = sizeof(type_str_pair) / sizeof(type_str_pair[0]);
void print_blob(const char *blob, size_t len)
{
for (int i = 0; i < len; i++) {
printf("%02x", blob[i]);
}
printf("\n");
}
nvs_type_t str_to_type(const char *type)
{
for (int i = 0; i < TYPE_STR_PAIR_SIZE; i++) {
const type_str_pair_t *p = &type_str_pair[i];
if (strcmp(type, p->str) == 0) {
return p->type;
}
}
return NVS_TYPE_ANY;
}
const char *type_to_str(nvs_type_t type)
{
for (int i = 0; i < TYPE_STR_PAIR_SIZE; i++) {
const type_str_pair_t *p = &type_str_pair[i];
if (p->type == type) {
return p->str;
}
}
return "Unknown";
}
void initialize_nvs() {
ESP_LOGI(TAG, "Initializing flash nvs ");
esp_err_t err = nvs_flash_init();

3
main/nvs_utilities.h
View File

@@ -16,6 +16,9 @@ esp_err_t store_nvs_value(nvs_type_t type, const char *key, void * data);
esp_err_t get_nvs_value(nvs_type_t type, const char *key, void*value, const uint8_t buf_size);
void * get_nvs_value_alloc(nvs_type_t type, const char *key);
esp_err_t erase_nvs(const char *key);
void print_blob(const char *blob, size_t len);
const char *type_to_str(nvs_type_t type);
nvs_type_t str_to_type(const char *type);
#ifdef __cplusplus
}
#endif