src/server/daemon/httprequest.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 <stdio.h>
#include <stdlib.h>
#include <limits.h>

#include <arpa/inet.h>

#include "../public/nsapi.h"
#include "../util/pool.h"
#include "../util/pblock.h"
#include "../util/io.h"
#include "../util/util.h"
#include "httprequest.h"
#include "config.h"
#include "vserver.h"
#include "event.h"
#include "httplistener.h"
#include "func.h"
#include "error.h"

void http_request_init(HTTPRequest *req) {
    memset(req, 0, sizeof(HTTPRequest));

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

    req->headers = hd;
    
    req->req_start = time(NULL);
}

void http_request_cleanup(HTTPRequest *req) {
    header_array_free(req->headers);
    free(req);
}

cxmutstr http_request_get_abspath(HTTPRequest *req) {
    cxmutstr uri = req->uri;
    
    int i = 0;
    if(uri.ptr[0] == '/') {
        return uri;
    } else if(cx_strprefix(cx_strcast(uri), (cxstring)CX_STR("http://"))) {
        i = 7;
    } else if(cx_strprefix(cx_strcast(uri), (cxstring)CX_STR("https://"))) {
        i = 8;
    } else if(!cx_strcmp(cx_strcast(uri), (cxstring)CX_STR("*"))) {
        return uri;
    }
    
    for(;i<uri.length;i++) {
        if(uri.ptr[i] == '/') {
            return cx_strsubs_m(uri, i);
        }
    }
    
    return (cxmutstr){ "/", 1 };
}

NSAPISession* nsapisession_create(pool_handle_t *pool) {
    NSAPISession *sn = pool_malloc(pool, sizeof(NSAPISession));
    if(!sn) {
        return NULL;
    }
    
    ZERO(sn, sizeof(NSAPISession));
    
    sn->sn.pool = pool;
    
    sn->sn.client = pblock_create_pool(sn->sn.pool, 8);
    if(!sn->sn.client) {
        pool_free(pool, sn);
        return NULL;
    }
    sn->sn.fill = 1;
    
    return sn;
}

int nsapisession_setconnection(NSAPISession *sn, Connection *conn, netbuf *inbuf, IOStream **io) {
    SessionHandler *sh = conn->session_handler;
    WSBool ssl;
    IOStream *sio = sh->create_iostream(sh, conn, sn->sn.pool, &ssl);
    if(!sio) {
        return 1;
    }
    *io = sio;
    IOStream *http = httpstream_new(sn->sn.pool, sio);
    if(!http) {
        return 1;
    }
    sn->connection = conn;
    sn->netbuf = inbuf;
    sn->sn.csd = http;
    sn->sn.ssl = ssl;
    sn->sn.inbuf = inbuf;
    sn->sn.inbuf->sd = http;
    return 0;
}

int handle_request(HTTPRequest *request, threadpool_t *thrpool, EventHandler *ev) {
    // handle nsapi request
     
    // create pool
    pool_handle_t *pool = pool_create();
    if(!pool) {
        log_ereport(LOG_FAILURE, "cannot create new memory pool for http request");
        return 1;
    }
    
    int ret = nsapi_start_request(request, thrpool, ev, pool);
    if(ret) {
        pool_destroy(pool);
    }
    return ret;
}

int nsapi_start_request(HTTPRequest *request, threadpool_t *thrpool, EventHandler *ev, pool_handle_t *pool) {
    log_ereport(LOG_DEBUG, "trace reqid: %016llx nsapi_start_request", (unsigned long long int)request->connection->id);
    
    // create nsapi data structures
    NSAPISession *sn = nsapisession_create(pool);
    if(sn == NULL) {
        /* TODO: error */
        return 1;
    }
    
    NSAPIRequest *rq = pool_malloc(pool, sizeof(NSAPIRequest));
    if(rq == NULL) {
        /* TODO: error */
        return 1;
    }
    ZERO(rq, sizeof(NSAPIRequest));
    rq->rq.req_start = request->req_start;
    rq->phase = NSAPIAuthTrans;

    // fill session structure
    IOStream *io = NULL;
    if(nsapisession_setconnection(sn, request->connection, request->netbuf, &io)) {
        // TODO: error
        return 1;
    }
    
    if(!ev) {
        ev = ev_instance(get_default_event_handler());
    }
    sn->sn.ev = ev;
      
    // the session needs the current server configuration
    sn->config = request->connection->listener->cfg;

    // add ip to sn->client pblock
    if(request->connection->addr_type == CONN_ADDR_IPV4) {
        char ip_str[INET_ADDRSTRLEN];
        if(inet_ntop(
                AF_INET,
                &request->connection->address.address_v4.sin_addr,
                ip_str,
                INET_ADDRSTRLEN) != NULL)
        {
            pblock_kvinsert(pb_key_ip, ip_str, INET_ADDRSTRLEN, sn->sn.client);
        }
    } else if(request->connection->addr_type == CONN_ADDR_IPV6) {
        char ip_str[INET6_ADDRSTRLEN];
        if(inet_ntop(
                AF_INET6,
                &request->connection->address.address_v6.sin6_addr,
                ip_str,
                INET6_ADDRSTRLEN) != NULL)
        {
            pblock_kvinsert(pb_key_ip, ip_str, INET6_ADDRSTRLEN, sn->sn.client);
        }
    }

    // init NSAPI request structure
    if(request_initialize(pool, request, rq) != 0) {
        log_ereport(LOG_FAILURE, "Cannot initialize request structure");
        return 1;
    }

    // set default virtual server
    rq->vs = request->connection->listener->default_vs.vs;

    // Pass request line as "clf-request"
    // remove \r\n 
    cxmutstr clfreq = request->request_line;
    while(clfreq.length > 0 && clfreq.ptr[clfreq.length - 1] < 33) {
        clfreq.length--;
    }
    pblock_kvinsert(
            pb_key_clf_request,
            clfreq.ptr,
            clfreq.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);
    
    if(!cx_strcmp(cx_strcast(request->httpv), (cxstring)CX_STR("HTTP/1.1"))) {
        rq->rq.protv_num = PROTOCOL_VERSION_HTTP11;
    } else if(!cx_strcmp(cx_strcast(request->httpv), (cxstring)CX_STR("HTTP/1.0"))) {
        rq->rq.protv_num = PROTOCOL_VERSION_HTTP10;
    } else {
        // invalid protocol version - abort
        log_ereport(
                LOG_FAILURE,
                "invalid protocol version: %.*s",
                (int)request->httpv.length,
                request->httpv.ptr);
        return 1;
    }

    /*
     * get absolute path and query of the request uri
     */
    // TODO: check for '#' #72
    cxmutstr absPath = http_request_get_abspath(request);
    if(!absPath.ptr) {
        // TODO: error msg
        return 1;
    } else if(absPath.ptr[0] == '*') {
        // TODO: implement global OPTIONS #71
        return 1;
    }
    
    for(int i=0;i<request->uri.length;i++) {
        if(request->uri.ptr[i] == '?') {
            cxmutstr query;
            query.ptr = NULL;
            query.length = 0;
            
            /* split uri in path and query */
            if(absPath.length > i + 2) {
                query.length = absPath.length - i - 1;
                query.ptr = absPath.ptr + i + 1;
            }
            absPath.length = i;

            // Pass any query as 'query' in reqpb
            if(query.length > 0) {
                pblock_kvinsert(
                    pb_key_query,
                    query.ptr,
                    query.length,
                    rq->rq.reqpb);
            }

            break;
        }
    }
    
    // Get abs_path part of request URI, and canonicalize the path
    cxmutstr orig_path = absPath;
    absPath.ptr = util_canonicalize_uri(
            pool,
            absPath.ptr,
            absPath.length,
            (int*)&absPath.length);
    if(!absPath.ptr) {
        log_ereport(
                LOG_WARN,
                "invalid request path: {%.*s}",
                (int)orig_path.length,
                orig_path.ptr);
        // TODO: 400 bad request
        return 1;
    }

    // Decode the abs_path
    if(util_uri_unescape_strict(absPath.ptr)) {
        // Pass the abs_path as 'uri' in reqpb
        pblock_kvinsert(
                pb_key_uri,
                absPath.ptr,
                absPath.length,
                rq->rq.reqpb);
    } else {
        log_ereport(
                LOG_WARN,
                "uri unescape failed: {%.*s}",
                (int)absPath.length,
                absPath.ptr);
        // TODO: 400 bad request
        pblock_kvinsert(pb_key_uri, "/", 1, rq->rq.reqpb);
    }

    // pass http header to the NSAPI request structure
    int hlen = request->headers->len;
    HeaderArray *ha  = request->headers;
    for(int i=0;i<=hlen;i++) {
        if(i == hlen) {
            ha = ha->next;
            if(ha == NULL) {
                break;
            }
            i = 0;
            hlen = ha->len;
        }
        
        Header header = ha->headers[i];

        if(header.name.ptr[0] < 90) {
            header.name.ptr[0] += 32;
        }

        // change to lower case
        for(int j=0;j<header.name.length;j++) {
            if(header.name.ptr[j] > 64 && header.name.ptr[j] < 97) {
                header.name.ptr[j] += 32;
            }
        }
        
        pblock_nvlinsert(
                header.name.ptr,
                header.name.length,
                header.value.ptr,
                header.value.length,
                rq->rq.headers);
    }
    
    // get host and port
    char *hosthdr = pblock_findkeyval(pb_key_host, rq->rq.headers);
    if(hosthdr) {
        char *host = pool_strdup(pool, hosthdr);
        char *portstr = NULL;
        if(host[0] != '[') {
            portstr = strchr(host, ':');
        } else {
            char *v6end = strchr(host, ']');
            if(v6end) {
                portstr = strchr(v6end, ':');
            }
        }
        
        if(portstr) {
            *portstr = '\0';
        }
        rq->host = host;
    } else {
        rq->host = NULL; // TODO: value from listener
    }
    rq->port = request->connection->listener->port;
    
    if(rq->host) {
        VirtualServer *vs = cxMapGet(sn->config->host_vs, cx_hash_key_str(rq->host));
        if(vs) {
            rq->vs = vs;
        } else {
            log_ereport(
                    LOG_VERBOSE,
                    "Unkown host '%s': using default virtual server", 
                    rq->host);
        }
    }
    
    // parse connection header
    rq->rq.rq_attr.keep_alive = (rq->rq.protv_num >= PROTOCOL_VERSION_HTTP11);
    char *conn_str = pblock_findkeyval(pb_key_connection, rq->rq.headers);
    if(conn_str) {
        if(!strcasecmp(conn_str, "keep-alive")) {
            rq->rq.rq_attr.keep_alive = 1;
        } else if(!strcasecmp(conn_str, "close")) {
            rq->rq.rq_attr.keep_alive = 0;
        }
    }
       
    // check for request body and prepare input buffer
    char *ctlen_str = pblock_findkeyval(pb_key_content_length, rq->rq.headers);
    if(ctlen_str) {
        int64_t ctlen;
        if(util_strtoint(ctlen_str, &ctlen)) {
            netbuf *nb = sn->netbuf;
            HttpStream *net_io = (HttpStream*)sn->sn.csd;
            net_io->read_eof = WS_FALSE;

            // how many bytes are already read and in the buffer
            int cur_input_available = nb->cursize - nb->pos;

            if(cur_input_available >= ctlen) {
                // we have the whole request body in the buffer and
                // maybe even more
                // no more read from the socket is necessary to get the body,
                // therefore disable it
                net_io->max_read = 0;
            } else {
                // read still required to get the complete request body
                net_io->max_read = ctlen - cur_input_available;
            }
            //printf("request body length: %d\n", ctlen);
        } // else: should we abort?
    }
    char *transfer_encoding = pblock_findkeyval(pb_key_transfer_encoding, rq->rq.headers);
    if(transfer_encoding) {
        if(!strcmp(transfer_encoding, "chunked")) {
            netbuf *nb = sn->netbuf;
            // a separate buffer is required for reading chunked transfer enc
            sn->buffer = pool_malloc(pool, nb->maxsize);
            if(!sn->buffer) {
                // TODO: error 500 
                return 1;
            }
            
            // copy remaining bytes from inbuf to the additional buffer
            if(nb->cursize - nb->pos > 0) {
                memcpy(sn->buffer, nb->inbuf, nb->cursize);
            }
            
            sn->pos = nb->pos;
            sn->cursize = nb->cursize;
            
            // clear inbuf
            nb->pos = 0;
            nb->cursize = 0;
            
            if(httpstream_enable_chunked_read(sn->sn.csd, sn->buffer, nb->maxsize, &sn->cursize, &sn->pos)) {
                // TODO: error 500 
                return 1;
            }
        } // else: TODO: unknown transfer encoding error
    }
    
    //
    // Send the request to the NSAPI system
    //
    
    // compare current and listener thread pool
    threadpool_t *lstp = request->connection->listener->threadpool;
    sn->defaultpool = lstp;
    if(lstp == thrpool) {
        sn->currentpool = thrpool;
        nsapi_handle_request(sn, rq);
    } else {
        // execute nsapi functions on a different thread pool
        nsapi_change_threadpool(sn, rq, lstp);
    }
    
    return 0;
}


void header_add(HeaderArray *hd, cxmutstr name, cxmutstr 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++;
}

void header_array_free(HeaderArray *hd) {
    HeaderArray *next;
    while(hd) {
        next = hd->next;
        free(hd->headers);
        free(hd);
        hd = next;
    }
}


/*
 * NSAPI Processing
 */

int nsapi_handle_request(NSAPISession *sn, NSAPIRequest *rq) {
    log_ereport(LOG_DEBUG, "trace reqid: %016llx nsapi_handle_request", (unsigned long long int)sn->connection->id);
    
    int r = REQ_NOACTION;
    do {
        switch(rq->phase) {
            case NSAPIAuthTrans: {
                r = nsapi_authtrans(sn, rq);
                if(r != REQ_PROCEED) {
                    break;
                }
                rq->phase++;
                nsapi_context_next_stage(&rq->context);
            }
            case NSAPINameTrans: {
                //printf(">>> NameTrans\n");
                r = nsapi_nametrans(sn, rq);
                if(r != REQ_PROCEED) {
                    break;
                }
                rq->phase++;
                nsapi_context_next_stage(&rq->context);
            }
            case NSAPIPathCheck: {
                //printf(">>> PathCheck\n");
                r = nsapi_pathcheck(sn, rq);
                if(r != REQ_PROCEED) {
                    break;
                }
                rq->phase++;
                nsapi_context_next_stage(&rq->context);
            }
            case NSAPIObjectType: {
                //printf(">>> ObjectType\n");
                r = nsapi_objecttype(sn, rq);
                if(r != REQ_PROCEED) {
                    break;
                }
                rq->phase++;
                nsapi_context_next_stage(&rq->context);
            }
            case NSAPIService: {
                //printf(">>> Service\n");
                r = nsapi_service(sn, rq);
                if(r != REQ_PROCEED) {
                    break;
                }
                rq->phase = NSAPIAddLog; // skip NSAPIError
                nsapi_context_next_stage(&rq->context);
            }
            case NSAPIAddLog: {
                //printf(">>> AddLog\n");
                r = nsapi_addlog(sn, rq);
                if(r == REQ_PROCESSING) {
                    break;
                }
                // finish request
                r = REQ_PROCEED;
                break;
            }
            default: // should not happen, but when it does, finish the req
            case REQ_FINISH: {
                //printf(">>> Finish\n");
                //r = nsapi_finish_request(sn, rq);
                r = REQ_PROCEED;
                break;
            }
            case NSAPIError: {
                //printf(">>> Error\n");
                r = nsapi_error(sn, rq);
                if(r == REQ_PROCEED) {
                    // restart the loop to switch to AddLog directive
                    r = REQ_RESTART;
                    rq->phase = NSAPIAddLog;
                    nsapi_context_next_stage(&rq->context);
                } else {
                    /*
                     * an error occured while handling an error
                     * leave loop to finish the request (without AddLog)
                     */
                    r = REQ_PROCEED;
                    break;
                }
            }
        }
        
        if(r == REQ_ABORTED) {
            // switch to NSAPIError
            rq->phase = NSAPIError;
            nsapi_context_next_stage(&rq->context);
            r = REQ_RESTART;
        }
        
    } while (r == REQ_RESTART);

    if(r != REQ_PROCESSING) {
        r = nsapi_finish_request(sn, rq);
    }

    return r;
}

int nsapi_finish_request(NSAPISession *sn, NSAPIRequest *rq) {
    rq->finished = TRUE;
    request_free_resources(sn, rq);
    
    log_ereport(LOG_DEBUG, "trace reqid: %016llx nsapi_finish_request", (unsigned long long int)sn->connection->id);
    
    WSBool read_stream_eof = httpstream_eof(sn->sn.csd);
    if(!read_stream_eof) {
        log_ereport(LOG_WARN, "request input stream not closed");
        // TODO: clean stream
        rq->rq.rq_attr.keep_alive = 0; // workaround
    }
    if(sn->pos < sn->cursize) {
        log_ereport(LOG_WARN, "nsapi_finish_request: TODO: remaining bytes in buffer");
        // TODO: reuse buffer in next request
        rq->rq.rq_attr.keep_alive = 0; // workaround
    }
    
    if(rq->rq.senthdrs) {
        // flush buffer and add termination if chunked encoding
        // is enabled
         net_finish(sn->sn.csd);
    } else {
        // why was no response sent?
        // something must have gone wrong
        // terminate the session
        char *clf_req = pblock_findkeyval(pb_key_clf_request, rq->rq.reqpb);
        log_ereport(LOG_WARN, "nsapi_finish_request: no response header: request: %s", clf_req);
        rq->rq.rq_attr.keep_alive = 0;
    }
    
    char *response_content_length = pblock_findkeyval(pb_key_content_length, rq->rq.srvhdrs);
    int64_t response_ctlen;
    if(response_content_length && util_strtoint(response_content_length, &response_ctlen)) {
        int64_t w = httpstream_written(sn->sn.csd);
        if(w != response_ctlen) {
            log_ereport(LOG_WARN, "nsapi_finish_request: content-length != number of bytes written");
            rq->rq.rq_attr.keep_alive = 0; // fatal io error, we can not safely reuse the connection
        }
    }
    
    if(rq->rq.rq_attr.keep_alive) {
        SessionHandler *sh = sn->connection->session_handler;
        sh->keep_alive(sh, sn->connection);
        /*
         * keep the connection object
         * the sn->config is referenced by the connection, so we don't
         * unref it
         */
    } else {
        log_ereport(LOG_DEBUG, "trace reqid: %016llx connection destroyed | keep_alive failed", (unsigned long long int)sn->connection->id);
        connection_destroy(sn->connection);
    }
    
    // free all memory 
    free(sn->netbuf->inbuf);
    free(sn->netbuf);
    
    pool_destroy(sn->sn.pool);
    
    return 0;
}

void request_free_resources(NSAPISession *sn, NSAPIRequest *rq) {
    if(!rq->resources) return;
    
    CxIterator i = cxMapIteratorValues(rq->resources);
    cx_foreach(ResourceData *, resource, i) {
        resourcepool_free(&sn->sn, &rq->rq, resource);
    }
}

int nsapi_authtrans(NSAPISession *sn, NSAPIRequest *rq) {
    HTTPObjectConfig *objconf = rq->vs->objects;
    httpd_object *obj = objconf->objects[0];
    dtable *dt = object_get_dtable(obj, NSAPIAuthTrans);

    int ret = rq->context.last_req_code;
    for(int i=NCX_DI(rq);i<dt->ndir;i++) {
        if(ret == REQ_NOACTION) {
            directive *d = dt->dirs[i];
            ret = nsapi_exec(d, sn, rq);
        }
        
        if(ret != REQ_NOACTION) {
            /*
             * if a saf is still processing, we need to save the context, to
             * process this object at a later time
             */
            if(ret == REQ_PROCESSING) {
                // save nsapi context
                // add +1 to start next round with next function
                rq->context.dtable_index = i + 1;
            }

            return ret;
        }
    }


    return REQ_PROCEED;
}

int nsapi_nametrans(NSAPISession *sn, NSAPIRequest *rq) {
    HTTPObjectConfig *objconf = rq->vs->objects;
    //printf("nsapi_nametrans\n");
    httpd_objset *objset = objset_create(sn->sn.pool);
    rq->rq.os = objset;
    // first object in objconf is the default object  TODO: make sure it is
    objset_add_object(sn->sn.pool, objset, objconf->objects[0]);

    httpd_object *obj = objset->obj[0]; // nametrans only in default object
    dtable *dt = object_get_dtable(obj, NSAPINameTrans);

    // execute directives
    int ret = rq->context.last_req_code;
    char *name = NULL;
    char *ppath = NULL;
    for(int i=NCX_DI(rq);i<dt->ndir;i++) {
        if(ret == REQ_NOACTION) {
            directive *d = dt->dirs[i];
            ret = nsapi_exec(d, sn, rq);
        }

        // check for name or ppath
        name = pblock_findkeyval(pb_key_name, rq->rq.vars);
        ppath = pblock_findkeyval(pb_key_ppath, rq->rq.vars);

        // add additional objects to the objset
        if(add_objects(objconf, objset, sn, rq, name, ppath) == REQ_ABORTED) {
            log_ereport(LOG_FAILURE, "add_objects failed");
            return REQ_ABORTED;
        }

        if(ret != REQ_NOACTION) {
            /*
             * if a saf is still processing, we need to save the context, to
             * process this object at a later time
             */
            if(ret == REQ_PROCESSING) {
                // save nsapi context
                // add +1 to start next round with next function
                rq->context.dtable_index = i + 1;
            } else if(ret == REQ_PROCEED) {
                char *pp = pblock_findkeyval(pb_key_ppath, rq->rq.vars);
                pblock_kvinsert(pb_key_path, pp, strlen(pp), rq->rq.vars);
            }

            return ret;
        }
    }

    // if no function has set the ppath var, translate it to docroot
    if(ret == REQ_NOACTION && ppath == NULL) {
        cxmutstr docroot = rq->vs->document_root;
        if(docroot.length < 1) {
            log_ereport(
                    LOG_WARN,
                    "VirtualServer(%.*s) docroot too short",
                    (int)rq->vs->name.length,
                    rq->vs->name.ptr);
            return REQ_ABORTED; // docroot too short
        }
        
        // if there is a trailing '/', remove it
        /*
        if(docroot.ptr[docroot.length - 1] == '/') {
            docroot.length--;
        }
        
        cxmutstr uri = cx_str(pblock_findkeyval(pb_key_uri, rq->rq.reqpb));
        
        cxmutstr translated;
        translated.length = docroot.length + uri.length;
        translated.ptr = alloca(translated.length + 1);
        translated = cx_strncat(translated, 2, docroot, uri);

        pblock_kvinsert(
            pb_key_ppath,
            translated.ptr,
            translated.length,
            rq->rq.vars);
        */
        cxstring uri = cx_str(pblock_findkeyval(pb_key_uri, rq->rq.reqpb));
        request_set_path(cx_strcast(docroot), uri, rq->rq.vars);
    }
    
    // TODO: remove ppath
    char *pp = pblock_findkeyval(pb_key_ppath, rq->rq.vars);
    pblock_kvinsert(pb_key_path, pp, strlen(pp), rq->rq.vars);

    return REQ_PROCEED;
}

int nsapi_pathcheck(NSAPISession *sn, NSAPIRequest *rq) {
    //printf("nsapi_pathcheck\n");
    httpd_objset *objset = rq->rq.os;

    if(NCX_OI(rq) == -1) {
        NCX_OI(rq) = objset->pos - 1;
    }

    int ret = rq->context.last_req_code;
    for(int i=NCX_OI(rq);i>=0;i--) {
        httpd_object *obj = objset->obj[i];
        dtable *dt = object_get_dtable(obj, NSAPIPathCheck);

        // execute directives
        for(int j=NCX_DI(rq);j<dt->ndir;j++) {
            if(ret == REQ_NOACTION || ret == REQ_PROCEED) {
                directive *d = dt->dirs[j];
                ret = nsapi_exec(d, sn, rq);
            } else {
                if(ret == REQ_PROCESSING) {
                    // save nsapi context
                    rq->context.objset_index = i;

                    // add +1 to start next round with next function
                    rq->context.dtable_index = j + 1;
                }

                return ret;
            }
        }
    }

    return REQ_PROCEED;
}

int nsapi_objecttype(NSAPISession *sn, NSAPIRequest *rq) {
    //printf("nsapi_objecttype\n");
    httpd_objset *objset = rq->rq.os;

    if(NCX_OI(rq) == -1) {
        // object index is undefined -> define correct object index
        NCX_OI(rq) = objset->pos - 1;
    }

    int ret = rq->context.last_req_code;
    for(int i=NCX_OI(rq);i>=0;i--) {
        httpd_object *obj = objset->obj[i];
        dtable *dt = object_get_dtable(obj, NSAPIObjectType);

        // execute directives
        for(int j=NCX_DI(rq);j<dt->ndir;j++) {
            if(ret == REQ_NOACTION) {
                directive *d = dt->dirs[j];
                ret = nsapi_exec(d, sn, rq);
            }
            
            switch(ret) {
                case REQ_PROCEED: {
                    char *type = pblock_findkeyval(
                            pb_key_content_type,
                            rq->rq.srvhdrs);
                    if(type == NULL) {
                        ret = REQ_NOACTION;
                        break;
                    }
                    return ret;
                }
                case REQ_PROCESSING: {
                    // save nsapi context
                    rq->context.objset_index = i;

                    // add +1 to start next round with next function
                    rq->context.dtable_index = j + 1;
                    return ret;
                }
                case REQ_NOACTION: {
                    break;
                }
                default: {
                    return ret;
                }
            }
        }
    }

    /*
     * No function returned with REQ_PROCEED, but we need a content type.
     * If the path ends with a '/', we set the content type to
     * 'internal/directory' so that 'index-common' can serve the content.
     * Otherwise we set the content type to text/plain
     */
    cxstring path = cx_str(pblock_findkeyval(pb_key_ppath, rq->rq.vars));
    cxstring ct;
    if(path.ptr[path.length - 1] == '/') {
        // directory
        ct = (cxstring)CX_STR("internal/directory");
    } else {
        ct = (cxstring)CX_STR("text/plain");
    }
    pblock_kvinsert(pb_key_content_type, ct.ptr, ct.length, rq->rq.srvhdrs);

    return REQ_PROCEED;
}

int nsapi_service(NSAPISession *sn, NSAPIRequest *rq) {
    //printf("nsapi_service\n");
    httpd_objset *objset = rq->rq.os;

    if(NCX_OI(rq) == -1) {
        NCX_OI(rq) = objset->pos - 1;
    }

    int ret = rq->context.last_req_code;
    char *content_type = NULL;
    char *method = NULL;
    for(int i=NCX_OI(rq);i>=0;i--) {
        httpd_object *obj = objset->obj[i];   
        dtable *dt = object_get_dtable(obj, NSAPIService);

        // execute directives
        for(int j=NCX_DI(rq);j<dt->ndir;j++) {
            if(ret == REQ_NOACTION) {
                directive *d = dt->dirs[j];

                // check type parameter          
                char *dtp = pblock_findkeyval(pb_key_type, d->param);
                if(dtp) {
                    // type parameter for directive
                    if(!content_type) {
                        content_type = pblock_findkeyval(
                                pb_key_content_type,
                                rq->rq.srvhdrs);
                    }
                    // compare types
                    if(!contenttype_match(cx_str(dtp), cx_str(content_type))) {
                        continue;
                    }
                }

                // check method parameter
                char *dmt = pblock_findkeyval(pb_key_method, d->param);
                if(dmt) {
                    if(!method) {
                        method = pblock_findkeyval(pb_key_method, rq->rq.reqpb);
                    }
                    
                    if(!method_match(dmt, method)) {
                        continue;
                    }
                }

                // execute the saf
                ret = nsapi_exec(d, sn, rq);
            }
            
            if(ret != REQ_NOACTION) {
                if(ret == REQ_PROCEED && !rq->rq.senthdrs) {
                    // a service SAF must send a response
                    // senthdrs == 0 indicators something has gone
                    // wrong
                    protocol_status(&sn->sn, &rq->rq, 500, NULL);
                    ret = REQ_ABORTED;
                } else if(ret == REQ_PROCESSING) {
                    // save nsapi context
                    rq->context.objset_index = i;

                    // add +1 to start next round with next function
                    rq->context.dtable_index = j + 1;
                }

                return ret;
            }
        }
    }

    return ret;
}

int nsapi_error(NSAPISession *sn, NSAPIRequest *rq) {
    //printf("nsapi_error\n");
    httpd_objset *objset = rq->rq.os;

    if(NCX_OI(rq) == -1) {
        NCX_OI(rq) = objset->pos - 1;
    }

    int ret = rq->context.last_req_code;
    for(int i=NCX_OI(rq);i>=0;i--) {
        httpd_object *obj = objset->obj[i];   
        dtable *dt = object_get_dtable(obj, NSAPIError);

        // execute directives
        for(int j=NCX_DI(rq);j<dt->ndir;j++) {
            if(ret == REQ_NOACTION) {
                directive *d = dt->dirs[j];

                // check status code parameter
                // Error SAFs can specify, for which status code they should
                // be executed
                char *status = pblock_findkeyval(pb_key_type, d->param);
                if(status) {
                    int64_t statuscode = -1;
                    if(!util_strtoint(status, &statuscode)) {
                        log_ereport(
                                LOG_WARN,
                                "nsapi_error: directive '%s' ignored: invalid type parameter: integer status code expected",
                                d->func->name);
                    } else if(statuscode != rq->rq.status_num) {
                        continue;
                    }
                }

                // execute the saf
                ret = nsapi_exec(d, sn, rq);
            }
            
            if(ret == REQ_ABORTED) {
                // if an error directive fails, we use the default
                // error handler
                break;
            }
            if(ret != REQ_NOACTION) {
                if(ret == REQ_PROCEED) {
                    // flush buffer and add termination if chunked encoding
                    // is enabled
                    net_finish(sn->sn.csd);
                } else if(ret == REQ_PROCESSING) {
                    // save nsapi context
                    rq->context.objset_index = i;

                    // add +1 to start next round with next function
                    rq->context.dtable_index = j + 1;
                }
                return ret;
            }
        }
    }
    
    if(ret != REQ_PROCEED) {
        // default error handler
        if(!rq->rq.senthdrs) {
            nsapi_error_request((Session*)sn, (Request*)rq);
        }
    }

    return ret;
}

int nsapi_addlog(NSAPISession *sn, NSAPIRequest *rq) {
    //printf("nsapi_addlog\n");
    httpd_objset *objset = rq->rq.os;

    if(NCX_OI(rq) == -1) {
        NCX_OI(rq) = objset->pos - 1;
    }

    int ret = rq->context.last_req_code;
    for(int i=NCX_OI(rq);i>=0;i--) {
        httpd_object *obj = objset->obj[i];
        dtable *dt = object_get_dtable(obj, NSAPIAddLog);

        // execute directives
        for(int j=NCX_DI(rq);j<dt->ndir;j++) {
            if(ret == REQ_NOACTION) {
                directive *d = dt->dirs[j];
                ret = nsapi_exec(d, sn, rq);
            }
            
            if(ret != REQ_NOACTION) {
                if(ret == REQ_PROCESSING) {
                    // save nsapi context
                    rq->context.objset_index = i;

                    // add +1 to start next round with next function
                    rq->context.dtable_index = j + 1;
                }

                return ret;
            }
        }
    }

    return REQ_PROCEED;
}

struct _tpd_data {
    NSAPISession *sn;
    NSAPIRequest *rq;
    directive    *directive;
    threadpool_t *threadpool;
};

int nsapi_exec(directive *d, NSAPISession *sn, NSAPIRequest *rq) {
    // TODO: condition
    if(d->cond) {
        if(!condition_evaluate(d->cond, (Session*)sn, (Request*)rq)) {
            return REQ_NOACTION;
        }
    }
    
    char *poolname = pblock_findkeyval(pb_key_pool, d->param);
    if(poolname) {
        threadpool_t *pool = get_threadpool(cx_str(poolname));
        if(pool && pool != sn->currentpool) {
            // execute directive in different thread pool
            return nsapi_exec_tp(d, sn, rq, pool);
        }
    } else if(sn->currentpool != sn->defaultpool) {
        // if no pool is set, use always the default thread pool
        return nsapi_exec_tp(d, sn, rq, sn->defaultpool);
    }
    
    return SAF_EXEC(d->func, d->param, (Session*)sn, (Request*)rq);
}

int nsapi_exec_tp(
        directive *d,
        NSAPISession *sn,
        NSAPIRequest *rq,
        threadpool_t *pool)
{
    struct  _tpd_data *data = malloc(sizeof(struct _tpd_data));
    if(data == NULL) {
        // TODO: set error
        return REQ_ABORTED;
    }
    data->sn = sn;
    data->rq = rq;
    data->directive  = d;
    data->threadpool = pool;
    
    sn->currentpool = pool;
    threadpool_run(pool, thrpool_exec, data);
    
    return REQ_PROCESSING;
}

void nsapi_saf_return(Session *session, Request *request, int ret) {
    NSAPISession *sn = (NSAPISession*)session;
    NSAPIRequest *rq = (NSAPIRequest*)request;
    
    rq->context.last_req_code = ret;
    
    if(sn->currentpool != sn->defaultpool) {
        nsapi_change_threadpool(sn, rq, sn->defaultpool);
    } else {
        nsapi_handle_request(sn, rq);
    }
}

void nsapi_function_return(Session *session, Request *request, int ret) {
    ev_saf_return(session->ev, session, request, ret);
}

void nsapi_change_threadpool(
        NSAPISession *sn,
        NSAPIRequest *rq,
        threadpool_t *thrpool)
{ 
    struct  _tpd_data *data = malloc(sizeof(struct _tpd_data));
    data->sn = sn;
    data->rq = rq;
    data->threadpool = thrpool;
    
    threadpool_run(thrpool, thrpool_change, data);
}

void* thrpool_exec(void *d) {
    struct _tpd_data *data = d;
    
    data->sn->currentpool = data->threadpool;
    int r = SAF_EXEC(
            data->directive->func,
            data->directive->param,
            (Session*)data->sn,
            (Request*)data->rq);
    
    nsapi_function_return((Session*)data->sn, (Request*)data->rq, r);
    free(data);
    
    return NULL;
}

void* thrpool_change(void *d) {
    struct _tpd_data *data = d;
    
    data->sn->currentpool = data->threadpool;
    nsapi_handle_request(data->sn, data->rq);
    
    free(data);
    return NULL;
}


/*
 * checks if the method matches the cmp string
 * the format of cmp is a single method string or a list of methods
 * (method1|method2|method3|...)
 */
int method_match(char *cmp, char *method) {
    if(cmp[0] != '(') {
        /* not a list of methods, so just compare the 2 strings */
        if(!strcmp(cmp, method)) {
            return 1;
        }
    } else if(cmp[0] == 0) {
        // empty string
        log_ereport(
                LOG_WARN,
                "Skipped service saf with empty method parameter");
        return 0;
    }

    size_t method_len = strlen(method);
    size_t last_pos = 0;
    cmp++; /* skip '(' */
    for(int i=0;cmp[i]!=0;i++) {
        char c = cmp[i];
        if(c == '|' || c == ')') {
            size_t len = i - last_pos;
            if(len == method_len) {
                char *cp = cmp + last_pos;
                if(!memcmp(cp, method, len)) {
                    return 1;
                }
            }
            last_pos = i + 1;
        }
    }

    return 0;
}

/*
 * checks if the content type matches the cmp string
 * the format of cmp is a single string with wildcards or a list
 * of types (also with wildcard support)
 * (type1|type2*)
 */
int contenttype_match(cxstring cmp, cxstring ctype) {
    if(cmp.ptr[0] != '(') {
        if(cmp.ptr[0] == '*') {
            cmp.ptr++;
            cmp.length--;
            return cx_strsuffix(ctype, cmp);
        } else if(cmp.ptr[cmp.length-1] == '*') {
            cmp.length--;
            return cx_strprefix(ctype, cmp);
        } else {
            return !cx_strcmp(cmp, ctype);
        }
    } else if(cmp.ptr[0] == 0) {
        log_ereport(LOG_WARN, "Skipped service saf with empty type parameter");
        return 0;
    }
    
    cmp = cx_strsubsl(cmp, 1, cmp.length - 2);
    
    int begin = 0;
    for(int i=0;i<cmp.length;i++) {
        if(cmp.ptr[i] == '|') {
            if(contenttype_match(cx_strsubsl(cmp, begin, i-begin), ctype)) {
                return 1;
            }
            begin = i + 1;
        }
    }
    return contenttype_match(cx_strsubs(cmp, begin), ctype);
}

/*
 * adds objects with specific name or path to the httpd_objset
 */
int add_objects(
        HTTPObjectConfig *objs,
        httpd_objset *os,
        NSAPISession *sn,
        NSAPIRequest *rq,
        char *name,
        char *path)
{
    /* first, add all objects with a matching path */
    /* TODO */


    /* add object with object with matching name */
    if(name == NULL) {
        return REQ_PROCEED;
    }

    for(int i=0;i<objs->nobj;i++) {
        httpd_object *obj = objs->objects[i];

        if(obj->name && !strcmp(name, obj->name)) {
            objset_add_object(sn->sn.pool, os, obj);
        }
    } 

    return REQ_PROCEED;
}