311 lines
9.9 KiB
C
311 lines
9.9 KiB
C
#include"config.h"
|
|
#include<stdio.h>
|
|
#include<stdlib.h>
|
|
#include<string.h>
|
|
#include<errno.h>
|
|
|
|
/**
|
|
* @brief 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
|
|
*
|
|
* @brief Input:
|
|
* @param char **str: the string to check
|
|
* @param char delimiterLeft: the left delimiter to check for
|
|
* @param char delimiterRight: the right delimiter to check for
|
|
*
|
|
* @brief Output:
|
|
* @param char **sectionName: if found the section Name of the section
|
|
*
|
|
* @brief Return:
|
|
* @param 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);
|
|
int state = ST_INIT;
|
|
int leftDelimiterPos=0;
|
|
int rightDelimiterPos=0;
|
|
char *sectionName2 = NULL;
|
|
while(state != ST_FINISH)
|
|
{
|
|
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)
|
|
{
|
|
if(*name == NULL)
|
|
{
|
|
int error = errno;
|
|
printf("Pointer NULL:%d\n",error);
|
|
return error;
|
|
}
|
|
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';
|
|
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)
|
|
{
|
|
if(*name == NULL || *value == NULL)
|
|
{
|
|
int error = errno;
|
|
printf("Pointer NULL:%d\n",error);
|
|
return error;
|
|
}
|
|
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\n",posDelimiter);
|
|
if((ret=getStrAtPos(str,0,posDelimiter-1,&ptr_name,sizeName)) == NO_ERROR)
|
|
{
|
|
printf("ptr_name:%s\n",ptr_name);
|
|
}else {
|
|
printf("Error at getStrAtPos:%d\n",ret);
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* Given a null terminated buffer of content(ex. from a file) an parse it with a default syntax of:
|
|
* Sections -> [SECTIONNAME]
|
|
* name / value -> name=value
|
|
*
|
|
* Input:
|
|
* char *originalBuffer: the buffer which holds the string for parsing.
|
|
* struct configEntry **entry: a user allocated buffer to which we write the parsed config data.
|
|
* int configSizeCount: the user allocated size of **entry.
|
|
* Output:
|
|
* int *returnedCount: to this variable the function writes the count of struct, which will be required to store all alavaible data.
|
|
*
|
|
* Note:
|
|
* The funtion returns the maximum allowed data structures, determined by configSizeCount. All data which exceeds will be dropped.
|
|
* To get the whole data we run the funtion a second time with the realloced configSizeCount in the size of [returnedCount] structures.
|
|
*/
|
|
int parseConfig(char *originalBuffer,struct configEntry **entry,int configSizeCount,int *returnedCount)
|
|
{
|
|
int state=ST_INIT;
|
|
int ret=0;
|
|
int i=0;
|
|
*returnedCount=0;
|
|
char *sectionName=NULL;
|
|
struct configEntry *ptr_entry = *entry;
|
|
char *keyName=NULL;
|
|
char *keyValue=NULL;
|
|
char *buffer=NULL;
|
|
|
|
buffer = malloc(strlen(originalBuffer)+1);
|
|
if(buffer == NULL)
|
|
{
|
|
int error = errno;
|
|
printf("ERROR MALLOC:%d",error);
|
|
return ERR_PARSECONFIG_UNKNOWN;
|
|
}
|
|
memset(buffer,0,strlen(originalBuffer)+1);
|
|
strcpy(buffer,originalBuffer);
|
|
|
|
//this step is necessary, because the strok function modifys the originalBuffer
|
|
//so we make a copy of it
|
|
strcpy(buffer,originalBuffer);
|
|
|
|
printf("buffer:%s\n--",buffer);
|
|
|
|
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:
|
|
if((ret=checkSection(token,'[',']',§ionName))==FOUND_SECTION)
|
|
{
|
|
state = ST_FOUND_SECTION;
|
|
printf("FOUND_SECTION:%s\n",sectionName);
|
|
}
|
|
break;
|
|
case ST_FOUND_SECTION:
|
|
keyName = malloc(MAX_LEN_SECTIONNAME);
|
|
keyValue = malloc(MAX_LEN_SECTIONNAME);
|
|
if(keyName == NULL || keyValue == NULL)
|
|
{
|
|
int error = errno;
|
|
printf("MALLOC:%d\n",error);
|
|
return error;
|
|
}
|
|
memset(keyName,0,MAX_LEN_SECTIONNAME);
|
|
memset(keyValue,0,MAX_LEN_SECTIONNAME);
|
|
|
|
ret=getNameValuePair(token,'=',0,&keyName,&keyValue,MAX_LEN_SECTIONNAME,MAX_LEN_SECTIONNAME);
|
|
if(ret==NO_ERROR)
|
|
{
|
|
printf("configSizeCount: %d, i:%d\n",configSizeCount,i);
|
|
if(i<configSizeCount)
|
|
{
|
|
ptr_entry[i].sectionName = strdup(sectionName);
|
|
ptr_entry[i].keyValue= strdup(keyValue);
|
|
ptr_entry[i].keyName = strdup(keyName);
|
|
}
|
|
i++;
|
|
*returnedCount = i;
|
|
state = ST_FOUND_SECTION;
|
|
}
|
|
else {
|
|
state = ST_SKIP_READ;
|
|
}
|
|
free(keyName);
|
|
free(keyValue);
|
|
break;
|
|
}
|
|
|
|
if(state != ST_SKIP_READ)
|
|
{
|
|
token = strtok(NULL,"\n");
|
|
}
|
|
else {
|
|
state = ST_INIT;
|
|
}
|
|
}
|
|
printf("token: %s\n",token);
|
|
printf("buffer:%s\n--",buffer);
|
|
|
|
free(sectionName);
|
|
free(buffer);
|
|
printf("finish exitting parsing\nSTATE:%d\n",state);
|
|
return NO_ERROR;
|
|
}
|