src/server/config/conf.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2013 Olaf Wintermann. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "conf.h"

#include <string.h>

int cfg_parse_basic_file(ConfigParser *parser, FILE *in) {
    parser->lines = NULL;
    parser->mp = ucx_mempool_new(512);

    // one logical line over many lines
    sstr_t mline;
    mline.ptr = NULL;
    mline.length = 0;
    ConfigLine *start_line;
    ConfigLine *end_line;
    
    // read file
    sstr_t l;
    while((l = cfg_readln(in)).ptr != NULL) {
        void *org_ptr = l.ptr;
        
        // put the line to the list
        ConfigLine *line = OBJ_NEW(parser->mp, ConfigLine);
        line->line = sstrdup_mp(parser->mp, l); // TODO: check for 0-len str
        line->object = NULL;
        line->type = LINE_OTHER;
        if(parser->lines) {
            parser->lines = ucx_dlist_append(parser->lines, line);
        } else {
            parser->lines = ucx_dlist_append(parser->lines, line);
            cfg_dlist_destr(parser->mp, parser->lines);
        }

        // check if the line contains something
        l = cfg_trim_comment(l);
        line->type = cfg_get_basic_type(l);

        if(line->type == LINE_OTHER) {
            // check for multi line
            if(mline.ptr != NULL) {
                // concate lines
                char *ptr = ucx_mempool_malloc(
                        parser->mp,
                        mline.length + l.length + 1);
                
                memcpy(ptr, mline.ptr, mline.length);
                memcpy(ptr + mline.length - 1, l.ptr, l.length);
                mline.length += l.length;
                free(mline.ptr);
                mline.ptr = ptr;
                mline.ptr[mline.length] = 0;

                end_line = line;

                line->type = LINE_MULTI;
            }
            if(l.ptr[l.length - 1] == '\\') {
                if(mline.ptr == NULL) {
                    mline = sstrdup_mp(parser->mp, l);
                    start_line = line;
                }
            } else {
                // this line is complete so we can parse it
                sstr_t ll; // we parse this line

                if(mline.ptr == NULL) {
                    // single line
                    ll = l;
                    start_line = line;
                    end_line = line;
                } else {
                    ll = mline;
                }
                
                // parse
                int r = parser->parse(parser, start_line, end_line, ll);

                // clean up
                if(mline.ptr != NULL) {
                    free(mline.ptr);
                    mline.ptr = NULL;
                    mline.length = 0;
                    start_line = NULL;
                    end_line = NULL;
                }

                if(r != 0) {
                    free(org_ptr);
                    return -1;
                }
            }
        }
        
        free(org_ptr);
    }

    return 0;
}

sstr_t cfg_readln(FILE *file) {
    sstr_t ns;
    ns.ptr = NULL;
    ns.length = 0;

    if(!feof(file)) {
        char buf[512];
        buf[0] = 0;
        int  len = 512;

        if(fgets(buf, len, file) == NULL) {
            return ns;
        }

        if(*buf == 0) {
            printf("???\n");
            return ns;
        }

        char *ptr;
        if((ptr = strrchr(buf, '\n'))) {
            ptr[0] = 0;
        }

        sstr_t line = sstr(buf);
        return sstrdup(line);
    }

    sstr_t s;
    s.ptr = NULL;
    s.length = 0;
    return s;
}


/*
 * removes a comment from the line
 */
sstr_t cfg_trim_comment(sstr_t line) {
    sstr_t nl = line;
    for(int i=0;i<line.length;i++) {
        if(line.ptr[i] == '#') {
            if(i > 0) {
                nl.ptr = line.ptr + i - 1;
                nl.length = i;
                break;
            } else {
                nl.ptr = line.ptr;
                nl.length = 0;
                break;
            }
        }
    }
    return sstrtrim(nl);
}

/*
 * gets the first parameter in the params string and returns a new string
 * containing the other parameters or an empty string, if there are no more
 * parameters
 */
sstr_t cfg_param(sstr_t params, sstr_t *name, sstr_t *value) {
    name->ptr = NULL;
    name->length = 0;
    value->ptr = NULL;
    value->length = 0;

    // get name
    int i;
    for(i=0;i<params.length;i++) {
        char c = params.ptr[i];
        if(c == '=') {
            break;
        } else if(c < 33) {
            // no '=' means there is only a name, no value
            name->ptr = params.ptr;
            name->length = i;

            params.ptr = params.ptr + i;
            params.length -= i;
            return sstrtrim(params);
        }
    }

    name->ptr = params.ptr;
    name->length = i;
    i++;
    
    // get value
    if(i>=params.length) {
        sstr_t ns;
        ns.ptr = NULL;
        ns.length = 0;
        return ns;
    }

    int quote = 0;
    value->ptr = params.ptr + i;
    for(;i<params.length;i++) {
        char c = params.ptr[i];
        if(c == '"') {
            if(quote) {
                break; // end of quoted value
            } else {
                quote = 1;
                value->ptr++;
            }
        } else if(!quote && c < 33) {
            break; // end of value
        }
    }
    
    if(quote) {
        // if the value is quoted, i points to the last quote char
        value->length = i - name->length - 2; // subtract the quotes
        i++; // set i behind the last quote
    } else {
        // i points to a white space char, which must be subtraced
        value->length = i - name->length - 1;
    }

    if(value->length <= 0) {
        value->length = 0;
        value->ptr = NULL;
    }

    // create new params string
    params.ptr += i;
    params.length -= i;
    return sstrtrim(params);
}

/*
 * gets a value from a parameter
 */
sstr_t cfg_param_get(UcxList *list, sstr_t name) {
    while(list != NULL) {
        ConfigParam *param = list->data;
        if(!sstrcmp(param->name, name)) {
            return param->value;
        }
        list = list->next;
    }
    sstr_t ns;
    ns.ptr = NULL;
    ns.length = 0;
    return ns;
}

/*
 * parses a line containing a directive and returns a ConfigDirective object
 * or NULL if an error occurs
 */
ConfigDirective* cfg_parse_directive(sstr_t line, UcxMempool *mp) {
    if(line.length < 6) {
        printf("line too short\n");
        return NULL; // line too short
    }

    sstr_t name;

    int i;
    for(i=0;i<line.length;i++) {
        if(line.ptr[i] < 33) {
            break;
        }
    }
    name.ptr = line.ptr;
    name.length = i;

    // create directive object
    ConfigDirective *directive = OBJ_NEW(mp, ConfigDirective);
    directive->directive_type = sstrdup_mp(mp, name);
    directive->type_num = cfg_get_directive_type_num(name);
    directive->condition = NULL; // set later by main parsing function
    //directive->param = NULL;

    sstr_t param_str;
    param_str.ptr = name.ptr + i;
    param_str.length = line.length - i;
    param_str = sstrtrim(param_str);
    directive->value = sstrdup_mp(mp, param_str);
    
    /*
    sstr_t pname;
    sstr_t pvalue;
    for(;;) {
        param_str = cfg_param(param_str, &pname, &pvalue);
        if(pname.length <= 0) {
            break;
        }
        

        // create param object
        ConfigParam *param = OBJ_NEW(mp, ConfigParam);
        param->name = sstrdup_mp(mp, pname);

        if(pvalue.length > 0) {
            param->value = sstrdup_mp(mp, pvalue);
        } else {
            param->value.ptr = NULL;
            param->value.length = 0;
        }

        // add param to list
        
        //directive->param = ucx_list_append(directive->param, param);
    }
    */
    
    return directive;
}

UcxList* cfg_param_list(sstr_t param_str, UcxMempool *mp) {
    sstr_t pname;
    sstr_t pvalue;
    UcxList *plist = NULL;
    for(;;) {
        param_str = cfg_param(param_str, &pname, &pvalue);
        if(pname.length <= 0) {
            break;
        }

        // create param object
        ConfigParam *param = OBJ_NEW(mp, ConfigParam);
        param->name = sstrdup_mp(mp, pname);

        if(pvalue.length > 0) {
            param->value = sstrdup_mp(mp, pvalue);
        } else {
            param->value.ptr = NULL;
            param->value.length = 0;
        }

        // add param to list
        plist = ucx_list_append(plist, param);
    }
    cfg_list_destr(mp, plist);
    return plist;
}


/*
 * gets the directive type number from a type string
 * valid types are:
 *   AuthTrans      0
 *   NameTrans      1
 *   PathCheck      2
 *   ObjectType     3
 *   Service        4
 *   AddLog         5
 *   Init           6
 */
int cfg_get_directive_type_num(sstr_t type) {
    /* get nsapi function type */
    int dt = -1;
    if(sstrcmp(type, sstr("AuthTrans")) == 0) {
        dt = 0;
    } else if(sstrcmp(type, sstr("NameTrans")) == 0) {
        dt = 1;
    } else if(sstrcmp(type, sstr("PathCheck")) == 0) {
        dt = 2;
    } else if(sstrcmp(type, sstr("ObjectType")) == 0) {
        dt = 3;
    } else if(sstrcmp(type, sstr("Service")) == 0) {
        dt = 4;
    } else if(sstrcmp(type, sstr("AddLog")) == 0) {
        dt = 5;
    } else if(sstrcmp(type, sstr("Init")) == 0) {
        dt = 6;
    }
    return dt;
}

/*
 * checks if the line contains only a comment or space
 */
int cfg_get_basic_type(sstr_t line) {
    if(line.length == 0) {
        return LINE_NOCONTENT;
    } else if(line.ptr[0] == '#') {
        return LINE_NOCONTENT;
    }
    return LINE_OTHER;
}

/*
 * checks if the line contains a begin/end tag or a directive
 */
int cfg_get_line_type(sstr_t line) {
    if(line.length < 3) {
        // this line is to short to be correct
        return LINE_ERROR;
    }
    
    if(line.ptr[0] == '<') {
        // start or end tag
        // TODO: check for space between '<' and '/'
        if(line.ptr[1] == '/') {
            return LINE_END_TAG;
        } else {
            return LINE_BEGIN_TAG;
        }
    } else {
        return LINE_DIRECTIVE;
    }
}

int cfg_get_tag_type(sstr_t tag) {
    if(!sstrcmp(tag, sstr("Object"))) {
        return TAG_OBJECT;
    } else if(!sstrcmp(tag, sstr("If"))) {
        return TAG_IF;
    } else if(!sstrcmp(tag, sstr("ElseIf"))) {
        return TAG_ELSEIF;
    } else if(!sstrcmp(tag, sstr("Else"))) {
        return TAG_ELSE;
    } else if(!sstrcmp(tag, sstr("Client"))) {
        return TAG_CLIENT;
    }
    return -1;
}

/*
 * returns the name of the ending tag
 * on error, this functions returns a zero length string
 */
sstr_t cfg_get_end_tag_name(sstr_t line) {
    sstr_t ns;
    ns.ptr = NULL;
    ns.length = 0;

    if(line.length < 4) {
        // minimum of 4 chars: </a>
        return ns;
    }

    sstr_t name;
    name.ptr = line.ptr + 2;
    name.length = line.length - 3;

    // check for </ > frame
    if(line.ptr[0] != '<'
            || line.ptr[1] != '/'
            || line.ptr[line.length - 1] != '>')
    {
        return ns;
    }

    return sstrtrim(name);
}

ConfigTag* cfg_parse_begin_tag(sstr_t line, UcxMempool *mp) {
    if(line.length < 4) {
        return NULL; // this line can't contain a valid tag
    }

    if(line.ptr[0] != '<' || line.ptr[line.length - 1] != '>') {
        return NULL; // syntax error
    }

    sstr_t name;
    name.ptr = line.ptr + 1;
    int i;
    for(i=1;i<line.length - 1;i++) {
        if(line.ptr[i] < 33) { // char is space
            break;
        }
    }
    name.length = i - 1;
    if(name.length < 1) {
        return NULL; // syntax error
    }

    // create tag object
    ConfigTag *tag = OBJ_NEW(mp, ConfigTag);
    tag->name = sstrdup_mp(mp, name);
    tag->param = NULL;

    // parse parameters
    sstr_t param_str;
    param_str.ptr = line.ptr + i;
    param_str.length = line.length - name.length - 2;
    param_str = sstrtrim(param_str);
    if(param_str.length <= 0) {
        return tag; // no parameters
    }

    sstr_t pname;
    sstr_t pvalue;
    for(;;) {
        param_str = cfg_param(param_str, &pname, &pvalue);
        if(pname.length <= 0) {
            break;
        }

        // create param object
        ConfigParam *param = OBJ_NEW(mp, ConfigParam);
        param->name = sstrdup_mp(mp, pname);
        if(pvalue.length > 0) {
            param->value = sstrdup_mp(mp, pvalue);
        } else {
            param->value.ptr = NULL;
            param->value.length = 0;
        }

        // add param to list
        if(tag->param) {
            tag->param = ucx_list_append(tag->param, param);
        } else {
            tag->param = ucx_list_append(tag->param, param);
            cfg_list_destr(mp, tag->param);
        }
    }

    return tag;
}


/* directive functions */

/*
 * gets a ConfigDirective with a specific name from a List of directives
 * returns a directive or NULL, if the directive cannot be found
 */
ConfigDirective* cfg_directivelist_get(UcxDlist *dirs, sstr_t name) {
    while(dirs != NULL) {
        ConfigDirective *d = dirs->data;
        if(d != NULL) {
            if(!sstrcmp(d->directive_type, name)) {
                return d;
            }
        }
        dirs = dirs->next;
    }
    return NULL;
}

sstr_t cfg_directivelist_get_str(UcxDlist *dirs, sstr_t name) {
    ConfigDirective *d = cfg_directivelist_get(dirs, name);
    if(d == NULL) {
        sstr_t n;
        n.ptr = NULL;
        n.length = 0;
        return n;
    }
    //return cfg_directive_pstr1(d);
    return d->value;
}

/*
 * returns the name of the first parameter of the directive
 * useful for 'name value' directives
 */
/*
sstr_t cfg_directive_pstr1(ConfigDirective *dir) {
    if(dir->param == NULL) {
        fprintf(stderr, "%s", "Error: cfg_directive_pstr1: param is NULL\n");
        sstr_t n;
        n.ptr = NULL;
        n.length = 0;
        return n;
    }

    ConfigParam *p = dir->param->data;
    return p->name;
}
*/

static void cfg_list_free(void *list) {
    ucx_list_free(list);
}
static void cfg_dlist_free(void *dlist) {
    ucx_dlist_free(dlist);
}
static void cfg_map_free(void *map) {
    ucx_map_free(map);
}

void cfg_list_destr(UcxMempool *mp, UcxList *list) {
    if(list) {
        ucx_mempool_reg_destr(mp, list, cfg_list_free);
    }
}

void cfg_dlist_destr(UcxMempool *mp, UcxDlist *dlist) {
    if(dlist) {
        ucx_mempool_reg_destr(mp, dlist, cfg_dlist_free);
    }
}

void cfg_map_destr(UcxMempool *mp, UcxMap *map) {
    if(map) {
        ucx_mempool_reg_destr(mp, map, cfg_map_free);
    }
}

UcxList* cfg_list_append(UcxMempool *mp, UcxList *list, void *data) {
    if(list) {
        return ucx_list_append(list, data);
    } else {
        UcxList *r = ucx_list_append(list, data);
        cfg_list_destr(mp, r);
        return r;
    }
}

UcxDlist* cfg_dlist_append(UcxMempool *mp, UcxDlist *list, void *data) {
    if(list) {
        return ucx_dlist_append(list, data);
    } else {
        UcxDlist *r = ucx_dlist_append(list, data);
        cfg_dlist_destr(mp, r);
        return r;
    }
}