/**

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (the "License"); you may not use this file except in compliance with

 * the License.  You may obtain a copy of the License at

 *

 * http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include "mod_lua.h"

#include <string.h>

#include <stdlib.h>

#include <ctype.h>

#include <apr_thread_mutex.h>

#include <apr_pools.h>

#include "lua_apr.h"

#include "lua_config.h"

#include "apr_optional.h"

#include "mod_ssl.h"

#include "mod_auth.h"

#include "util_mutex.h"

#ifdef APR_HAS_THREADS

#include "apr_thread_proc.h"

#endif

/* getpid for *NIX */

#if APR_HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#if APR_HAVE_UNISTD_H

#include <unistd.h>

#endif

/* getpid for Windows */

#if APR_HAVE_PROCESS_H

#include <process.h>

#endif

APR_IMPLEMENT_OPTIONAL_HOOK_RUN_ALL(ap_lua, AP_LUA, int, lua_open,

                                    (lua_State *L, apr_pool_t *p),

                                    (L, p), OK, DECLINED)

APR_IMPLEMENT_OPTIONAL_HOOK_RUN_ALL(ap_lua, AP_LUA, int, lua_request,

                                    (lua_State *L, request_rec *r),

                                    (L, r), OK, DECLINED)

static APR_OPTIONAL_FN_TYPE(ssl_var_lookup) *lua_ssl_val = NULL;

static APR_OPTIONAL_FN_TYPE(ssl_is_https) *lua_ssl_is_https = NULL;

module AP_MODULE_DECLARE_DATA lua_module;

#define AP_LUA_HOOK_FIRST (APR_HOOK_FIRST - 1)

#define AP_LUA_HOOK_LAST  (APR_HOOK_LAST  + 1)

typedef struct {

    const char *name;

    const char *file_name;

    const char *function_name;

    ap_lua_vm_spec *spec;

} lua_authz_provider_spec;

typedef struct {

    lua_authz_provider_spec *spec;

    apr_array_header_t *args;

} lua_authz_provider_func;

apr_hash_t *lua_authz_providers;

typedef struct

{

    apr_bucket_brigade *tmpBucket;

    lua_State *L;

    ap_lua_vm_spec *spec;

    int broken;

} lua_filter_ctx;

#define DEFAULT_LUA_SHMFILE "lua_ivm_shm"

apr_global_mutex_t *lua_ivm_mutex;

apr_shm_t *lua_ivm_shm;

char *lua_ivm_shmfile;

static apr_status_t shm_cleanup_wrapper(void *unused)

{

    if (lua_ivm_shm) {

        return apr_shm_destroy(lua_ivm_shm);

    }

    return OK;

}

/**

 * error reporting if lua has an error.

 * Extracts the error from lua stack and prints

 */

static void report_lua_error(lua_State *L, request_rec *r)

{

    const char *lua_response;

    r->status = HTTP_INTERNAL_SERVER_ERROR;

    r->content_type = "text/html";

    ap_rputs("
Error!
\n", r);

    ap_rputs("
", r);

    lua_response = lua_tostring(L, -1);

    ap_rputs(ap_escape_html(r->pool, lua_response), r);

    ap_rputs("\n", r);

    ap_log_perror(APLOG_MARK, APLOG_WARNING, 0, r->pool, APLOGNO(01471) "Lua error: %s",

                  lua_response);

}

static void lua_open_callback(lua_State *L, apr_pool_t *p, void *ctx)

{

    ap_lua_init(L, p);

    ap_lua_load_apache2_lmodule(L);

    ap_lua_load_request_lmodule(L, p);

    ap_lua_load_config_lmodule(L);

}

static int lua_open_hook(lua_State *L, apr_pool_t *p)

{

    lua_open_callback(L, p, NULL);

    return OK;

}

static const char *scope_to_string(unsigned int scope)

{

    switch (scope) {

    case AP_LUA_SCOPE_ONCE:

    case AP_LUA_SCOPE_UNSET:

        return "once";

    case AP_LUA_SCOPE_REQUEST:

        return "request";

    case AP_LUA_SCOPE_CONN:

        return "conn";

#if APR_HAS_THREADS

    case AP_LUA_SCOPE_THREAD:

        return "thread";

    case AP_LUA_SCOPE_SERVER:

        return "server";

#endif

    default:

        ap_assert(0);

        return 0;

    }

}

static void ap_lua_release_state(lua_State* L, ap_lua_vm_spec* spec, request_rec* r)

{

    char *hash;

    apr_reslist_t* reslist = NULL;

    if (spec->scope == AP_LUA_SCOPE_SERVER) {

        ap_lua_server_spec* sspec = NULL;

        lua_settop(L, 0);

        lua_getfield(L, LUA_REGISTRYINDEX, "Apache2.Lua.server_spec");

        sspec = (ap_lua_server_spec*) lua_touserdata(L, 1);

        hash = apr_psprintf(r->pool, "reslist:%s", spec->file);

        if (apr_pool_userdata_get((void **)&reslist, hash,

                                r->server->process->pool) == APR_SUCCESS) {

            AP_DEBUG_ASSERT(sspec != NULL);

            if (reslist != NULL) {

                apr_reslist_release(reslist, sspec);

            }

        }

    }

}

static ap_lua_vm_spec *create_vm_spec(apr_pool_t **lifecycle_pool,

                                      request_rec *r,

                                      const ap_lua_dir_cfg *cfg,

                                      const ap_lua_server_cfg *server_cfg,

                                      const char *filename,

                                      const char *bytecode,

                                      apr_size_t bytecode_len,

                                      const char *function,

                                      const char *what)

{

    apr_pool_t *pool;

    ap_lua_vm_spec *spec = apr_pcalloc(r->pool, sizeof(ap_lua_vm_spec));

    spec->scope = cfg->vm_scope;

    spec->pool = r->pool;

    spec->package_paths = cfg->package_paths;

    spec->package_cpaths = cfg->package_cpaths;

    spec->cb = &lua_open_callback;

    spec->cb_arg = NULL;

    spec->bytecode = bytecode;

    spec->bytecode_len = bytecode_len;

    spec->codecache = (cfg->codecache == AP_LUA_CACHE_UNSET) ? AP_LUA_CACHE_STAT : cfg->codecache;

    spec->vm_min = cfg->vm_min ? cfg->vm_min : 1;

    spec->vm_max = cfg->vm_max ? cfg->vm_max : 1;

    if (filename) {

        char *file;

        apr_filepath_merge(&file, server_cfg->root_path,

                           filename, APR_FILEPATH_NOTRELATIVE, r->pool);

        spec->file = file;

    }

    else {

        spec->file = r->filename;

    }

    ap_log_rerror(APLOG_MARK, APLOG_TRACE2, 0, r, APLOGNO(02313)

                  "%s details: scope: %s, file: %s, func: %s",

                  what, scope_to_string(spec->scope), spec->file,

                  function ? function : "-");

    switch (spec->scope) {

    case AP_LUA_SCOPE_ONCE:

    case AP_LUA_SCOPE_UNSET:

        apr_pool_create(&pool, r->pool);

        break;

    case AP_LUA_SCOPE_REQUEST:

        pool = r->pool;

        break;

    case AP_LUA_SCOPE_CONN:

        pool = r->connection->pool;

        break;

#if APR_HAS_THREADS

    case AP_LUA_SCOPE_THREAD:

        pool = apr_thread_pool_get(r->connection->current_thread);

        break;

    case AP_LUA_SCOPE_SERVER:

        pool = r->server->process->pool;

        break;

#endif

    default:

        ap_assert(0);

    }

    *lifecycle_pool = pool;

    return spec;

}

static const char* ap_lua_interpolate_string(apr_pool_t* pool, const char* string, const char** values)

{

    char *stringBetween;

    const char* ret;

    int srclen,x,y;

    srclen = strlen(string);

    ret = "";

    y = 0;

    for (x=0; x < srclen; x++) {

        if (string[x] == '$' && x != srclen-1 && string[x+1] >= '0' && string[x+1] <= '9') {

            int v = *(string+x+1) - '0';

            if (x-y > 0) {

                stringBetween = apr_pstrndup(pool, string+y, x-y);

            }

            else {

                stringBetween = "";

            }

            ret = apr_pstrcat(pool, ret, stringBetween, values[v], NULL);

            y = ++x+1;

        }

    }

    if (x-y > 0 && y > 0) {

        stringBetween = apr_pstrndup(pool, string+y, x-y);

        ret = apr_pstrcat(pool, ret, stringBetween, NULL);

    }

    /* If no replacement was made, just return the original string */

    else if (y == 0) {

        return string;

    }

    return ret;

}

/**

 * "main"

 */

static int lua_handler(request_rec *r)

{

    int rc = OK;

    if (strcmp(r->handler, "lua-script")) {

        return DECLINED;

    }

    /* Decline the request if the script does not exist (or is a directory),

     * rather than just returning internal server error */

    if (

            (r->finfo.filetype == APR_NOFILE)

            || (r->finfo.filetype & APR_DIR)

        ) {

        return DECLINED;

    }

    ap_log_rerror(APLOG_MARK, APLOG_TRACE1, 0, r, APLOGNO(01472)

                  "handling [%s] in mod_lua", r->filename);

    /* XXX: This seems wrong because it may generate wrong headers for HEAD requests */

    if (!r->header_only) {

        lua_State *L;

        apr_pool_t *pool;

        const ap_lua_dir_cfg *cfg = ap_get_module_config(r->per_dir_config,

                                                         &lua_module);

        ap_lua_vm_spec *spec = create_vm_spec(&pool, r, cfg, NULL, NULL, NULL,

                                              0, "handle", "request handler");

        L = ap_lua_get_lua_state(pool, spec, r);

        if (!L) {

            /* TODO annotate spec with failure reason */

            r->status = HTTP_INTERNAL_SERVER_ERROR;

            ap_rputs("Unable to compile VM, see logs", r);

            ap_lua_release_state(L, spec, r);

            return HTTP_INTERNAL_SERVER_ERROR;

        }

        ap_log_rerror(APLOG_MARK, APLOG_TRACE3, 0, r, APLOGNO(01474) "got a vm!");

        lua_getglobal(L, "handle");

        if (!lua_isfunction(L, -1)) {

            ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, APLOGNO(01475)

                          "lua: Unable to find entry function '%s' in %s (not a valid function)",

                          "handle",

                          spec->file);

            ap_lua_release_state(L, spec, r);

            return HTTP_INTERNAL_SERVER_ERROR;

        }

        ap_lua_run_lua_request(L, r);

        if (lua_pcall(L, 1, 1, 0)) {

            report_lua_error(L, r);

        }

        if (lua_isnumber(L, -1)) {

            rc = lua_tointeger(L, -1);

        }

        ap_lua_release_state(L, spec, r);

    }

    return rc;

}

/* ------------------- Input/output content filters ------------------- */

static apr_status_t lua_setup_filter_ctx(ap_filter_t* f, request_rec* r, lua_filter_ctx** c)

{

    apr_pool_t *pool;

    ap_lua_vm_spec *spec;

    int n, rc;

    lua_State *L;

    lua_filter_ctx *ctx;    

    ap_lua_server_cfg *server_cfg = ap_get_module_config(r->server->module_config,

                                                        &lua_module);

    const ap_lua_dir_cfg *cfg = ap_get_module_config(r->per_dir_config,

                                                    &lua_module);

    ctx = apr_pcalloc(r->pool, sizeof(lua_filter_ctx));

    ctx->broken = 0;

    *c = ctx;

    /* Find the filter that was called.

     * XXX: If we were wired with mod_filter, the filter (mod_filters name)

     *      and the provider (our underlying filters name) need to have matched.

     */

    for (n = 0; n < cfg->mapped_filters->nelts; n++) {

        ap_lua_filter_handler_spec *hook_spec =

            ((ap_lua_filter_handler_spec **) cfg->mapped_filters->elts)[n];

        if (hook_spec == NULL) {

            continue;

        }

        if (!strcasecmp(hook_spec->filter_name, f->frec->name)) {

            spec = create_vm_spec(&pool, r, cfg, server_cfg,

                                    hook_spec->file_name,

                                    NULL,

                                    0,

                                    hook_spec->function_name,

                                    "filter");

            L = ap_lua_get_lua_state(pool, spec, r);

            if (L) {

                L = lua_newthread(L);

            }

            if (!L) {

                ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, APLOGNO(02328)

                                "lua: Failed to obtain lua interpreter for %s %s",

                                hook_spec->function_name, hook_spec->file_name);

                ap_lua_release_state(L, spec, r);

                return APR_EGENERAL;

            }

            if (hook_spec->function_name != NULL) {

                lua_getglobal(L, hook_spec->function_name);

                if (!lua_isfunction(L, -1)) {

                    ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, APLOGNO(02329)

                                "lua: Unable to find entry function '%s' in %s (not a valid function)",

                                    hook_spec->function_name,

                                    hook_spec->file_name);

                    ap_lua_release_state(L, spec, r);

                    return APR_EGENERAL;

                }

                ap_lua_run_lua_request(L, r);

            }

            else {

                int t;

                ap_lua_run_lua_request(L, r);

                t = lua_gettop(L);

                lua_setglobal(L, "r");

                lua_settop(L, t);

            }

            ctx->L = L;

            ctx->spec = spec;

            /* If a Lua filter is interested in filtering a request, it must first do a yield, 

             * otherwise we'll assume that it's not interested and pretend we didn't find it.

             */

            rc = lua_resume(L, 1);

            if (rc == LUA_YIELD) {

                if (f->frec->providers == NULL) { 

                    /* Not wired by mod_filter */

                    apr_table_unset(r->headers_out, "Content-Length");

                    apr_table_unset(r->headers_out, "Content-MD5");

                    apr_table_unset(r->headers_out, "ETAG");

                }

                return OK;

            }

            else {

                ap_lua_release_state(L, spec, r);

                return APR_ENOENT;

            }

        }

    }

    return APR_ENOENT;

}

static apr_status_t lua_output_filter_handle(ap_filter_t *f, apr_bucket_brigade *pbbIn)

{

    request_rec *r = f->r;

    int rc;

    lua_State *L;

    lua_filter_ctx* ctx;

    conn_rec *c = r->connection;

    apr_bucket *pbktIn;

    apr_status_t rv;

    /* Set up the initial filter context and acquire the function.

     * The corresponding Lua function should yield here.

     */

    if (!f->ctx) {

        rc = lua_setup_filter_ctx(f,r,&ctx;;

        if (rc == APR_EGENERAL) {

            return HTTP_INTERNAL_SERVER_ERROR;

        }

        if (rc == APR_ENOENT) {

            /* No filter entry found (or the script declined to filter), just pass on the buckets */

            ap_remove_output_filter(f);

            return ap_pass_brigade(f->next,pbbIn);

        }

        else { 

            /* We've got a willing lua filter, setup and check for a prefix */

            size_t olen;

            apr_bucket *pbktOut;

            const char* output = lua_tolstring(ctx->L, 1, &olen);

            f->ctx = ctx;

            ctx->tmpBucket = apr_brigade_create(r->pool, c->bucket_alloc);

            if (olen > 0) { 

                pbktOut = apr_bucket_heap_create(output, olen, NULL, c->bucket_alloc);

                APR_BRIGADE_INSERT_TAIL(ctx->tmpBucket, pbktOut);

                rv = ap_pass_brigade(f->next, ctx->tmpBucket);

                apr_brigade_cleanup(ctx->tmpBucket);

                if (rv != APR_SUCCESS) {

                    return rv;

                }

            }

        }

    }

    ctx = (lua_filter_ctx*) f->ctx;

    L = ctx->L;

    /* While the Lua function is still yielding, pass in buckets to the coroutine */

    if (!ctx->broken) {

        for (pbktIn = APR_BRIGADE_FIRST(pbbIn);

            pbktIn != APR_BRIGADE_SENTINEL(pbbIn);

            pbktIn = APR_BUCKET_NEXT(pbktIn))

            {

            const char *data;

            apr_size_t len;

            apr_bucket *pbktOut;

            /* read the bucket */

            apr_bucket_read(pbktIn,&data,&len,APR_BLOCK_READ);

            /* Push the bucket onto the Lua stack as a global var */

            lua_pushlstring(L, data, len);

            lua_setglobal(L, "bucket");

            /* If Lua yielded, it means we have something to pass on */

            if (lua_resume(L, 0) == LUA_YIELD) {

                size_t olen;

                const char* output = lua_tolstring(L, 1, &olen);

                if (olen > 0) { 

                    pbktOut = apr_bucket_heap_create(output, olen, NULL,

                                            c->bucket_alloc);

                    APR_BRIGADE_INSERT_TAIL(ctx->tmpBucket, pbktOut);

                    rv = ap_pass_brigade(f->next, ctx->tmpBucket);

                    apr_brigade_cleanup(ctx->tmpBucket);

                    if (rv != APR_SUCCESS) {

                        return rv;

                    }

                }

            }

            else {

                ctx->broken = 1;

                ap_lua_release_state(L, ctx->spec, r);

                ap_remove_output_filter(f);

                apr_brigade_cleanup(pbbIn);

                apr_brigade_cleanup(ctx->tmpBucket);

                ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(02663)

                              "lua: Error while executing filter: %s",

                              lua_tostring(L, -1));

                return HTTP_INTERNAL_SERVER_ERROR;

            }

        }

        /* If we've safely reached the end, do a final call to Lua to allow for any 

        finishing moves by the script, such as appending a tail. */

        if (APR_BUCKET_IS_EOS(APR_BRIGADE_LAST(pbbIn))) {

            apr_bucket *pbktEOS;

            lua_pushnil(L);

            lua_setglobal(L, "bucket");

            if (lua_resume(L, 0) == LUA_YIELD) {

                apr_bucket *pbktOut;

                size_t olen;

                const char* output = lua_tolstring(L, 1, &olen);

                if (olen > 0) { 

                    pbktOut = apr_bucket_heap_create(output, olen, NULL,

                            c->bucket_alloc);

                    APR_BRIGADE_INSERT_TAIL(ctx->tmpBucket, pbktOut);

                }

            }

            pbktEOS = apr_bucket_eos_create(c->bucket_alloc);

            APR_BRIGADE_INSERT_TAIL(ctx->tmpBucket, pbktEOS);

            ap_lua_release_state(L, ctx->spec, r);

            rv = ap_pass_brigade(f->next, ctx->tmpBucket);

            apr_brigade_cleanup(ctx->tmpBucket);

            if (rv != APR_SUCCESS) {

                return rv;

            }

        }

    }

    /* Clean up */

    apr_brigade_cleanup(pbbIn);

    return APR_SUCCESS;    

}

static apr_status_t lua_input_filter_handle(ap_filter_t *f,

                                       apr_bucket_brigade *pbbOut,

                                       ap_input_mode_t eMode,

                                       apr_read_type_e eBlock,

                                       apr_off_t nBytes) 

{

    request_rec *r = f->r;

    int rc, lastCall = 0;

    lua_State *L;

    lua_filter_ctx* ctx;

    conn_rec *c = r->connection;

    apr_status_t ret;

    /* Set up the initial filter context and acquire the function.

     * The corresponding Lua function should yield here.

     */

    if (!f->ctx) {

        rc = lua_setup_filter_ctx(f,r,&ctx;;

        f->ctx = ctx;

        if (rc == APR_EGENERAL) {

            ctx->broken = 1;

            ap_remove_input_filter(f); 

            return HTTP_INTERNAL_SERVER_ERROR;

        }

        if (rc == APR_ENOENT ) {

            ap_remove_input_filter(f);

            ctx->broken = 1;

        }

        if (rc == APR_SUCCESS) {

            ctx->tmpBucket = apr_brigade_create(r->pool, c->bucket_alloc);

        }

    }

    ctx = (lua_filter_ctx*) f->ctx;

    L = ctx->L;

    /* If the Lua script broke or denied serving the request, just pass the buckets through */

    if (ctx->broken) {

        return ap_get_brigade(f->next, pbbOut, eMode, eBlock, nBytes);

    }

    if (APR_BRIGADE_EMPTY(ctx->tmpBucket)) {

        ret = ap_get_brigade(f->next, ctx->tmpBucket, eMode, eBlock, nBytes);

        if (eMode == AP_MODE_EATCRLF || ret != APR_SUCCESS)

            return ret;

    }

    /* While the Lua function is still yielding, pass buckets to the coroutine */

    if (!ctx->broken) {

        lastCall = 0;

        while (!APR_BRIGADE_EMPTY(ctx->tmpBucket)) {

            apr_bucket *pbktIn = APR_BRIGADE_FIRST(ctx->tmpBucket);

            apr_bucket *pbktOut;

            const char *data;

            apr_size_t len;

            if (APR_BUCKET_IS_EOS(pbktIn)) {

                APR_BUCKET_REMOVE(pbktIn);

                break;

            }

            /* read the bucket */

            ret = apr_bucket_read(pbktIn, &data, &len, eBlock);

            if (ret != APR_SUCCESS)

                return ret;

            /* Push the bucket onto the Lua stack as a global var */

            lastCall++;

            lua_pushlstring(L, data, len);

            lua_setglobal(L, "bucket");

            /* If Lua yielded, it means we have something to pass on */

            if (lua_resume(L, 0) == LUA_YIELD) {

                size_t olen;

                const char* output = lua_tolstring(L, 1, &olen);

                pbktOut = apr_bucket_heap_create(output, olen, 0, c->bucket_alloc);

                APR_BRIGADE_INSERT_TAIL(pbbOut, pbktOut);

                apr_bucket_delete(pbktIn);

                return APR_SUCCESS;

            }

            else {

                ctx->broken = 1;

                ap_lua_release_state(L, ctx->spec, r);

                ap_remove_input_filter(f); 

                apr_bucket_delete(pbktIn);

                return HTTP_INTERNAL_SERVER_ERROR;

            }

        }

        /* If we've safely reached the end, do a final call to Lua to allow for any 

        finishing moves by the script, such as appending a tail. */

        if (lastCall == 0) {

            apr_bucket *pbktEOS = apr_bucket_eos_create(c->bucket_alloc);

            lua_pushnil(L);

            lua_setglobal(L, "bucket");

            if (lua_resume(L, 0) == LUA_YIELD) {

                apr_bucket *pbktOut;

                size_t olen;

                const char* output = lua_tolstring(L, 1, &olen);

                pbktOut = apr_bucket_heap_create(output, olen, 0, c->bucket_alloc);

                APR_BRIGADE_INSERT_TAIL(pbbOut, pbktOut);

            }

            APR_BRIGADE_INSERT_TAIL(pbbOut,pbktEOS);

            ap_lua_release_state(L, ctx->spec, r);

        }

    }

    return APR_SUCCESS;

}

/* ---------------- Configury stuff --------------- */

/** harnesses for magic hooks **/

static int lua_request_rec_hook_harness(request_rec *r, const char *name, int apr_hook_when)

{

    int rc;

    apr_pool_t *pool;

    lua_State *L;

    ap_lua_vm_spec *spec;

    ap_lua_server_cfg *server_cfg = ap_get_module_config(r->server->module_config,

                                                         &lua_module);

    const ap_lua_dir_cfg *cfg = ap_get_module_config(r->per_dir_config,

                                                     &lua_module);

    const char *key = apr_psprintf(r->pool, "%s_%d", name, apr_hook_when);

    apr_array_header_t *hook_specs = apr_hash_get(cfg->hooks, key,

                                                  APR_HASH_KEY_STRING);

    if (hook_specs) {

        int i;

        for (i = 0; i < hook_specs->nelts; i++) {

            ap_lua_mapped_handler_spec *hook_spec =

                ((ap_lua_mapped_handler_spec **) hook_specs->elts)[i];

            if (hook_spec == NULL) {

                continue;

            }

            spec = create_vm_spec(&pool, r, cfg, server_cfg,

                                  hook_spec->file_name,

                                  hook_spec->bytecode,

                                  hook_spec->bytecode_len,

                                  hook_spec->function_name,

                                  "request hook");

            L = ap_lua_get_lua_state(pool, spec, r);

            if (!L) {

                ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, APLOGNO(01477)

                    "lua: Failed to obtain lua interpreter for entry function '%s' in %s",

                              hook_spec->function_name, hook_spec->file_name);

                return HTTP_INTERNAL_SERVER_ERROR;

            }

            if (hook_spec->function_name != NULL) {

                lua_getglobal(L, hook_spec->function_name);

                if (!lua_isfunction(L, -1)) {

                    ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, APLOGNO(01478)

                               "lua: Unable to find entry function '%s' in %s (not a valid function)",

                                  hook_spec->function_name,

                                  hook_spec->file_name);

                    ap_lua_release_state(L, spec, r);

                    return HTTP_INTERNAL_SERVER_ERROR;

                }

                ap_lua_run_lua_request(L, r);

            }

            else {

                int t;

                ap_lua_run_lua_request(L, r);

                t = lua_gettop(L);

                lua_setglobal(L, "r");

                lua_settop(L, t);

            }

            if (lua_pcall(L, 1, 1, 0)) {

                report_lua_error(L, r);

                ap_lua_release_state(L, spec, r);

                return HTTP_INTERNAL_SERVER_ERROR;

            }

            rc = DECLINED;

            if (lua_isnumber(L, -1)) {

                rc = lua_tointeger(L, -1);

                ap_log_rerror(APLOG_MARK, APLOG_TRACE4, 0, r, "Lua hook %s:%s for phase %s returned %d", 

                              hook_spec->file_name, hook_spec->function_name, name, rc);

            }

            else { 

                ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, APLOGNO(03017)

                              "Lua hook %s:%s for phase %s did not return a numeric value",

                              hook_spec->file_name, hook_spec->function_name, name);

                return HTTP_INTERNAL_SERVER_ERROR;

            }

            if (rc != DECLINED) {

                ap_lua_release_state(L, spec, r);

                return rc;

            }

            ap_lua_release_state(L, spec, r);

        }

    }

    return DECLINED;

}

/* Fix for making sure that LuaMapHandler works when FallbackResource is set */

static int lua_map_handler_fixups(request_rec *r)

{

    /* If there is no handler set yet, this might be a LuaMapHandler request */

    if (r->handler == NULL) {

        int n = 0;

        ap_regmatch_t match[10];

        const ap_lua_dir_cfg *cfg = ap_get_module_config(r->per_dir_config,

                                                     &lua_module);

        for (n = 0; n < cfg->mapped_handlers->nelts; n++) {

            ap_lua_mapped_handler_spec *hook_spec =

            ((ap_lua_mapped_handler_spec **) cfg->mapped_handlers->elts)[n];

            if (hook_spec == NULL) {

                continue;

            }

            if (!ap_regexec(hook_spec->uri_pattern, r->uri, 10, match, 0)) {

                r->handler = apr_pstrdup(r->pool, "lua-map-handler");

                return OK;

            }

        }

    }

    return DECLINED;

}

static int lua_map_handler(request_rec *r)

{

    int rc, n = 0;

    apr_pool_t *pool;

    lua_State *L;

    const char *filename, *function_name;

    const char *values[10];

    ap_lua_vm_spec *spec;

    ap_regmatch_t match[10];

    ap_lua_server_cfg *server_cfg = ap_get_module_config(r->server->module_config,

                                                         &lua_module);

    const ap_lua_dir_cfg *cfg = ap_get_module_config(r->per_dir_config,

                                                     &lua_module);

    for (n = 0; n < cfg->mapped_handlers->nelts; n++) {

        ap_lua_mapped_handler_spec *hook_spec =

            ((ap_lua_mapped_handler_spec **) cfg->mapped_handlers->elts)[n];

        if (hook_spec == NULL) {

            continue;

        }

        if (!ap_regexec(hook_spec->uri_pattern, r->uri, 10, match, 0)) {

            int i;

            for (i=0 ; i < 10; i++) {

                if (match[i].rm_eo >= 0) {

                    values[i] = apr_pstrndup(r->pool, r->uri+match[i].rm_so, match[i].rm_eo - match[i].rm_so);

                }

                else values[i] = "";

            }

            filename = ap_lua_interpolate_string(r->pool, hook_spec->file_name, values);

            function_name = ap_lua_interpolate_string(r->pool, hook_spec->function_name, values);

            spec = create_vm_spec(&pool, r, cfg, server_cfg,

                                    filename,

                                    hook_spec->bytecode,

                                    hook_spec->bytecode_len,

                                    function_name,

                                    "mapped handler");

            L = ap_lua_get_lua_state(pool, spec, r);

            if (!L) {

                ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, APLOGNO(02330)

                                "lua: Failed to obtain Lua interpreter for entry function '%s' in %s",

                                function_name, filename);

                ap_lua_release_state(L, spec, r);

                return HTTP_INTERNAL_SERVER_ERROR;

            }

            if (function_name != NULL) {

                lua_getglobal(L, function_name);

                if (!lua_isfunction(L, -1)) {

                    ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, APLOGNO(02331)

                                    "lua: Unable to find entry function '%s' in %s (not a valid function)",

                                    function_name,

                                    filename);

                    ap_lua_release_state(L, spec, r);

                    return HTTP_INTERNAL_SERVER_ERROR;

                }

                ap_lua_run_lua_request(L, r);

            }

            else {

                int t;

                ap_lua_run_lua_request(L, r);

                t = lua_gettop(L);

                lua_setglobal(L, "r");

                lua_settop(L, t);

            }

            if (lua_pcall(L, 1, 1, 0)) {

                report_lua_error(L, r);

                ap_lua_release_state(L, spec, r);

                return HTTP_INTERNAL_SERVER_ERROR;

            }

            rc = DECLINED;

            if (lua_isnumber(L, -1)) {

                rc = lua_tointeger(L, -1);

            }

            else { 

                ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, APLOGNO(02483)

                              "lua: Lua handler %s in %s did not return a value, assuming apache2.OK",

                              function_name,

                              filename);

                rc = OK;

            }

            ap_lua_release_state(L, spec, r);

            if (rc != DECLINED) {

                return rc;

            }

        }

    }

    return DECLINED;

}

static apr_size_t config_getstr(ap_configfile_t *cfg, char *buf,

                                size_t bufsiz)

{

    apr_size_t i = 0;

    if (cfg->getstr) {

        apr_status_t rc = (cfg->getstr) (buf, bufsiz, cfg->param);

        if (rc == APR_SUCCESS) {