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 <stdio.h>
#include <stdlib.h>

#include "nsapi.h"
#include "pool.h"
#include "pblock.h"
#include "io.h"
#include "util.h"
#include "httprequest.h"
#include "conf.h"
#include "vserver.h"

HTTPRequest *http_request_new() {
    HTTPRequest *req = malloc(sizeof(HTTPRequest));
    req->connection = NULL;
    req->uri.ptr = NULL;

    HeaderArray *hd = malloc(sizeof(HeaderArray));
    hd->next = NULL;
    hd->len = 0;
    hd->headers = calloc(16, sizeof(Header));
    hd->alloc = 16;

    req->headers = hd;

    return req;
}

int handle_request(HTTPRequest *request) {
    // handle nsapi request

    // create pool
    request->pool = pool_create();

    // create nsapi data structures
    NSAPISession *sn = malloc(sizeof(NSAPISession));
    NSAPIRequest *rq = malloc(sizeof(NSAPIRequest));
    request->rq = rq;
    rq->phase = NSAPIAuthTrans;

    // fill session structure
    sn->sn.pool = pool_create();
    sn->sn.csd = stream_new_from_fd(request->connection->fd);
    sn->sn.client = NULL;
    sn->sn.next = NULL;
    sn->sn.fill = 1;
    sn->sn.subject = NULL;

    // init NSAPI request structure
    if(request_initialize(request->pool, request, rq) != 0) {
        printf("Cannot initialize request structure\n");
        return 1;
    }

    // set default virtual server
    rq->vs = conf_get_default_vs();


    /* Pass request line as "clf-request" */
    pblock_kvinsert(
            pb_key_clf_request,
            request->request_line.ptr,
            request->request_line.length,
            rq->rq.reqpb);

    /* Pass method as "method" in reqpb, and also as method_num */
    pblock_kvinsert(
            pb_key_method,
            request->method.ptr,
            request->method.length,
            rq->rq.reqpb);
    // TODO: method num
    //rqRq.rq.method_num = rqHdr->GetMethodNumber();
    //PR_ASSERT(rqRq.rq.method_num != -1 || iStatus);
    
    /* Pass protocol as "protocol" in reqpb, and also in protv_num */
    pblock_kvinsert(
            pb_key_protocol,
            request->httpv.ptr,
            request->httpv.length,
            rq->rq.reqpb);
    // TODO: protocol num

    /* Pass any query as "query" in reqpb */
    // TODO: query

    /* Get abs_path part of request URI, and canonicalize the path */
    sstr_t absPath = request->uri;
    // TODO: get abs_path
    absPath.ptr = util_canonicalize_uri(
            request->pool,
            absPath.ptr,
            absPath.length,
            (int*)&absPath.length);

    /* Decode the abs_path */
    // TODO: decode abs_path

    /* Pass the abs_path as "uri" in reqpb */
    // TODO: pass abs_path to reqpb
    // TODO: replace this code
    pblock_kvinsert(
            pb_key_uri,
            absPath.ptr,
            absPath.length,
            rq->rq.reqpb);

    // pass http header to the NSAPI request structure


    // Send the request to the NSAPI system
    nsapi_handle_request(sn, rq);

    return 0;
}



void header_add(HeaderArray *hd, char *name, char *value) {
    while(hd->len >= hd->alloc) {
        if(hd->next == NULL) {
            HeaderArray *block = malloc(sizeof(HeaderArray));
            block->next = NULL;
            block->len = 0;
            block->headers = calloc(16, sizeof(Header));
            block->alloc = 16;
            hd->next = block;
        }
        hd = hd->next;
    }
    hd->headers[hd->len].name = name;
    hd->headers[hd->len].value = value;
    hd->len++;
}


/*
 * NSAPI Processing
 * TODO: add this to new file
 */

int nsapi_handle_request(NSAPISession *sn, NSAPIRequest *rq) {
    // TODO: threadpool

    int r = REQ_NOACTION;

    do {
        switch(rq->phase) {
            case NSAPIAuthTrans: {
                rq->phase++;
            }
            case NSAPINameTrans: {
                printf(">>> NameTrans\n");
                r = nsapi_nametrans(sn, rq);
                if(r != REQ_PROCEED) {
                    break;
                }
                rq->phase++;
            }
            case NSAPIPathCheck: {
                printf(">>> PathCheck\n");
                rq->phase++;
            }
            case NSAPIService: {
                printf(">>> Service\n");
                r = nsapi_service(sn, rq);
                if(r != REQ_PROCEED) {
                    break;
                }
                rq->phase++;
            }
            case REQ_FINISH: {
                printf(">>> Finish\n");
                r = nsapi_finish_request(sn, rq);
            }
        }
    } while (r == REQ_RESTART);


    return r;
}

int nsapi_finish_request(NSAPISession *sn, NSAPIRequest *rq) {
    return 0;
}

int nsapi_nametrans(NSAPISession *sn, NSAPIRequest *rq) {
    httpd_objset *objset = rq->vs->objset;
    printf("nsapi_nametrans\n");

    int ret = -1;
    for(int i=0;i<objset->pos;i++) {
        httpd_object *obj = objset->obj[i];
        dtable *dt = object_get_dtable(obj, NSAPINameTrans);

        printf("object[%s] dt: %d\n", obj->name, dt);

        // execute directives
        for(int j=0;j<dt->ndir;j++) {
            directive *d = dt->directive[j];

            printf("execute [%s]\n", d->func->name);
            ret = d->func->func(d->param, (Session*)sn, (Request*)rq);
            if(ret == REQ_PROCEED || ret == REQ_PROCESSING) {
                break;
            }
        }

        // TODO: stultus
        if(ret == REQ_PROCEED || ret == REQ_PROCESSING) {
            break;
        }
    }

    // todo: check object, path, ...
    char *ppath = pblock_findkeyval(pb_key_ppath, rq->rq.vars);
    printf("ppath: [%s]\n", ppath);

    return ret;
}

int nsapi_service(NSAPISession *sn, NSAPIRequest *rq) {
    httpd_objset *objset = rq->vs->objset;

    int ret = -1;
    for(int i=0;i<objset->pos;i++) {
        httpd_object *obj = objset->obj[i];
        dtable *dt = object_get_dtable(obj, NSAPIService);

        // execute directives
        for(int j=0;j<dt->ndir;j++) {
            directive *d = dt->directive[j];

            ret = d->func->func(d->param, (Session*)sn, (Request*)rq);
            if(ret == REQ_PROCEED || ret == REQ_PROCESSING) {
                break;
            }
        }

        // TODO: stultus
        if(ret == REQ_PROCEED || ret == REQ_PROCESSING) {
            break;
        }
    }

    return ret;
}