262 lines
8.1 KiB
C
262 lines
8.1 KiB
C
#include"config.h"
|
|
#include<stdio.h>
|
|
#include<stdlib.h>
|
|
#include<string.h>
|
|
/*
|
|
* Here we check if the given string contains a section
|
|
* for example [SECTIONName] here delimiterLeft is [ and delimiterRight is ]
|
|
* if a section is found, the section name will be written to sectionName
|
|
*
|
|
* Input:
|
|
* char **str: the string to check
|
|
* char delimiterLeft: the left delimiter to check for
|
|
* char delimiterRight: the right delimiter to check for
|
|
* Output:
|
|
* char **sectionName: if found the section Name of the section
|
|
* Return:
|
|
* int status_code: one of the following values:
|
|
*
|
|
*/
|
|
|
|
int checkSection(char *str,char delimiterLeft,char delimiterRight,char **sectionName)
|
|
{
|
|
char section[MAX_LEN_SECTIONNAME];
|
|
int i = 0; //most outer loop -> character of string
|
|
if(str == NULL)
|
|
{
|
|
return ERROR_STR;
|
|
}
|
|
int len = strlen(str);
|
|
printf("strlen: %d",len);
|
|
int state = ST_INIT;
|
|
int leftDelimiterPos=0;
|
|
int rightDelimiterPos=0;
|
|
char *sectionName2 = NULL;
|
|
while(state != ST_FINISH)
|
|
{
|
|
printf("STATE:%i\n",state);
|
|
switch(state)
|
|
{
|
|
case ST_INIT:
|
|
for(i=0;i<=len;i++) //find first (left) delimiter
|
|
{
|
|
if(str[i] == delimiterLeft)
|
|
{
|
|
state = ST_FOUND_LEFT_DELIMITER;
|
|
leftDelimiterPos = i;
|
|
break;
|
|
}
|
|
}
|
|
if(state != ST_FOUND_LEFT_DELIMITER)
|
|
{
|
|
return ST_ERROR_NOT_FOUND_LEFT_DELIMITER;
|
|
}
|
|
break;
|
|
case ST_FOUND_LEFT_DELIMITER:
|
|
for(i=0;i<=len;i++) //find second (right) delimiter
|
|
{
|
|
if(str[i] == delimiterRight)
|
|
{
|
|
state = ST_FOUND_RIGHT_DELIMITER;
|
|
rightDelimiterPos = i;
|
|
break;
|
|
}
|
|
}
|
|
if(state != ST_FOUND_RIGHT_DELIMITER)
|
|
{
|
|
return ST_ERROR_NOT_FOUND_RIGHT_DELIMITER;
|
|
}
|
|
break;
|
|
case ST_FOUND_RIGHT_DELIMITER:
|
|
int ret=0;
|
|
if((ret=getStrAtPos(str,leftDelimiterPos,rightDelimiterPos,sectionName,MAX_LEN_SECTIONNAME)) == NO_ERROR)
|
|
{
|
|
state = ST_FINISH;
|
|
}else{
|
|
return ret;
|
|
}
|
|
case ST_FINISH:
|
|
return FOUND_SECTION;
|
|
}
|
|
}
|
|
return NO_SECTION;
|
|
}
|
|
/*
|
|
* Here we get / cut from fromPos to toPos and write it to an address
|
|
*
|
|
* Input:
|
|
* char *str: the string to cut
|
|
* int fromPos: from which position we want to copy, the pos is included and zero indexed
|
|
* int toPos: to which position we want to copy, the pos is included and zero indexed
|
|
* Output:
|
|
* char **name: here we will write the section name to
|
|
* Input:
|
|
* int sizeName: the size of the user allocated buffer at **name
|
|
*/
|
|
|
|
int getStrAtPos(char *str,int fromPos,int toPos,char **name,int sizeName)
|
|
{
|
|
int i=fromPos; //character iterator, which starts from specified pos
|
|
int j=0; //the character iterator for the target string
|
|
int diffLen=toPos-fromPos;
|
|
char *ptr_name=*name;
|
|
if(diffLen > MAX_LEN_SECTIONNAME || diffLen>sizeName)
|
|
{
|
|
return ERROR_MAX_LEN;
|
|
}
|
|
for(i=fromPos,j=0;i<=toPos;i++,j++)
|
|
{
|
|
ptr_name[j] = str[i];
|
|
}
|
|
ptr_name[j+1]='\0';
|
|
//printf("*name:%s\n",ptr_name);
|
|
return NO_ERROR;
|
|
}
|
|
/*
|
|
*Here we get a "pair" of data, parsed from *str, witch consists of a keyname and a keyvalue.
|
|
*These are written to the pointers at char **name and char **value.
|
|
*These pair can be in the form of:
|
|
* ex1:
|
|
* NAME=VALUE
|
|
* ^ ^
|
|
* | Here we have no delimiter this means rightDelimiterPos must be NULL
|
|
* This is the left delimiter
|
|
* ex2:
|
|
* name(value)
|
|
* ^ ^
|
|
* | This is the rightDelimiterPos and must be ')'
|
|
* This is leftDelimiterPos which must be '('
|
|
*
|
|
* Input:
|
|
* char *str: the line in the form of a string where a key value pair is stored
|
|
* char leftDelimiterPos: the left delimiter for example '='
|
|
* char rightDelimiterPos: the right delimiter can be NULL in most cases, if NULL we assume that there is only one delimiter, which is in this case the leftDelimiterPos
|
|
* Output:
|
|
* char **name: The address where we store the name of the Key
|
|
* char **value: The address where we store the key value
|
|
* int sizeName: for size checking against memory allocated at **name
|
|
* int sizeValue: for size checking against memory allocated at **value
|
|
*
|
|
* Return:
|
|
* will return NO_ERROR (0) if successfull.
|
|
* If not it will return the error of the subroutine
|
|
*/
|
|
|
|
int getNameValuePair(char *str,char leftDelimiterPos,char rightDelimiterPos,char **name,char **value,int sizeName,int sizeValue)
|
|
{
|
|
int state=ST_INIT;
|
|
char *ptr_name=*name;
|
|
char *ptr_value=*value;
|
|
int ret=0;
|
|
|
|
char *ptrDelimiter=NULL;
|
|
int posDelimiter=0;
|
|
int posEnd=0;
|
|
|
|
ptrDelimiter=strchr(str,leftDelimiterPos);
|
|
if(ptrDelimiter==NULL)
|
|
{
|
|
return ERROR_DELIMITER_NOT_FOUND;
|
|
}
|
|
posDelimiter = (ptrDelimiter - str);
|
|
printf("LenUntilDelimiter: %d",posDelimiter);
|
|
if((ret=getStrAtPos(str,0,posDelimiter-1,&ptr_name,sizeName)) == NO_ERROR)
|
|
{
|
|
printf("ptr_name:%s",ptr_name);
|
|
}else {
|
|
return ret;
|
|
}
|
|
if(rightDelimiterPos == 0)
|
|
{
|
|
posEnd = strlen(str);
|
|
}else{
|
|
posEnd = rightDelimiterPos;
|
|
}
|
|
|
|
if((ret=getStrAtPos(str,posDelimiter+1,posEnd,&ptr_value,sizeValue)) == NO_ERROR)
|
|
{
|
|
printf("ptr_name:%s\n",ptr_value);
|
|
}else {
|
|
return ret;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
|
|
int parseConfig(char *buffer,struct configEntry **entry,int configSizeCount,int *returnedCount)
|
|
{
|
|
int state=ST_INIT;
|
|
int ret=0;
|
|
int i=0;
|
|
char *sectionName=NULL;
|
|
struct configEntry *ptr_entry = *entry;
|
|
char *keyName=NULL;
|
|
char *keyValue=NULL;
|
|
|
|
sectionName = malloc(MAX_LEN_SECTIONNAME);
|
|
memset(sectionName,0,MAX_LEN_SECTIONNAME);
|
|
|
|
//read buffer line by line
|
|
char *token;
|
|
token = strtok(buffer,"\n");
|
|
while(token != NULL && state != ST_FINISH)
|
|
{
|
|
switch(state)
|
|
{
|
|
case ST_INIT:
|
|
printf("token(line): %s\n",token);
|
|
|
|
if((ret=checkSection(token,'[',']',§ionName))==FOUND_SECTION)
|
|
{
|
|
state = ST_FOUND_SECTION;
|
|
}
|
|
break;
|
|
case ST_FOUND_SECTION:
|
|
keyName = malloc(MAX_LEN_SECTIONNAME);
|
|
keyValue = malloc(MAX_LEN_SECTIONNAME);
|
|
memset(keyName,0,MAX_LEN_SECTIONNAME);
|
|
memset(keyValue,0,MAX_LEN_SECTIONNAME);
|
|
if((ret=getNameValuePair(token,'=',0,
|
|
&keyName,&keyValue,
|
|
MAX_LEN_SECTIONNAME,MAX_LEN_SECTIONNAME
|
|
))==NO_ERROR)
|
|
{
|
|
ptr_entry[i].sectionName = strdup(sectionName);
|
|
ptr_entry[i].keyValue= strdup(keyValue);
|
|
ptr_entry[i].keyName = strdup(keyName);
|
|
free(keyName);
|
|
free(keyValue);
|
|
if(i<configSizeCount-1)
|
|
{
|
|
i++;
|
|
*returnedCount = i;
|
|
}
|
|
else {
|
|
free(sectionName);
|
|
return ERROR_STR;
|
|
}
|
|
state = ST_FOUND_SECTION;
|
|
}
|
|
else {
|
|
free(keyName);
|
|
free(keyValue);
|
|
state = ST_SKIP_READ;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if(state != ST_SKIP_READ)
|
|
{
|
|
token = strtok(NULL,"\n");
|
|
}
|
|
else {
|
|
state = ST_INIT;
|
|
}
|
|
}
|
|
|
|
free(sectionName);
|
|
return NO_ERROR;
|
|
}
|