config.c

Go to the documentation of this file.

#include"config.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>

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;
}

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;
}

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;
}

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,'[',']',&sectionName))==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;
}