Mercurial > hg > webserver / file revision

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 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 "../public/nsapi.h"

#include <stdio.h>
#include <stdlib.h>

#include <fcntl.h>
#include <sys/types.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/mman.h>

#include "../ucx/string.h"

#include "httplistener.h"
#include "config.h"
#include "func.h"

#include "vserver.h"
#include "../util/pblock.h"

VirtualServer *default_vs;

pool_handle_t *cfg_pool;

// TODO: Funktion für ConfigDirective -> directive
// TODO: Funktion für UcxList parameter list -> pblock
// TODO: ConfigurationManager
// TODO: server.conf

UcxMap *server_conf_handlers; // type: ServerConfigHandler*

void load_init_conf(char *file) {
    printf("load_init_conf\n");

    InitConfig *cfg = load_init_config("conf/init.conf");
    if(cfg == NULL) {
        return;
    }

    cfg_pool = pool_create(); // one pool for one Configuration
    UcxDlist *dirs = cfg->directives;
    while(dirs != NULL) {
        ConfigDirective *dir = dirs->data;

        /* create NSAPI directive */
        directive *d = malloc(sizeof(directive));
        d->param = pblock_create_pool(cfg_pool, 8);
        UcxList *param = dir->param;
        while(param != NULL) {
            ConfigParam *p = param->data;
            pblock_nvlinsert(
                    p->name.ptr,
                    p->name.length,
                    p->value.ptr,
                    p->value.length,
                    d->param);
            param = param->next;
        }

        /* get function */
        char *func_name = pblock_findval("fn", d->param);
        d->func = get_function(func_name);
        if(d->func == NULL) {
            free(d);
            continue;
        }

        /* execute init directive */
        d->func->func(d->param, NULL, NULL);

        dirs = dirs->next;
    }
    
    free_init_config(cfg);
}

void load_server_conf(char *file) {
    printf("load_server_conf\n");

    init_default_server_conf_handlers();

    ServerConfig *serverconf = load_server_config("conf/server.conf");
    if(serverconf == NULL) {
        fprintf(stderr, "Cannot load server.conf\n");
    }
    ServerConfiguration *serverconfig = malloc(sizeof(ServerConfiguration));
    // TODO: init serverconfig stuff

    /* convert ServerConfig to ServerConfiguration */
    for(int i=0;i<serverconf->objects->size;i++) {
        UcxMapElement *elm = &serverconf->objects->map[i];
        while(elm != NULL) {
            UcxList *list = elm->data;
            while(list != NULL) {
                ServerConfigObject *scfgobj = list->data;

                /* get handler */
                ServerConfigHandler *handler = ucx_map_sstr_get(
                        server_conf_handlers,
                        scfgobj->type);
                if(handler != NULL) {
                    /* process the directives */
                    UcxDlist *dirs = scfgobj->directives;
                    while(dirs != NULL) {
                        handler->process_directive(
                                handler,
                                serverconfig,
                                dirs->data);
                        
                        dirs = dirs->next;
                    }
                }

                list = list->next;
            }
            
            elm = elm->next;
        }
    }
    
    
    ListenerConfig *conf = malloc(sizeof(ListenerConfig));
    conf->port = 9090;
    conf->nacceptors = 1;
    conf->name = "default";

    http_listener_new(conf);

    // virtual server
    default_vs = vs_new();
    // load obj.conf
    default_vs->objects = load_obj_conf("conf/obj.conf");
    default_vs->default_obj_name = "default";
    
}

void init_default_server_conf_handlers() {
    /* create handler map */
    server_conf_handlers = ucx_map_new(8);

    /* create and add default handlers */

    ServerConfigHandler *runtime = malloc(sizeof(ServerConfigHandler));
    runtime->init = NULL;
    runtime->process_directive = handle_runtime_directive;

    ucx_map_cstr_put(server_conf_handlers, "Runtime", runtime);
}

int handle_runtime_directive(
        ServerConfigHandler *h,
        ServerConfiguration *conf,
        ConfigDirective *dir)
{
    

    return 0;
}

VirtualServer* conf_get_default_vs() {
    return default_vs;
}

HTTPObjectConfig* load_obj_conf(char *file) {
    printf("load_obj_conf\n");

    // new conf function test
    ObjectConfig *cfg = load_object_config(file);
    if(cfg == NULL) {
        return NULL;
    }

    /* create object config */
    HTTPObjectConfig *conf = calloc(sizeof(HTTPObjectConfig), 1);
    conf->pool = cfg_pool;

    /* convert ObjectConfig to HTTPObjectConfig */

    /* add objects */
    conf->nobj = ucx_dlist_size(cfg->objects);
    conf->objects = calloc(1, sizeof(httpd_object*));
    
    UcxDlist *objlist = cfg->objects;
    int i = 0;
    while(objlist != NULL) {
        ConfigObject *cob = objlist->data;

        /* get name and ppath */
        char *name = NULL;
        char *ppath = NULL;
        if(cob->name.length > 0) {
            name = sstrdub(cob->name).ptr;
        }
        if(cob->ppath.length > 0) {
            ppath = sstrdub(cob->ppath).ptr;
        }

        /* create and add object */
        httpd_object *obj = object_new(name);
        obj->path = NULL;

        conf->objects[i] = obj;

        /* add directives */
        for(int i=0;i<6;i++) {
            UcxDlist *dirs = cob->directives[i];
            while(dirs != NULL) {
                ConfigDirective *cfgdir = dirs->data;

                directive *d = malloc(sizeof(directive));
                d->cond = NULL;
                d->param = pblock_create_pool(conf->pool, 8);

                /* add params */
                UcxList *param = cfgdir->param;
                while(param != NULL) {
                    ConfigParam *p = param->data;
                    pblock_nvlinsert(
                            p->name.ptr,
                            p->name.length,
                            p->value.ptr,
                            p->value.length,
                            d->param);
                    param = param->next;
                }

                /* get function */
                char *func_name = pblock_findval("fn", d->param);
                d->func = get_function(func_name);

                dirs = dirs->next;

                /* add function to dtable */
                object_add_directive(obj, d, cfgdir->type_num);
            }
        }

        /* next */
        i++;
        objlist = objlist->next;
    }

    free_object_config(cfg);

    return conf;
}