common/ini/ini_handler.c - u-boot - Git at Google

 /*
  * Author:  Shoufu Zhao <shoufu.zhao@amlogic.com>
  */

 #include "ini_config.h"

 #define LOG_TAG "ini_handler"
 #define LOG_NDEBUG 0

 #include "ini_log.h"

 #include "ini_core.h"
 #include "ini_handler.h"
 #include "ini_platform.h"

 static void trim(char *str, char ch);
 static void trim_all(char *str);
 static INI_SECTION* getSection(const char* section, INI_HANDLER_DATA *pHandlerData);
 static INI_LINE* getKeyLineAtSec(INI_SECTION* pSec, const char* key);
 static int setKeyValue(void* user, const char* section, const char* name, const char* value, int set_mode);
 static int handler(void* user, const char* section, const char* name, const char* value);
 static INI_LINE* newLine(const char* name, const char* value);
 static INI_SECTION* newSection(const char* section, INI_LINE* pLINE);

 #if CC_MEMORY_ALLOC_FREE_TRACE == 1
 static void alloc_mem(const char *fun_name, const char *var_name, void *ptr);
 static void free_mem(const char *fun_name, const char *var_name, void *ptr);
 static void printAllocMemND(const char *fun_name);
 static void printFreeMemND(const char *fun_name);
 static void clearMemND(void);
 #endif

 int ini_file_parse(const char* filename, INI_HANDLER_DATA *pHandlerData) {
     int tmp_ret = -1, rd_cnt = 0, file_size = 0;
     unsigned char *tmp_buf = NULL;

     if (!iniIsFileExist(filename)) {
         ALOGE("%s, file \"%s\" is not exist!\n", __FUNCTION__, filename);
         return -1;
     }

     file_size = iniGetFileSize(filename);
     if (file_size <= 0) {
         ALOGE("%s, file \"%s\" size error!\n", __FUNCTION__, filename);
         return -1;
     }

     tmp_buf = (unsigned char *) malloc(file_size * 2);
     if (tmp_buf != NULL) {
         strncpy(pHandlerData->mpFileName, filename, CC_MAX_INI_FILE_NAME_LEN - 1);

         rd_cnt = iniReadFileToBuffer(filename, 0, file_size, tmp_buf);
         if (rd_cnt > 0) {
             tmp_ret = ini_mem_parse(tmp_buf, pHandlerData);
         }

         free(tmp_buf);
         tmp_buf = NULL;
     }

     return tmp_ret;
 }

 int ini_mem_parse(unsigned char* file_buf, INI_HANDLER_DATA *pHandlerData) {
     //ALOGD("%s, entering...\n", __FUNCTION__);
     return ini_parse_mem((char *)file_buf, handler, (void *)pHandlerData);
 }

 int ini_set_save_file_name(const char* filename, INI_HANDLER_DATA *pHandlerData) {
     //ALOGD("%s, entering...\n", __FUNCTION__);

     strncpy(pHandlerData->mpFileName, filename, CC_MAX_INI_FILE_NAME_LEN - 1);
     return 0;
 }

 void ini_free_mem(INI_HANDLER_DATA *pHandlerData) {
     //ALOGD("%s, entering...\n", __FUNCTION__);

     INI_SECTION* pNextSec = NULL;
     INI_SECTION* pSec = NULL;
     for (pSec = pHandlerData->mpFirstSection; pSec != NULL;) {
         pNextSec = pSec->pNext;

         INI_LINE* pNextLine = NULL;
         INI_LINE* pLine = NULL;
         for (pLine = pSec->pLine; pLine != NULL;) {
             pNextLine = pLine->pNext;

             if (pLine != NULL) {
 #if CC_MEMORY_ALLOC_FREE_TRACE == 1
                 free_mem(__FUNCTION__, "pLine", pLine);
 #endif

                 free(pLine);
                 pLine = NULL;
             }

             pLine = pNextLine;
         }

         if (pSec != NULL) {
 #if CC_MEMORY_ALLOC_FREE_TRACE == 1
             free_mem(__FUNCTION__, "pSec", pSec);
 #endif

             free(pSec);
             pSec = NULL;
         }

         pSec = pNextSec;
     }

     pHandlerData->mpFirstSection = NULL;
     pHandlerData->mpCurSection = NULL;

 #if CC_MEMORY_ALLOC_FREE_TRACE == 1
     printAllocMemND(__FUNCTION__);
     printFreeMemND(__FUNCTION__);
     clearMemND();
 #endif
 }

 static void trim(char *str, char ch) {
     char* pStr;

     pStr = str;
     while (*pStr != '\0') {
         if (*pStr == ch) {
             char* pTmp = pStr;
             while (*pTmp != '\0') {
                 *pTmp = *(pTmp + 1);
                 pTmp++;
             }
         } else {
             pStr++;
         }
     }
 }

 static void trim_all(char *str) {
     char* pStr = NULL;

     pStr = strchr(str, '\n');
     if (pStr != NULL) {
         *pStr = 0;
     }

     int Len = strlen(str);
     if (Len > 0) {
         if (str[Len - 1] == '\r') {
             str[Len - 1] = '\0';
         }
     }

     pStr = strchr(str, '#');
     if (pStr != NULL) {
         *pStr = 0;
     }

     pStr = strchr(str, ';');
     if (pStr != NULL) {
         *pStr = 0;
     }

     trim(str, ' ');
     trim(str, '{');
     trim(str, '\\');
     trim(str, '}');
     trim(str, '\"');
     return;
 }

 void ini_print_all(INI_HANDLER_DATA *pHandlerData) {
     INI_SECTION* pSec = NULL;
     for (pSec = pHandlerData->mpFirstSection; pSec != NULL; pSec = pSec->pNext) {
         ALOGD("[%s]\n", pSec->Name);
         INI_LINE* pLine = NULL;
         for (pLine = pSec->pLine; pLine != NULL; pLine = pLine->pNext) {
             ALOGD("%s = %s\n", pLine->Name, pLine->Value);
         }
         ALOGD("\n\n\n");
     }
 }

 static INI_SECTION* getSection(const char* section, INI_HANDLER_DATA *pHandlerData) {
     INI_SECTION* pSec = NULL;
     for (pSec = pHandlerData->mpFirstSection; pSec != NULL; pSec = pSec->pNext) {
         if (strncmp(pSec->Name, section, strlen(section)) == 0) {
             return pSec;
         }
     }

     return NULL;
 }

 static INI_LINE* getKeyLineAtSec(INI_SECTION* pSec, const char* key) {
     INI_LINE* pLine = NULL;
     for (pLine = pSec->pLine; pLine != NULL; pLine = pLine->pNext) {
         if (strncmp(pLine->Name, key, strlen(key)) == 0) {
             return pLine;
         }
     }
     return NULL;
 }

 const char* ini_get_string(const char* section, const char* key,
         const char* def_value, INI_HANDLER_DATA *pHandlerData) {
     INI_SECTION* pSec = getSection(section, pHandlerData);
     if (pSec == NULL) {
         //ALOGD("%s, section %s is NULL\n", __FUNCTION__, section);
         return def_value;
     }

     INI_LINE* pLine = getKeyLineAtSec(pSec, key);
     if (pLine == NULL) {
         //ALOGD("%s, key \"%s\" is NULL\n", __FUNCTION__, key);
         return def_value;
     }

     return pLine->Value;
 }

 int ini_set_string(const char *section, const char *key, const char *value, INI_HANDLER_DATA *pHandlerData) {
     setKeyValue(pHandlerData, section, key, value, 1);
     return 0;
 }

 int ini_save_to_file(const char *filename, INI_HANDLER_DATA *pHandlerData) {
 #if (defined CC_COMPILE_IN_PC || defined CC_COMPILE_IN_ANDROID)
     const char *fname = NULL;
     FILE *fp = NULL;

     if (filename == NULL) {
         if (strlen(pHandlerData->mpFileName) == 0) {
             ALOGE("%s, save file name is NULL!!!\n", __FUNCTION__);
             return -1;
         } else {
             fname = pHandlerData->mpFileName;
         }
     } else {
         fname = filename;
     }

     if ((fp = fopen (fname, "wb")) == NULL) {
         ALOGE("%s, Open file \"%s\" ERROR (%s)!!!\n", __FUNCTION__, fname, strerror(errno));
         return -1;
     }

     INI_SECTION* pSec = NULL;
     for (pSec = pHandlerData->mpFirstSection; pSec != NULL; pSec = pSec->pNext) {
         fprintf(fp, "[%s]\r\n", pSec->Name);
         INI_LINE* pLine = NULL;
         for (pLine = pSec->pLine; pLine != NULL; pLine = pLine->pNext) {
             fprintf(fp, "%s = %s\r\n", pLine->Name, pLine->Value);
         }
     }

     fflush(fp);
     fsync(fileno(fp));

     fclose(fp);
     fp = NULL;

     return 0;
 #elif (defined CC_COMPILE_IN_UBOOT)
     return 0;
 #endif
 }

 static INI_LINE* newLine(const char* name, const char* value) {
     INI_LINE* pLine = NULL;

     pLine = (INI_LINE*) malloc(sizeof(INI_LINE));
     if (pLine != NULL) {
         pLine->pNext = NULL;
         strcpy(pLine->Name, name);
         strcpy(pLine->Value, value);

 #if CC_MEMORY_ALLOC_FREE_TRACE == 1
         alloc_mem(__FUNCTION__, "pLine", pLine);
 #endif
     }

     return pLine;
 }

 static INI_SECTION* newSection(const char* section, INI_LINE* pLine) {
     INI_SECTION* pSec = NULL;

     pSec = (INI_SECTION*) malloc(sizeof(INI_SECTION));
     if (pSec != NULL) {
         pSec->pLine = pLine;
         pSec->pNext = NULL;
         strcpy(pSec->Name, section);

 #if CC_MEMORY_ALLOC_FREE_TRACE == 1
         alloc_mem(__FUNCTION__, "pSec", pSec);
 #endif
     }

     return pSec;
 }

 static int setKeyValue(void* user, const char* section, const char* key, const char* value, int set_mode) {
     INI_LINE* pLine = NULL;
     INI_SECTION *pSec = NULL;
     INI_HANDLER_DATA *pHandlerData = (INI_HANDLER_DATA *) user;

     if (section == NULL || key == NULL || value == NULL) {
         return 1;
     }

     trim_all((char *) value);
     if (value[0] == '\0') {
         return 1;
     }

     if (strlen(key) > CC_MAX_INI_LINE_NAME_LEN) {
         ALOGE("key name is too long, limit %d.\n", CC_MAX_INI_LINE_NAME_LEN);
         return 1;
     }
     if (strlen(value) > CC_MAX_INI_FILE_LINE_LEN) {
         ALOGE("key name is too long, limit %d.\n", CC_MAX_INI_FILE_LINE_LEN);
         return 1;
     }

     if (pHandlerData->mpFirstSection == NULL) {
         pLine = newLine(key, value);
         pSec = newSection(section, pLine);

         pHandlerData->mpFirstSection = pSec;
         pHandlerData->mpCurSection = pSec;
         pSec->pCurLine = pLine;
     } else {
         pSec = getSection(section, pHandlerData);
         if (pSec == NULL) {
             pLine = newLine(key, value);
             pSec = newSection(section, pLine);

             pHandlerData->mpCurSection->pNext = pSec;
             pHandlerData->mpCurSection = pSec;
             pSec->pCurLine = pLine;

             pSec->pCurLine = pLine;
         } else {
             pLine = getKeyLineAtSec(pSec, key);
             if (pLine == NULL) {
                 pLine = newLine(key, value);

                 pSec->pCurLine->pNext = pLine;
                 pSec->pCurLine = pLine;
             } else {
                 if (set_mode == 1) {
                     strcpy(pLine->Value, value);
                 } else {
                     strcat(pLine->Value, value);
                 }
             }
         }
     }

     return 0;
 }

 static int handler(void* user, const char* section, const char* name,
         const char* value) {
     //ALOGD("%s, section = %s, name = %s, value = %s\n", __FUNCTION__, section, name, value);
     setKeyValue(user, section, name, value, 0);
     return 1;
 }

 #if CC_MEMORY_ALLOC_FREE_TRACE == 1

 #define CC_MEM_RECORD_CNT    (1024)

 typedef struct tag_memnd {
     char fun_name[50];
     char var_name[50];
     void *ptr;
 } memnd;

 static memnd gMemAllocItems[CC_MEM_RECORD_CNT];
 static int gMemAllocInd = 0;

 static memnd gMemFreeItems[CC_MEM_RECORD_CNT];
 static int gMemFreeInd = 0;

 static void alloc_mem(const char *fun_name, const char *var_name, void *ptr) {
     strcpy(gMemAllocItems[gMemAllocInd].fun_name, fun_name);
     strcpy(gMemAllocItems[gMemAllocInd].var_name, var_name);
     gMemAllocItems[gMemAllocInd].ptr = ptr;

     gMemAllocInd += 1;
 }

 static void free_mem(const char *fun_name, const char *var_name, void *ptr) {
     strcpy(gMemFreeItems[gMemFreeInd].fun_name, fun_name);
     strcpy(gMemFreeItems[gMemFreeInd].var_name, var_name);
     gMemFreeItems[gMemFreeInd].ptr = ptr;

     gMemFreeInd += 1;
 }

 static void printMemND(const char *fun_name, memnd *tmp_nd, int tmp_cnt) {
 #if CC_MEMORY_ALLOC_FREE_TRACE_PRINT_ALL == 1
     int i = 0;

     ALOGD("fun_name = %s, total_cnt = %d\n", fun_name, tmp_cnt);

     for (i = 0; i < tmp_cnt; i++) {
         ALOGD("fun_name = %s, var_name = %s, ptr = %p\n", tmp_nd[i].fun_name, tmp_nd[i].var_name, tmp_nd[i].ptr);
     }
 #endif
 }

 static void printFreeMemND(const char *fun_name) {
     printMemND(__FUNCTION__, gMemFreeItems, gMemFreeInd);
 }

 static void printAllocMemND(const char *fun_name) {
     printMemND(__FUNCTION__, gMemAllocItems, gMemAllocInd);
 }

 static void clearMemND(void) {
     gMemAllocInd = 0;
     gMemFreeInd = 0;
     memset((void *)gMemAllocItems, 0, sizeof(memnd) * CC_MEM_RECORD_CNT);
     memset((void *)gMemFreeItems, 0, sizeof(memnd) * CC_MEM_RECORD_CNT);
 }
 #endif
	/*
	* Author: Shoufu Zhao <shoufu.zhao@amlogic.com>
	*/

	#include "ini_config.h"

	#define LOG_TAG "ini_handler"
	#define LOG_NDEBUG 0

	#include "ini_log.h"

	#include "ini_core.h"
	#include "ini_handler.h"
	#include "ini_platform.h"

	static void trim(char *str, char ch);
	static void trim_all(char *str);
	static INI_SECTION* getSection(const char* section, INI_HANDLER_DATA *pHandlerData);
	static INI_LINE* getKeyLineAtSec(INI_SECTION* pSec, const char* key);
	static int setKeyValue(void* user, const char* section, const char* name, const char* value, int set_mode);
	static int handler(void* user, const char* section, const char* name, const char* value);
	static INI_LINE* newLine(const char* name, const char* value);
	static INI_SECTION* newSection(const char* section, INI_LINE* pLINE);

	#if CC_MEMORY_ALLOC_FREE_TRACE == 1
	static void alloc_mem(const char fun_name, const char var_name, void *ptr);
	static void free_mem(const char fun_name, const char var_name, void *ptr);
	static void printAllocMemND(const char *fun_name);
	static void printFreeMemND(const char *fun_name);
	static void clearMemND(void);
	#endif

	int ini_file_parse(const char* filename, INI_HANDLER_DATA *pHandlerData) {
	int tmp_ret = -1, rd_cnt = 0, file_size = 0;
	unsigned char *tmp_buf = NULL;

	if (!iniIsFileExist(filename)) {
	ALOGE("%s, file \"%s\" is not exist!\n", __FUNCTION__, filename);
	return -1;
	}

	file_size = iniGetFileSize(filename);
	if (file_size <= 0) {
	ALOGE("%s, file \"%s\" size error!\n", __FUNCTION__, filename);
	return -1;
	}

	tmp_buf = (unsigned char ) malloc(file_size 2);
	if (tmp_buf != NULL) {
	strncpy(pHandlerData->mpFileName, filename, CC_MAX_INI_FILE_NAME_LEN - 1);

	rd_cnt = iniReadFileToBuffer(filename, 0, file_size, tmp_buf);
	if (rd_cnt > 0) {
	tmp_ret = ini_mem_parse(tmp_buf, pHandlerData);
	}

	free(tmp_buf);
	tmp_buf = NULL;
	}

	return tmp_ret;
	}

	int ini_mem_parse(unsigned char* file_buf, INI_HANDLER_DATA *pHandlerData) {
	//ALOGD("%s, entering...\n", __FUNCTION__);
	return ini_parse_mem((char )file_buf, handler, (void )pHandlerData);
	}

	int ini_set_save_file_name(const char* filename, INI_HANDLER_DATA *pHandlerData) {
	//ALOGD("%s, entering...\n", __FUNCTION__);

	strncpy(pHandlerData->mpFileName, filename, CC_MAX_INI_FILE_NAME_LEN - 1);
	return 0;
	}

	void ini_free_mem(INI_HANDLER_DATA *pHandlerData) {
	//ALOGD("%s, entering...\n", __FUNCTION__);

	INI_SECTION* pNextSec = NULL;
	INI_SECTION* pSec = NULL;
	for (pSec = pHandlerData->mpFirstSection; pSec != NULL;) {
	pNextSec = pSec->pNext;

	INI_LINE* pNextLine = NULL;
	INI_LINE* pLine = NULL;
	for (pLine = pSec->pLine; pLine != NULL;) {
	pNextLine = pLine->pNext;

	if (pLine != NULL) {
	#if CC_MEMORY_ALLOC_FREE_TRACE == 1
	free_mem(__FUNCTION__, "pLine", pLine);
	#endif

	free(pLine);
	pLine = NULL;
	}

	pLine = pNextLine;
	}

	if (pSec != NULL) {
	#if CC_MEMORY_ALLOC_FREE_TRACE == 1
	free_mem(__FUNCTION__, "pSec", pSec);
	#endif

	free(pSec);
	pSec = NULL;
	}

	pSec = pNextSec;
	}

	pHandlerData->mpFirstSection = NULL;
	pHandlerData->mpCurSection = NULL;

	#if CC_MEMORY_ALLOC_FREE_TRACE == 1
	printAllocMemND(__FUNCTION__);
	printFreeMemND(__FUNCTION__);
	clearMemND();
	#endif
	}

	static void trim(char *str, char ch) {
	char* pStr;

	pStr = str;
	while (*pStr != '\0') {
	if (*pStr == ch) {
	char* pTmp = pStr;
	while (*pTmp != '\0') {
	pTmp = (pTmp + 1);
	pTmp++;
	}
	} else {
	pStr++;
	}
	}
	}

	static void trim_all(char *str) {
	char* pStr = NULL;

	pStr = strchr(str, '\n');
	if (pStr != NULL) {
	*pStr = 0;
	}

	int Len = strlen(str);
	if (Len > 0) {
	if (str[Len - 1] == '\r') {
	str[Len - 1] = '\0';
	}
	}

	pStr = strchr(str, '#');
	if (pStr != NULL) {
	*pStr = 0;
	}

	pStr = strchr(str, ';');
	if (pStr != NULL) {
	*pStr = 0;
	}

	trim(str, ' ');
	trim(str, '{');
	trim(str, '\\');
	trim(str, '}');
	trim(str, '\"');
	return;
	}

	void ini_print_all(INI_HANDLER_DATA *pHandlerData) {
	INI_SECTION* pSec = NULL;
	for (pSec = pHandlerData->mpFirstSection; pSec != NULL; pSec = pSec->pNext) {
	ALOGD("[%s]\n", pSec->Name);
	INI_LINE* pLine = NULL;
	for (pLine = pSec->pLine; pLine != NULL; pLine = pLine->pNext) {
	ALOGD("%s = %s\n", pLine->Name, pLine->Value);
	}
	ALOGD("\n\n\n");
	}
	}

	static INI_SECTION* getSection(const char* section, INI_HANDLER_DATA *pHandlerData) {
	INI_SECTION* pSec = NULL;
	for (pSec = pHandlerData->mpFirstSection; pSec != NULL; pSec = pSec->pNext) {
	if (strncmp(pSec->Name, section, strlen(section)) == 0) {
	return pSec;
	}
	}

	return NULL;
	}

	static INI_LINE* getKeyLineAtSec(INI_SECTION* pSec, const char* key) {
	INI_LINE* pLine = NULL;
	for (pLine = pSec->pLine; pLine != NULL; pLine = pLine->pNext) {
	if (strncmp(pLine->Name, key, strlen(key)) == 0) {
	return pLine;
	}
	}
	return NULL;
	}

	const char* ini_get_string(const char* section, const char* key,
	const char* def_value, INI_HANDLER_DATA *pHandlerData) {
	INI_SECTION* pSec = getSection(section, pHandlerData);
	if (pSec == NULL) {
	//ALOGD("%s, section %s is NULL\n", __FUNCTION__, section);
	return def_value;
	}

	INI_LINE* pLine = getKeyLineAtSec(pSec, key);
	if (pLine == NULL) {
	//ALOGD("%s, key \"%s\" is NULL\n", __FUNCTION__, key);
	return def_value;
	}

	return pLine->Value;
	}

	int ini_set_string(const char section, const char key, const char value, INI_HANDLER_DATA pHandlerData) {
	setKeyValue(pHandlerData, section, key, value, 1);
	return 0;
	}

	int ini_save_to_file(const char filename, INI_HANDLER_DATA pHandlerData) {
	#if (defined CC_COMPILE_IN_PC \|\| defined CC_COMPILE_IN_ANDROID)
	const char *fname = NULL;
	FILE *fp = NULL;

	if (filename == NULL) {
	if (strlen(pHandlerData->mpFileName) == 0) {
	ALOGE("%s, save file name is NULL!!!\n", __FUNCTION__);
	return -1;
	} else {
	fname = pHandlerData->mpFileName;
	}
	} else {
	fname = filename;
	}

	if ((fp = fopen (fname, "wb")) == NULL) {
	ALOGE("%s, Open file \"%s\" ERROR (%s)!!!\n", __FUNCTION__, fname, strerror(errno));
	return -1;
	}

	INI_SECTION* pSec = NULL;
	for (pSec = pHandlerData->mpFirstSection; pSec != NULL; pSec = pSec->pNext) {
	fprintf(fp, "[%s]\r\n", pSec->Name);
	INI_LINE* pLine = NULL;
	for (pLine = pSec->pLine; pLine != NULL; pLine = pLine->pNext) {
	fprintf(fp, "%s = %s\r\n", pLine->Name, pLine->Value);
	}
	}

	fflush(fp);
	fsync(fileno(fp));

	fclose(fp);
	fp = NULL;

	return 0;
	#elif (defined CC_COMPILE_IN_UBOOT)
	return 0;
	#endif
	}

	static INI_LINE* newLine(const char* name, const char* value) {
	INI_LINE* pLine = NULL;

	pLine = (INI_LINE*) malloc(sizeof(INI_LINE));
	if (pLine != NULL) {
	pLine->pNext = NULL;
	strcpy(pLine->Name, name);
	strcpy(pLine->Value, value);

	#if CC_MEMORY_ALLOC_FREE_TRACE == 1
	alloc_mem(__FUNCTION__, "pLine", pLine);
	#endif
	}

	return pLine;
	}

	static INI_SECTION* newSection(const char* section, INI_LINE* pLine) {
	INI_SECTION* pSec = NULL;

	pSec = (INI_SECTION*) malloc(sizeof(INI_SECTION));
	if (pSec != NULL) {
	pSec->pLine = pLine;
	pSec->pNext = NULL;
	strcpy(pSec->Name, section);

	#if CC_MEMORY_ALLOC_FREE_TRACE == 1
	alloc_mem(__FUNCTION__, "pSec", pSec);
	#endif
	}

	return pSec;
	}

	static int setKeyValue(void* user, const char* section, const char* key, const char* value, int set_mode) {
	INI_LINE* pLine = NULL;
	INI_SECTION *pSec = NULL;
	INI_HANDLER_DATA pHandlerData = (INI_HANDLER_DATA ) user;

	if (section == NULL \|\| key == NULL \|\| value == NULL) {
	return 1;
	}

	trim_all((char *) value);
	if (value[0] == '\0') {
	return 1;
	}

	if (strlen(key) > CC_MAX_INI_LINE_NAME_LEN) {
	ALOGE("key name is too long, limit %d.\n", CC_MAX_INI_LINE_NAME_LEN);
	return 1;
	}
	if (strlen(value) > CC_MAX_INI_FILE_LINE_LEN) {
	ALOGE("key name is too long, limit %d.\n", CC_MAX_INI_FILE_LINE_LEN);
	return 1;
	}

	if (pHandlerData->mpFirstSection == NULL) {
	pLine = newLine(key, value);
	pSec = newSection(section, pLine);

	pHandlerData->mpFirstSection = pSec;
	pHandlerData->mpCurSection = pSec;
	pSec->pCurLine = pLine;
	} else {
	pSec = getSection(section, pHandlerData);
	if (pSec == NULL) {
	pLine = newLine(key, value);
	pSec = newSection(section, pLine);

	pHandlerData->mpCurSection->pNext = pSec;
	pHandlerData->mpCurSection = pSec;
	pSec->pCurLine = pLine;

	pSec->pCurLine = pLine;
	} else {
	pLine = getKeyLineAtSec(pSec, key);
	if (pLine == NULL) {
	pLine = newLine(key, value);

	pSec->pCurLine->pNext = pLine;
	pSec->pCurLine = pLine;
	} else {
	if (set_mode == 1) {
	strcpy(pLine->Value, value);
	} else {
	strcat(pLine->Value, value);
	}
	}
	}
	}

	return 0;
	}

	static int handler(void* user, const char* section, const char* name,
	const char* value) {
	//ALOGD("%s, section = %s, name = %s, value = %s\n", __FUNCTION__, section, name, value);
	setKeyValue(user, section, name, value, 0);
	return 1;
	}

	#if CC_MEMORY_ALLOC_FREE_TRACE == 1

	#define CC_MEM_RECORD_CNT (1024)

	typedef struct tag_memnd {
	char fun_name[50];
	char var_name[50];
	void *ptr;
	} memnd;

	static memnd gMemAllocItems[CC_MEM_RECORD_CNT];
	static int gMemAllocInd = 0;

	static memnd gMemFreeItems[CC_MEM_RECORD_CNT];
	static int gMemFreeInd = 0;

	static void alloc_mem(const char fun_name, const char var_name, void *ptr) {
	strcpy(gMemAllocItems[gMemAllocInd].fun_name, fun_name);
	strcpy(gMemAllocItems[gMemAllocInd].var_name, var_name);
	gMemAllocItems[gMemAllocInd].ptr = ptr;

	gMemAllocInd += 1;
	}

	static void free_mem(const char fun_name, const char var_name, void *ptr) {
	strcpy(gMemFreeItems[gMemFreeInd].fun_name, fun_name);
	strcpy(gMemFreeItems[gMemFreeInd].var_name, var_name);
	gMemFreeItems[gMemFreeInd].ptr = ptr;

	gMemFreeInd += 1;
	}

	static void printMemND(const char fun_name, memnd tmp_nd, int tmp_cnt) {
	#if CC_MEMORY_ALLOC_FREE_TRACE_PRINT_ALL == 1
	int i = 0;

	ALOGD("fun_name = %s, total_cnt = %d\n", fun_name, tmp_cnt);

	for (i = 0; i < tmp_cnt; i++) {
	ALOGD("fun_name = %s, var_name = %s, ptr = %p\n", tmp_nd[i].fun_name, tmp_nd[i].var_name, tmp_nd[i].ptr);
	}
	#endif
	}

	static void printFreeMemND(const char *fun_name) {
	printMemND(__FUNCTION__, gMemFreeItems, gMemFreeInd);
	}

	static void printAllocMemND(const char *fun_name) {
	printMemND(__FUNCTION__, gMemAllocItems, gMemAllocInd);
	}

	static void clearMemND(void) {
	gMemAllocInd = 0;
	gMemFreeInd = 0;
	memset((void )gMemAllocItems, 0, sizeof(memnd) CC_MEM_RECORD_CNT);
	memset((void )gMemFreeItems, 0, sizeof(memnd) CC_MEM_RECORD_CNT);
	}
	#endif