OVMS3-idf/components/bt/bluedroid/osi/config.c
wangmengyang 2c87e84b0a component/bt: bluetooth storage module clean up and bug fix.
1. clean up bluetooth storage log prints;
2. reduce maximum link key storage size
3. modify so that the link key information of the latest connected device is stored at first
2017-01-20 16:46:10 +08:00

552 lines
14 KiB
C

/******************************************************************************
*
* Copyright (C) 2014 Google, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
#define LOG_TAG "bt_osi_config"
#include "esp_system.h"
#include "nvs_flash.h"
#include "nvs.h"
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// #include <sys/stat.h>
#include "allocator.h"
#include "config.h"
#include "list.h"
#include "bt_trace.h"
#define CONFIG_FILE_MAX_SIZE (512)
#define CONFIG_KEY "cfg_key1"
typedef struct {
char *key;
char *value;
} entry_t;
typedef struct {
char *name;
list_t *entries;
} section_t;
struct config_t {
list_t *sections;
};
// Empty definition; this type is aliased to list_node_t.
struct config_section_iter_t {};
static void config_parse(nvs_handle fp, config_t *config);
static section_t *section_new(const char *name);
static void section_free(void *ptr);
static section_t *section_find(const config_t *config, const char *section);
static entry_t *entry_new(const char *key, const char *value);
static void entry_free(void *ptr);
static entry_t *entry_find(const config_t *config, const char *section, const char *key);
config_t *config_new_empty(void)
{
config_t *config = osi_calloc(sizeof(config_t));
if (!config) {
LOG_ERROR("%s unable to allocate memory for config_t.\n", __func__);
goto error;
}
config->sections = list_new(section_free);
if (!config->sections) {
LOG_ERROR("%s unable to allocate list for sections.\n", __func__);
goto error;
}
return config;
error:;
config_free(config);
return NULL;
}
config_t *config_new(const char *filename)
{
assert(filename != NULL);
config_t *config = config_new_empty();
if (!config) {
return NULL;
}
esp_err_t err;
nvs_handle fp;
err = nvs_open(filename, NVS_READWRITE, &fp);
if (err != ESP_OK) {
LOG_ERROR("%s unable to open file '%s'\n", __func__, filename);
config_free(config);
return NULL;
}
config_parse(fp, config);
nvs_close(fp);
return config;
}
void config_free(config_t *config)
{
if (!config) {
return;
}
list_free(config->sections);
osi_free(config);
}
bool config_has_section(const config_t *config, const char *section)
{
assert(config != NULL);
assert(section != NULL);
return (section_find(config, section) != NULL);
}
bool config_has_key(const config_t *config, const char *section, const char *key)
{
assert(config != NULL);
assert(section != NULL);
assert(key != NULL);
return (entry_find(config, section, key) != NULL);
}
int config_get_int(const config_t *config, const char *section, const char *key, int def_value)
{
assert(config != NULL);
assert(section != NULL);
assert(key != NULL);
entry_t *entry = entry_find(config, section, key);
if (!entry) {
return def_value;
}
char *endptr;
int ret = strtol(entry->value, &endptr, 0);
return (*endptr == '\0') ? ret : def_value;
}
bool config_get_bool(const config_t *config, const char *section, const char *key, bool def_value)
{
assert(config != NULL);
assert(section != NULL);
assert(key != NULL);
entry_t *entry = entry_find(config, section, key);
if (!entry) {
return def_value;
}
if (!strcmp(entry->value, "true")) {
return true;
}
if (!strcmp(entry->value, "false")) {
return false;
}
return def_value;
}
const char *config_get_string(const config_t *config, const char *section, const char *key, const char *def_value)
{
assert(config != NULL);
assert(section != NULL);
assert(key != NULL);
entry_t *entry = entry_find(config, section, key);
if (!entry) {
return def_value;
}
return entry->value;
}
void config_set_int(config_t *config, const char *section, const char *key, int value)
{
assert(config != NULL);
assert(section != NULL);
assert(key != NULL);
char value_str[32] = { 0 };
sprintf(value_str, "%d", value);
config_set_string(config, section, key, value_str, false);
}
void config_set_bool(config_t *config, const char *section, const char *key, bool value)
{
assert(config != NULL);
assert(section != NULL);
assert(key != NULL);
config_set_string(config, section, key, value ? "true" : "false", false);
}
void config_set_string(config_t *config, const char *section, const char *key, const char *value, bool insert_back)
{
section_t *sec = section_find(config, section);
if (!sec) {
sec = section_new(section);
if (insert_back) {
list_append(config->sections, sec);
} else {
list_prepend(config->sections, sec);
}
}
for (const list_node_t *node = list_begin(sec->entries); node != list_end(sec->entries); node = list_next(node)) {
entry_t *entry = list_node(node);
if (!strcmp(entry->key, key)) {
osi_free(entry->value);
entry->value = osi_strdup(value);
return;
}
}
entry_t *entry = entry_new(key, value);
list_append(sec->entries, entry);
}
bool config_remove_section(config_t *config, const char *section)
{
assert(config != NULL);
assert(section != NULL);
section_t *sec = section_find(config, section);
if (!sec) {
return false;
}
return list_remove(config->sections, sec);
}
bool config_remove_key(config_t *config, const char *section, const char *key)
{
assert(config != NULL);
assert(section != NULL);
assert(key != NULL);
section_t *sec = section_find(config, section);
entry_t *entry = entry_find(config, section, key);
if (!sec || !entry) {
return false;
}
return list_remove(sec->entries, entry);
}
const config_section_node_t *config_section_begin(const config_t *config)
{
assert(config != NULL);
return (const config_section_node_t *)list_begin(config->sections);
}
const config_section_node_t *config_section_end(const config_t *config)
{
assert(config != NULL);
return (const config_section_node_t *)list_end(config->sections);
}
const config_section_node_t *config_section_next(const config_section_node_t *node)
{
assert(node != NULL);
return (const config_section_node_t *)list_next((const list_node_t *)node);
}
const char *config_section_name(const config_section_node_t *node)
{
assert(node != NULL);
const list_node_t *lnode = (const list_node_t *)node;
const section_t *section = (const section_t *)list_node(lnode);
return section->name;
}
bool config_save(const config_t *config, const char *filename)
{
assert(config != NULL);
assert(filename != NULL);
assert(*filename != '\0');
esp_err_t err;
int err_code = 0;
nvs_handle fp;
char *line = osi_calloc(1024);
char *buf = osi_calloc(CONFIG_FILE_MAX_SIZE);
if (!line || !buf) {
err_code |= 0x01;
goto error;
}
err = nvs_open(filename, NVS_READWRITE, &fp);
if (err != ESP_OK) {
err_code |= 0x02;
goto error;
}
int w_cnt, w_cnt_total = 0;
for (const list_node_t *node = list_begin(config->sections); node != list_end(config->sections); node = list_next(node)) {
const section_t *section = (const section_t *)list_node(node);
LOG_DEBUG("section name: %s\n", section->name);
w_cnt = snprintf(line, 1024, "[%s]\n", section->name);
if (w_cnt + w_cnt_total < CONFIG_FILE_MAX_SIZE) {
memcpy(buf + w_cnt_total, line, w_cnt);
w_cnt_total += w_cnt;
} else {
break;
}
for (const list_node_t *enode = list_begin(section->entries); enode != list_end(section->entries); enode = list_next(enode)) {
const entry_t *entry = (const entry_t *)list_node(enode);
LOG_DEBUG("(key, val): (%s, %s)\n", entry->key, entry->value);
w_cnt = snprintf(line, 1024, "%s = %s\n", entry->key, entry->value);
if (w_cnt + w_cnt_total < CONFIG_FILE_MAX_SIZE) {
memcpy(buf + w_cnt_total, line, w_cnt);
w_cnt_total += w_cnt;
} else {
break;
}
}
// Only add a separating newline if there are more sections.
if (list_next(node) != list_end(config->sections)) {
if (1 + w_cnt_total < CONFIG_FILE_MAX_SIZE) {
buf[w_cnt_total] = '\n';
w_cnt_total += 1;
}
} else {
break;
}
}
buf[w_cnt_total] = '\0';
err = nvs_set_blob(fp, CONFIG_KEY, buf, w_cnt_total);
if (err != ESP_OK) {
nvs_close(fp);
err_code |= 0x04;
goto error;
}
err = nvs_commit(fp);
if (err != ESP_OK) {
nvs_close(fp);
err_code |= 0x08;
goto error;
}
nvs_close(fp);
osi_free(line);
osi_free(buf);
return true;
error:
if (buf) {
osi_free(buf);
}
if (line) {
osi_free(line);
}
if (err_code) {
LOG_ERROR("%s, err_code: 0x%x\n", __func__, err_code);
}
return false;
}
static char *trim(char *str)
{
while (isspace((unsigned char)(*str))) {
++str;
}
if (!*str) {
return str;
}
char *end_str = str + strlen(str) - 1;
while (end_str > str && isspace((unsigned char)(*end_str))) {
--end_str;
}
end_str[1] = '\0';
return str;
}
static void config_parse(nvs_handle fp, config_t *config)
{
assert(fp != 0);
assert(config != NULL);
int line_num = 0;
int err_code = 0;
char *line = osi_calloc(1024);
char *section = osi_calloc(1024);
char *buf = osi_calloc(CONFIG_FILE_MAX_SIZE);
if (!line || !section || !buf) {
err_code |= 0x01;
goto error;
}
esp_err_t err;
size_t length = CONFIG_FILE_MAX_SIZE;
err = nvs_get_blob(fp, CONFIG_KEY, buf, &length);
if (err != ESP_OK) {
err_code |= 0x02;
goto error;
}
char *p_line_end;
char *p_line_bgn = buf;
strcpy(section, CONFIG_DEFAULT_SECTION);
while ( (p_line_bgn < buf + length - 1) && (p_line_end = strchr(p_line_bgn, '\n'))) {
// get one line
int line_len = p_line_end - p_line_bgn;
if (line_len > 1023) {
LOG_WARN("%s exceed max line length on line %d.\n", __func__, line_num);
break;
}
memcpy(line, p_line_bgn, line_len);
line[line_len] = '\0';
p_line_bgn = p_line_end + 1;
char *line_ptr = trim(line);
++line_num;
// Skip blank and comment lines.
if (*line_ptr == '\0' || *line_ptr == '#') {
continue;
}
if (*line_ptr == '[') {
size_t len = strlen(line_ptr);
if (line_ptr[len - 1] != ']') {
LOG_WARN("%s unterminated section name on line %d.\n", __func__, line_num);
continue;
}
strncpy(section, line_ptr + 1, len - 2);
section[len - 2] = '\0';
} else {
char *split = strchr(line_ptr, '=');
if (!split) {
LOG_DEBUG("%s no key/value separator found on line %d.\n", __func__, line_num);
continue;
}
*split = '\0';
config_set_string(config, section, trim(line_ptr), trim(split + 1), true);
}
}
error:
if (buf) {
osi_free(buf);
}
if (line) {
osi_free(line);
}
if (section) {
osi_free(section);
}
if (err_code) {
LOG_ERROR("%s returned with err code: %d\n", __func__, err_code);
}
}
static section_t *section_new(const char *name)
{
section_t *section = osi_calloc(sizeof(section_t));
if (!section) {
return NULL;
}
section->name = osi_strdup(name);
section->entries = list_new(entry_free);
return section;
}
static void section_free(void *ptr)
{
if (!ptr) {
return;
}
section_t *section = ptr;
osi_free(section->name);
list_free(section->entries);
osi_free(section);
}
static section_t *section_find(const config_t *config, const char *section)
{
for (const list_node_t *node = list_begin(config->sections); node != list_end(config->sections); node = list_next(node)) {
section_t *sec = list_node(node);
if (!strcmp(sec->name, section)) {
return sec;
}
}
return NULL;
}
static entry_t *entry_new(const char *key, const char *value)
{
entry_t *entry = osi_calloc(sizeof(entry_t));
if (!entry) {
return NULL;
}
entry->key = osi_strdup(key);
entry->value = osi_strdup(value);
return entry;
}
static void entry_free(void *ptr)
{
if (!ptr) {
return;
}
entry_t *entry = ptr;
osi_free(entry->key);
osi_free(entry->value);
osi_free(entry);
}
static entry_t *entry_find(const config_t *config, const char *section, const char *key)
{
section_t *sec = section_find(config, section);
if (!sec) {
return NULL;
}
for (const list_node_t *node = list_begin(sec->entries); node != list_end(sec->entries); node = list_next(node)) {
entry_t *entry = list_node(node);
if (!strcmp(entry->key, key)) {
return entry;
}
}
return NULL;
}