323 lines
9.1 KiB
C
323 lines
9.1 KiB
C
/***************************************************************************
|
|
*
|
|
* Copyright 2015-2019 BES.
|
|
* All rights reserved. All unpublished rights reserved.
|
|
*
|
|
* No part of this work may be used or reproduced in any form or by any
|
|
* means, or stored in a database or retrieval system, without prior written
|
|
* permission of BES.
|
|
*
|
|
* Use of this work is governed by a license granted by BES.
|
|
* This work contains confidential and proprietary information of
|
|
* BES. which is protected by copyright, trade secret,
|
|
* trademark and other intellectual property rights.
|
|
*
|
|
****************************************************************************/
|
|
#define LOG_TAG "bt_osi_config"
|
|
|
|
#include "nvrec_config.h"
|
|
#include "hal_trace.h"
|
|
#include "list_ext.h"
|
|
#include "nvrecord.h"
|
|
#include "stdio.h"
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
static nvrec_section_t *nvrec_section_new(const char *name);
|
|
static void nvrec_section_free(void *ptr);
|
|
|
|
static nvrec_entry_t *nvrec_entry_new(const char *key, const char *value,
|
|
const char *descrip);
|
|
static nvrec_entry_t *nvrec_entry_find(const nvrec_config_t *config,
|
|
const char *section, const char *key);
|
|
|
|
void *cfg_malloc(unsigned int size) {
|
|
void *ptr = NULL;
|
|
if (size == 0)
|
|
return NULL;
|
|
ptr = pool_malloc(size);
|
|
if (ptr == NULL) {
|
|
printf("cfg_malloc......ERROR\n");
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
void *cfg_zmalloc(unsigned int size) {
|
|
void *ptr = NULL;
|
|
ptr = cfg_malloc(size);
|
|
memset(ptr, 0, size);
|
|
return ptr;
|
|
}
|
|
|
|
void cfg_free(void *p_mem) { pool_free(p_mem); }
|
|
|
|
nvrec_config_t *nvrec_config_new(const char *filename) {
|
|
nvrec_config_t *config;
|
|
// add your code at here
|
|
// printf("nvrec_config_new-->cfg_zmalloc..........................\r\n");
|
|
config = (nvrec_config_t *)cfg_zmalloc(sizeof(nvrec_config_t));
|
|
if (config)
|
|
config->sections = list_new_ext(nvrec_section_free);
|
|
|
|
return config;
|
|
}
|
|
|
|
void nvrec_config_free(nvrec_config_t *config) {
|
|
if (!config)
|
|
return;
|
|
|
|
list_free_ext(config->sections);
|
|
// printf("nvrec_config_free-->cfg_free..........................\r\n");
|
|
cfg_free(config);
|
|
}
|
|
|
|
bool nvrec_config_has_section(const nvrec_config_t *config,
|
|
const char *section) {
|
|
assert(config != NULL);
|
|
assert(section != NULL);
|
|
|
|
return (nvrec_section_find(config, section) != NULL);
|
|
}
|
|
|
|
bool nvrec_config_has_key(const nvrec_config_t *config, const char *section,
|
|
const char *key) {
|
|
assert(config != NULL);
|
|
assert(section != NULL);
|
|
assert(key != NULL);
|
|
|
|
return (nvrec_entry_find(config, section, key) != NULL);
|
|
}
|
|
|
|
int nvrec_config_get_int(const nvrec_config_t *config, const char *section,
|
|
const char *key, int def_value) {
|
|
nvrec_entry_t *entry = NULL;
|
|
char *endptr = NULL;
|
|
int ret = 0;
|
|
assert(config != NULL);
|
|
assert(section != NULL);
|
|
assert(key != NULL);
|
|
|
|
entry = nvrec_entry_find(config, section, key);
|
|
if (!entry)
|
|
return def_value;
|
|
|
|
ret = strtol(entry->value, &endptr, 0);
|
|
return (*endptr == '\0') ? ret : def_value;
|
|
}
|
|
|
|
bool nvrec_config_get_bool(const nvrec_config_t *config, const char *section,
|
|
const char *key, bool def_value) {
|
|
nvrec_entry_t *entry = NULL;
|
|
assert(config != NULL);
|
|
assert(section != NULL);
|
|
assert(key != NULL);
|
|
|
|
entry = nvrec_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 *nvrec_config_get_string(const nvrec_config_t *config,
|
|
const char *section, const char *key,
|
|
const char *def_value) {
|
|
nvrec_entry_t *entry = NULL;
|
|
|
|
assert(config != NULL);
|
|
assert(section != NULL);
|
|
assert(key != NULL);
|
|
|
|
entry = nvrec_entry_find(config, section, key);
|
|
|
|
if (!entry)
|
|
return def_value;
|
|
|
|
return entry->value;
|
|
}
|
|
|
|
void nvrec_config_set_int(nvrec_config_t *config, const char *section,
|
|
const char *key, int value) {
|
|
|
|
char value_str[32] = {0};
|
|
assert(config != NULL);
|
|
assert(section != NULL);
|
|
assert(key != NULL);
|
|
|
|
sprintf(value_str, "%d", value);
|
|
nvrec_config_set_string(config, section, key, value_str);
|
|
}
|
|
|
|
void nvrec_config_set_bool(nvrec_config_t *config, const char *section,
|
|
const char *key, bool value) {
|
|
assert(config != NULL);
|
|
assert(section != NULL);
|
|
assert(key != NULL);
|
|
|
|
nvrec_config_set_string(config, section, key, value ? "true" : "false");
|
|
}
|
|
|
|
void *strdup_ext(const char *value) {
|
|
void *ptr = NULL;
|
|
|
|
if (NULL != value) {
|
|
size_t malloclen = (strlen(value) + 1);
|
|
ptr = zmalloc_ext(malloclen);
|
|
memcpy(ptr, value, strlen(value));
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
static char *bdaddrdup(const char *string, unsigned int len) {
|
|
char *memory;
|
|
|
|
if (!string)
|
|
return (NULL);
|
|
memory = cfg_zmalloc(len + 1);
|
|
if (NULL != memory) {
|
|
memcpy(memory, string, len);
|
|
return memory;
|
|
}
|
|
return (NULL);
|
|
}
|
|
|
|
void nvrec_config_set_string(nvrec_config_t *config, const char *section,
|
|
const char *key, const char *value) {
|
|
nvrec_entry_t *entry = NULL;
|
|
list_node_t *node = NULL;
|
|
nvrec_section_t *sec = nvrec_section_find(config, section);
|
|
if (!sec) {
|
|
sec = nvrec_section_new(section);
|
|
list_append_ext(config->sections, sec);
|
|
}
|
|
if (0 == strcmp(section, section_name_ddbrec)) {
|
|
for (node = list_begin_ext(sec->entries);
|
|
node != list_end_ext(sec->entries); node = list_next_ext(node)) {
|
|
entry = list_node_ext(node);
|
|
if (0 == memcmp(entry->key, key, BTIF_BD_ADDR_SIZE)) {
|
|
cfg_free(entry->value);
|
|
entry->value = (char *)strdup_ext(value);
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
for (node = list_begin_ext(sec->entries);
|
|
node != list_end_ext(sec->entries); node = list_next_ext(node)) {
|
|
entry = list_node_ext(node);
|
|
if (!strcmp(entry->key, key)) {
|
|
cfg_free(entry->value);
|
|
entry->value = (char *)strdup_ext(value);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
entry = nvrec_entry_new(key, value, section);
|
|
list_append_ext(sec->entries, entry);
|
|
}
|
|
|
|
static nvrec_section_t *nvrec_section_new(const char *name) {
|
|
// printf("nvrec_section_new-->cfg_zmalloc..........................\r\n");
|
|
nvrec_section_t *section = cfg_zmalloc(sizeof(nvrec_section_t));
|
|
if (!section)
|
|
return NULL;
|
|
|
|
section->name = strdup_ext(name);
|
|
section->entries = list_new_ext(nvrec_entry_free);
|
|
return section;
|
|
}
|
|
|
|
static void nvrec_section_free(void *ptr) {
|
|
nvrec_section_t *section = ptr;
|
|
if (!ptr)
|
|
return;
|
|
// printf("nvrec_section_free-->cfg_free..........................\r\n");
|
|
cfg_free(section->name);
|
|
list_free_ext(section->entries);
|
|
cfg_free(section);
|
|
}
|
|
|
|
nvrec_section_t *nvrec_section_find(const nvrec_config_t *config,
|
|
const char *section) {
|
|
nvrec_section_t *sec = NULL;
|
|
list_node_t *node = NULL;
|
|
for (node = list_begin_ext(config->sections);
|
|
node != list_end_ext(config->sections); node = list_next_ext(node)) {
|
|
sec = list_node_ext(node);
|
|
if (!strcmp(sec->name, section))
|
|
return sec;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static nvrec_entry_t *nvrec_entry_new(const char *key, const char *value,
|
|
const char *descrip) {
|
|
nvrec_entry_t *entry = cfg_zmalloc(sizeof(nvrec_entry_t));
|
|
if (!entry)
|
|
return NULL;
|
|
if (0 == strcmp(descrip, section_name_ddbrec))
|
|
entry->key = bdaddrdup(key, BTIF_BD_ADDR_SIZE);
|
|
else
|
|
entry->key = strdup_ext(key);
|
|
entry->value = strdup_ext(value);
|
|
return entry;
|
|
}
|
|
|
|
void nvrec_entry_free(void *ptr) {
|
|
nvrec_entry_t *entry = ptr;
|
|
if (!ptr)
|
|
return;
|
|
// printf("entry_free-->cfg_free..........................\r\n");
|
|
cfg_free(entry->key);
|
|
cfg_free(entry->value);
|
|
cfg_free(entry);
|
|
}
|
|
|
|
static nvrec_entry_t *nvrec_entry_find(const nvrec_config_t *config,
|
|
const char *section, const char *key) {
|
|
list_node_t *node = NULL;
|
|
nvrec_section_t *sec = nvrec_section_find(config, section);
|
|
if (!sec)
|
|
return NULL;
|
|
if (0 == strcmp(section, section_name_ddbrec)) {
|
|
for (node = list_begin_ext(sec->entries);
|
|
node != list_end_ext(sec->entries); node = list_next_ext(node)) {
|
|
nvrec_entry_t *entry = list_node_ext(node);
|
|
if (0 == memcmp((const void *)entry->key, (const void *)key,
|
|
BTIF_BD_ADDR_SIZE))
|
|
return entry;
|
|
}
|
|
return NULL;
|
|
} else {
|
|
for (node = list_begin_ext(sec->entries);
|
|
node != list_end_ext(sec->entries); node = list_next_ext(node)) {
|
|
nvrec_entry_t *entry = list_node_ext(node);
|
|
if (!strcmp(entry->key, key))
|
|
return entry;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
}
|
|
#if 0
|
|
int nevrec_entry_remove(const config_t *config, const char *section, const char *key) {
|
|
list_node_t *node;
|
|
section_t *sec = section_find(config, section);
|
|
if (!sec)
|
|
return NULL;
|
|
for (node = list_begin_ext(sec->entries); node != list_end_ext(sec->entries); node = list_next_ext(node)) {
|
|
entry_t *entry = list_node_ext(node);
|
|
if (!strcmp(entry->key, key))
|
|
list_remove_ext(sec->entries, entry);
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|