pinebuds/services/nvrecord/nvrec_config.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 <assert.h>
#include <ctype.h>
#include "stdio.h"
#include <stdlib.h>
#include <string.h>
#include "list_ext.h"
#include "nvrecord.h"
#include "nvrec_config.h"
#include "hal_trace.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