/**

* 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 "apr_thread_mutex.h"

#include "apr_pools.h"

#include "apr_optional.h"

/* getpid for *NIX vs Windows */

#if APR_HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#if APR_HAVE_PROCESS_H

#include <process.h>

#endif

#if APR_HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <string.h>

#include <stdlib.h>

#include <ctype.h>

#include "mod_lua.h"

#include "lua_apr.h"

#include "lua_config.h"

#include "mod_auth.h"

#include "util_mutex.h"

#ifdef APR_HAS_THREADS

#include "apr_thread_proc.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)

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("<h3>Error!</h3>\n", r);

ap_rputs("<pre>", r);

lua_response = lua_tostring(L, -1);

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

ap_rputs("</pre>\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,

"%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);

apr_pool_tag(pool, "mod_lua-vm");

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,

"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, "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, nres;

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, &nres);

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, nres;

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, &nres) == LUA_YIELD && nres == 1) {

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, &nres) == LUA_YIELD && nres == 1) {

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, nres;

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, &nres) == LUA_YIELD && nres == 1) {

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, &nres) == LUA_YIELD && nres == 1) {

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) {

i = strlen(buf);

if (i && buf[i - 1] == '\n')

++cfg->line_number;

}

else {

buf[0] = '\0';

i = 0;

}

}

else {

while (i < bufsiz) {

char ch;

apr_status_t rc = (cfg->getch) (&ch, cfg->param);

if (rc != APR_SUCCESS)

break;

buf[i++] = ch;

if (ch == '\n') {

++cfg->line_number;

break;

}

}

}

return i;

}

typedef struct cr_ctx

{

cmd_parms *cmd;

ap_configfile_t *cfp;

size_t startline;

const char *endstr;

char buf[HUGE_STRING_LEN];

} cr_ctx;

/* Okay, this deserves a little explanation -- in order for the errors that lua

* generates to be 'accuarate', including line numbers, we basically inject

* N line number new lines into the 'top' of the chunk reader.....

*

* be happy. this is cool.

*

*/

static const char *lf =

"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n";

#define N_LF 32

static const char *direct_chunkreader(lua_State *lvm, void *udata,

size_t *plen)

{

const char *p;

struct cr_ctx *ctx = udata;

if (ctx->startline) {

*plen = ctx->startline > N_LF ? N_LF : ctx->startline;

ctx->startline -= *plen;

return lf;

}

*plen = config_getstr(ctx->cfp, ctx->buf, HUGE_STRING_LEN);

for (p = ctx->buf; isspace(*p); ++p);

if (p[0] == '<' && p[1] == '/') {

apr_size_t i = 0;

while (i < strlen(ctx->endstr)) {

if (tolower(p[i + 2]) != ctx->endstr[i])

return ctx->buf;

++i;

}

*plen = 0;

return NULL;

}

/*fprintf(stderr, "buf read: %s\n", ctx->buf); */

return ctx->buf;

}

static int ldump_writer(lua_State *L, const void *b, size_t size, void *B)

{

(void) L;

luaL_addlstring((luaL_Buffer *) B, (const char *) b, size);

return 0;

}

typedef struct hack_section_baton

{

const char *name;

ap_lua_mapped_handler_spec *spec;

int apr_hook_when;

} hack_section_baton;

/* You can be unhappy now.

*

* This is uncool.

*

* When you create a <Section handler in httpd, the only 'easy' way to create

* a directory context is to parse the section, and convert it into a 'normal'

* Configureation option, and then collapse the entire section, in memory,

* back into the parent section -- from which you can then get the new directive

* invoked.... anyways. evil. Rici taught me how to do this hack :-)

*/

static const char *hack_section_handler(cmd_parms *cmd, void *_cfg,

const char *arg)

{

ap_lua_dir_cfg *cfg = (ap_lua_dir_cfg *) _cfg;

ap_directive_t *directive = cmd->directive;

hack_section_baton *baton = directive->data;

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

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

APR_HASH_KEY_STRING);

if (!hook_specs) {

hook_specs = apr_array_make(cmd->pool, 2,

sizeof(ap_lua_mapped_handler_spec *));

apr_hash_set(cfg->hooks, key,

APR_HASH_KEY_STRING, hook_specs);

}

baton->spec->scope = cfg->vm_scope;

*(ap_lua_mapped_handler_spec **) apr_array_push(hook_specs) = baton->spec;

return NULL;

}

static const char *register_named_block_function_hook(const char *name,

cmd_parms *cmd,