pinebuds/services/nvrecord/nvrec_config.c
Ben V. Brown 75381150fd Formatting
Formatting Pass 1

Lots of fixups to adding stdint and stdbool all over the place

Formatting Pass 2
Formatting Pass 3
Formatting Pass 4

Update app_bt_stream.cpp
2023-02-02 07:56:49 +11:00

322 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