src/server/config/objconf.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 "objconf.h"

#include <string.h>

#include <cx/utils.h>

/* dev notes:
 *
 * to free ObjectConfig, free:
 *    line dlist
 *    mempool
 *    object
 */

ObjectConfig *load_object_config(char *file) {
    FILE *in = fopen(file, "r");
    if(in == NULL) {
        return NULL;
    }

    ObjectConfig *conf = malloc(sizeof(ObjectConfig));
    conf->parser.parse = objconf_parse;
    conf->file = file;
    //conf->conditions = NULL;
    conf->levels = NULL;
    conf->objects = cxPointerLinkedListCreate(cxDefaultAllocator, cx_cmp_ptr);
    //conf->lines = NULL;

    int r = cfg_parse_basic_file((ConfigParser*)conf, in);
    if(r != 0) {
        // TODO: free
        return NULL;
    }
    
    fclose(in);

    return conf;
}

ObjectConfig2* objectconf_load(const char *file) {
    CxMempool *mp = cxBasicMempoolCreate(512);
    if(!mp) {
        return NULL;
    }
    
    // setup parser
    ConfigParser2 parser;
    memset(&parser, 0, sizeof(ConfigParser2));
    parser.mp = mp;
    parser.delim = "()/*%";
    parser.validateDirective = objectconf_validate_directive;
    parser.validateObjBegin = objectconf_validate_objbegin;
    parser.validateObjEnd = objectconf_validate_objend;
    parser.allow_hierarchy = 1;
    
    ConfigNode *obj_config = serverconfig_load_file(&parser, file);
    if(!obj_config) {
        cxMempoolDestroy(mp);
        return NULL;
    }
    
    ObjectConfig2 *conf = cxMalloc(mp->allocator, sizeof(ObjectConfig2));
    if(!conf) {
        cxMempoolDestroy(mp);
        return NULL;
    }
    
    conf->mp = mp;
    conf->root = obj_config;

    return conf;
}

void objectconf_free(ObjectConfig2 *objconf) {
    cxMempoolDestroy(objconf->mp);
}

int objectconf_validate_directive(ConfigParser2 *parser, ConfigNode *node) {
    // It is possible that this function is called for Objects
    // if { is on the next line
    // It may be possible to fix the parser to not do that, but it is fine
    // to just deal with that here
    
    // ignore if node->name is an Object name like
    // Object, Client, If, Else IfElse
    const char *objnames[] = { "Object", "Client", "If", "ElseIf", "Else" };
    size_t typeindex;
    if(!serverconfig_validate_directive_name(node, objnames, 5, &typeindex)) {
        return 0;
    }
    
    // now check directive type
    const char *dirtypes[] = { "AuthTrans", "NameTrans", "PathCheck", "ObjectType", "Service", "AddLog", "Error" };
    if(serverconfig_validate_directive_name(node, dirtypes, 7, &typeindex)) {
        return 1;
    }
    
    // directives must have parameter names
    ConfigParam *param_err;
    if(serverconfig_check_param_names(node, &param_err)) {
        return 1;
    }
    
    // check if the fn parameter exists
    cxstring fn = serverconfig_directive_get_arg(node, cx_str("fn"));
    if(fn.length == 0) {
        return 1;
    }
    
    return 0;
}

static int validate_else_node(ConfigNode *node) {
    // previous node must be "If" or "ElseIf"
    ConfigNode *prev = serverconfig_previous_dir_or_obj(node);
    const char *allowed_prev_types[] = { "If", "ElseIf" };
    size_t typeindex;
    if(serverconfig_validate_directive_name(prev, allowed_prev_types, 2, &typeindex)) {
        return 1; // prevous node (not counting space, comments) is not "If" or "Else"
    }
    
    // "Else" must have no args
    return node->args ? 1 : 0;
}

static int validate_elseif_node(ConfigNode *node) {
    // the previous node must be "If" or "IfElse"
    // in case if "IfElse", we also have to check all previous nodes, until
    // we find the starting "If" node
    const char *allowed_prev_types[] = { "If", "ElseIf" };
    size_t typeindex;
    ConfigNode *prev = serverconfig_previous_dir_or_obj(node);
    while(prev) {
        if(serverconfig_validate_directive_name(prev, allowed_prev_types, 2, &typeindex)) {
            return 1; // previous node was not "If" or "ElseIf"
        }
        // we found a valid "If" node, the whole construct is valid
        if(typeindex == 0) {
            return 0;
        }
        
        prev = serverconfig_previous_dir_or_obj(node);
    }
    // at this point we found only "IfElse" nodes, but no "If" node
    return 1;
}

int objectconf_validate_objbegin(ConfigParser2 *parser, ConfigNode *node) {
    // get object type
    const char *objnames[] = { "Object", "Client", "If", "ElseIf", "Else" };
    size_t typeindex;
    if(serverconfig_validate_directive_name(node, objnames, 5, &typeindex)) {
        return 1; // unknown object type
    }
    
    // some special requirements for "Else" node
    if(typeindex == 4) {
        // type is "Else"
        return validate_else_node(node);
    }
    
    // check "ElseIf" was used after "If" or "IfElse"
    if(typeindex == 3 && validate_elseif_node(node)) {
        return 1;
    }
    
    // only Object must have a name/value arg, other types can have more
    // complex parameters
    if(typeindex == 0) {
        // type is "Object"
        ConfigParam *err;
        if(serverconfig_check_param_names(node, &err)) {
            return 1;
        }
        return 0;
    }

    // all remaining object types must have arguments, but don't check more
    return node->args ? 0 : 1;
}

int objectconf_validate_objend(ConfigParser2 *parser, ConfigNode *node) {
    return 0;
}


void free_object_config(ObjectConfig *conf) {
    // free other lists
    if(conf->levels) {
        //ucx_list_free(conf->levels);
    }

    // free mempool
    //ucx_mempool_destroy(conf->parser.mp->pool);
    free(conf);
}


int objconf_parse(void *p, ConfigLine *begin, ConfigLine *end, cxmutstr line) {
    ObjectConfig *conf = p;

    begin->type = cfg_get_line_type(line);
    switch(begin->type) {
        case LINE_BEGIN_TAG: {
            ConfigTag *tag = cfg_parse_begin_tag(line, conf->parser.mp);
            if(tag == NULL) {
                log_ereport(LOG_FAILURE, "Parse error in %s", conf->file);
                exit(-1); // TODO: better error handling
            }
            tag->begin = begin;
            tag->end = end;
            tag->type_num = cfg_get_tag_type(cx_strcast(tag->name));
            //printf("line {%s}\n", cx_strdub(ll).ptr);
            if(objconf_on_begin_tag(conf, tag) != 0) {
                fprintf(stderr, "1error\n");
                exit(-1);
            }
            break;
        }
        case LINE_END_TAG: {
            cxmutstr tag = cfg_get_end_tag_name(line);
            if(objconf_on_end_tag(conf, tag) != 0) {
                fprintf(stderr, "2error\n");
                exit(-1);
            }

            break;
        }
        case LINE_DIRECTIVE: {
            ConfigDirective *dir = cfg_parse_directive(
                    line,
                    conf->parser.mp);
            dir->begin = begin;
            dir->end = end;
            if(objconf_on_directive(conf, dir) != 0) {
                fprintf(stderr, "3error\n");
                exit(-1);
            }
        }
    }
    return 0;
}

int objconf_on_begin_tag(ObjectConfig *conf, ConfigTag *tag) {
    CxAllocator *mp = conf->parser.mp;
    if(tag->type_num != TAG_OBJECT) {
        ConfigParserLevel *l = conf->levels;
        if(l->tag->type_num != TAG_OBJECT) {
            tag->parent = l->tag;
        }
    }
    

    switch(tag->type_num) {
        case TAG_OBJECT: {
            ConfigObject *obj = OBJ_NEW_N(mp, ConfigObject);
            obj->begin = tag->begin;
            obj->end = tag->end;
            
            obj->name = cfg_param_get(tag->param, cx_str("name"));
            obj->ppath = cfg_param_get(tag->param, cx_str("ppath"));

            conf->obj = obj;
            //conf->objects = ucx_list_append_a(mp, conf->objects, obj);
            cxListAdd(conf->objects, obj);

            // create tree level object
            ConfigParserLevel *lvl = OBJ_NEW(mp, ConfigParserLevel);
            lvl->iftag = NULL;
            lvl->levelnum = 1;
            lvl->tag = tag;
            lvl->next = NULL;
            //conf->levels = ucx_list_prepend_a(mp, conf->levels, lvl);
            CFG_LEVEL_PREPEND(&conf->levels, lvl);

            break;
        }
        case TAG_IF: {
            // create tree level object
            ConfigParserLevel *last_lvl = conf->levels;

            ConfigParserLevel *lvl = OBJ_NEW(mp, ConfigParserLevel);
            
            lvl->iftag = NULL;
            lvl->levelnum = last_lvl->levelnum + 1;
            lvl->tag = tag;
            //conf->levels = ucx_list_prepend_a(mp, conf->levels, lvl);
            CFG_LEVEL_PREPEND(&conf->levels, lvl);
            last_lvl->iftag = tag;

            break;
        }
        case TAG_ELSEIF: {
        }
        case TAG_ELSE: {
            // create tree level object
            ConfigParserLevel *last_lvl = conf->levels;
            tag->iftag = last_lvl->iftag;

            ConfigParserLevel *lvl = OBJ_NEW(
                    conf->parser.mp,
                    ConfigParserLevel);
            
            lvl->iftag = last_lvl->tag;
            lvl->levelnum = last_lvl->levelnum + 1;
            lvl->tag = tag;
            //conf->levels = ucx_list_prepend(conf->levels, lvl);
            CFG_LEVEL_PREPEND(&conf->levels, lvl);

            break;
        }
        case TAG_CLIENT: {
            // create tree level object
            
            // TODO
            
            break;
        }
        default: {
            log_ereport(LOG_FAILURE, "objconf: unknown tag");
            return 1;
        }
    }

    return 0;
}

int objconf_on_end_tag(ObjectConfig *conf, cxmutstr tagname) {
    int type = cfg_get_tag_type(cx_strcast(tagname));
    if(type == -1) {
        log_ereport(LOG_FAILURE, "objconf: unknown tag");
        return 1;
    } else {
        if(type == TAG_OBJECT) {
            conf->obj = NULL;
        }

        // remove level
        /*
        conf->levels = ucx_list_remove_a(
                conf->parser.mp,
                conf->levels,
                conf->levels);
        */
        conf->levels = conf->levels->next;
    }
    
    return 0;
}

int objconf_on_directive(ObjectConfig *conf, ConfigDirective *dir) {
    ConfigParserLevel *lvl = conf->levels;

    // check if we have a condition for the directive
    // if the level tag is not an object tag, use it as condition
    if(lvl->tag->type_num != TAG_OBJECT) {
        dir->condition = lvl->tag;
    }

    // add directive to current object
    /*
    conf->obj->directives[dir->type_num] = ucx_list_append_a(
            conf->parser.mp,
            conf->obj->directives[dir->type_num],
            dir);
    */
    
    ConfigDirectiveList *dir_entry = cxMalloc(conf->parser.mp, sizeof(ConfigDirectiveList));
    dir_entry->directive = dir;
    dir_entry->next = NULL;
    CFG_DIRECTIVES_ADD(&conf->obj->directives[dir->type_num], dir_entry);

    return 0;
}